Gaussian blur

[siamirold]

This is a Gaussian blur shader and a collection made by it, the Gaussian blur is smoother than the native blur filter.

This is a very performance consuming shader. Please lower the value If lagging

Using the shader, I created an awesome collection.

It achieves a myopia like effect. It looks like you have watched too many porn and make yourself can't see anything clearly anymore. XD

Please note that collection is a full screen effect.
Besides, I uncensored the feet and the armpits to demonstrate my mercy

Any advice, pls come to Discord and DM Eilysia

Keeping censored and have fun !

       

[Wombatant1]

this thing devours gpu resources, but [gaussian blur] joined with bodyline clipping is one of the best combinations that i've tried in hotscreen

[bobbob9999]

I downloaded, and added myopia collection, but hotscreen doesn't enable the "edit collection" button with it turned off, and with it turned on my entire screen is blurry so I can't see the hotscreen controls for the collection.

What's the solution?

[whizzkid]

Is there a way to increase the blurring?

[whizzkid]

I played around with it a bit and added a toggle --> with the "Blur Regler" line you can adjust the blur.


shader_type canvas_item;

// =====================
// Gaussian Blur (Original + extrem starker Bereich)
// =====================

const float COHERENT_BASE = 1920.0;

// Basis-Radius (Qualität)
uniform int radius : hint_range(1, 32) = 24;

// ? Blur-Regler (jetzt wirklich extrem)
uniform float blur_strength : hint_range(20.0, 60.0) = 50.0;

uniform float opacity : hint_range(0.0, 1.0) = 1.0;
uniform int use_smooth : hint_enum("sharp:0","smooth:1");

global uniform int ScreenRotation;
global uniform sampler2D CurrentScreenTexture;

// ---------------------
vec4 sampleCurrentScreen(vec2 uv, vec2 screen_pixel_size) {
    vec2 rotated_uv = uv * (1.0 - screen_pixel_size);
    if (ScreenRotation == 2) {
        rotated_uv = vec2(uv.y, 1.0 - uv.x);
    } else if (ScreenRotation == 3) {
        rotated_uv = vec2(uv.x, uv.y);
    } else if (ScreenRotation == 4) {
        rotated_uv = vec2(1.0 - uv.y, uv.x);
    }
    return texture(CurrentScreenTexture, rotated_uv).bgra;
}

// ---------------------
float gaussian(float x, float sigma) {
    return exp(-(x * x) / (2.0 * sigma * sigma));
}

void fragment() {
    vec2 uv = SCREEN_UV;

    float base_texel = 1.0 / COHERENT_BASE;
    vec2 texel = vec2(
        base_texel,
        base_texel * SCREEN_PIXEL_SIZE.y / SCREEN_PIXEL_SIZE.x
    );

    // Radius leicht dynamisch an Stärke koppeln
    int r = int(float(radius) * (blur_strength / 25.0));

    float sigma = float® * 0.5 * (blur_strength / 25.0); // höhere Werte → mehr Weichheit

    vec3 accum_rgb = vec3(0.0);
    float accum_a = 0.0;
    float weight_sum = 0.0;

    for (int x = -r; x <= r; x++) {
        for (int y = -r; y <= r; y++) {

            vec2 offset = vec2(float(x), float(y)) * texel;

            float dist = length(vec2(float(x), float(y)));
            float w = gaussian(dist, sigma);

            vec4 s = sampleCurrentScreen(uv + offset, SCREEN_PIXEL_SIZE);

            accum_rgb += s.rgb * w;
            accum_a  += s.a * w;
            weight_sum += w;
        }
    }

    vec3 blurred_rgb = accum_rgb / weight_sum;
    float blurred_a  = accum_a  / weight_sum;

    vec4 final_color = vec4(blurred_rgb, blurred_a * opacity);

    if (use_smooth == 1) {
        final_color.a *= texture(TEXTURE, UV).r;
    }
    final_color.a *= COLOR.a;

    COLOR = final_color;
}