GLSL - How to code a "local" jitter blur

[adamwparker]

Hey Malt users!

I'm trying to make a jitter blur that uses a black and white image to restrain the blur in certain bounds.
white = in bounds (use this information)
black = out of bounds (don't use this information)
I'm having trouble doing this. Any help would be appreciated.
The main problem can be seen in this example image. I'm using a checker texture as the qualifier. I don't want the yellow circle to bleed into the blurred squares.

vec4 adam_blur(sampler2D input_texture, sampler2D qualifier_texture, vec2 uv, float radius, float distribution_exponent, float threshold, int samples)
{
    vec2 resolution = textureSize(input_texture, 0);
    vec4 result = vec4(0);
    for(int i = 0; i < samples;  i++)
    {
        vec4 random = random_per_pixel(i);
        float angle = random.x * PI * 2;
        float length = random.y;
        length = pow(length, distribution_exponent) * radius;
        float x = cos(angle) * length;
        float y = sin(angle) * length;
        vec2 offset = vec2(x,y) / resolution;
        if (texture(qualifier_texture, uv).r > threshold && texture(qualifier_texture, uv + offset).r > threshold)
        {
        result += texture(input_texture, uv + offset) / samples;
        }
        else
        {
        result += texture(input_texture, uv);
        }
    }

    return result;
}

[pragma37]

The main problem is that since the offsets are random for each pixel, the GPU is going to select a very small mip map.
So the checkerboard that ends up using will look something like this:

The solution is to tell the GPU the LoD you want to use::
textureLod(qualifier_texture, uv + offset, 0)
(The LoD 0 is always the full image resolution, LoD 1 is half the resolution and so on)

Additionally, you were also accumulating samples for pixels below the "qualifier" threshold, which I guess is not what you wanted?

I guess this is the result you're looking for?

If that's the case, this is the modified code I used:

vec4 adam_blur(sampler2D input_texture, sampler2D qualifier_texture, vec2 uv, 
    float radius, float distribution_exponent, float threshold, int samples)
{
    vec2 resolution = textureSize(input_texture, 0);
    vec4 result = vec4(0);
    if (texture(qualifier_texture, uv).r > threshold)
    {
        int sample_count = 0;
        for(int i = 0; i < samples;  i++)
        {
            vec4 random = random_per_pixel(i);
            float angle = random.x * PI * 2;
            float length = random.y;
            length = pow(length, distribution_exponent) * radius;
            float x = cos(angle) * length;
            float y = sin(angle) * length;
            vec2 offset = vec2(x,y) / resolution;

            vec4 qualifier = textureLod(qualifier_texture, uv + offset, 0);
            vec4 input = textureLod(input_texture, uv + offset, 0);

            if(qualifier.r > threshold)
            {
                sample_count++;
                result += input;
            }
        }
        result /= sample_count;
    }
    else
    {
        result = texture(input_texture, uv);
    }

    return result;
}

[adamwparker]

Thanks so much! I had no idea about the LODs

[pragma37]

You're welcome!
I did, and still took me a while to figure out what was going on. 😅