Add convolution filter node

[bluesillybeard]

I was messing around with blur filters, then I had an idea: make a custom blur filter. A common way to do that is to use a convolution filter, but when I looked there is no convolution filter node!

The reason being, I am creating my own outline system and part of that requires blurring the output of a line detector with something like a boca blur to achieve a particular shape and size.

Node inputs:
convolution: Sampler2D (Or vec4[][]) (Or vec4[] and width/height)
texture: Sampler2D
UV: vec2
normalize: bool (if true, the output is normalized based on the sum of the convolution kernel's values)

Node output:
vec4 result

[pragma37]

It's not hard to implement something like this:

/*  META
    @meta: category=Filter;
    @uv: default=UV[0];
    @K1: subtype=Vector;
    @K2: subtype=Vector;
    @K3: subtype=Vector;
*/
vec4 convolution(sampler2D input_texture, vec2 uv, vec3 K1, vec3 K2, vec3 K3, bool normalize)
{
    vec3 kernel[3] = vec3[3](K1, K2, K3);
    vec2 texel_size = vec2(1.0) / textureSize(input_texture, 0).xy;
    vec4 result = vec4(0.0);
    float total_weight = 0.0;

    for(int y = -1; y <= 1; y++)
    {
        for(int x = -1; x <= 1; x++)
        {
            float weight = kernel[y][x];
            result += texture(input_texture, uv + vec2(x,y) * texel_size) * weight;
            total_weight += weight;
        }
    }

    if(normalize)
    {
        result /= total_weight;
    }

    return result;
}

But that's quite clunky to work with, IMO.
At that point I think it's better to just write it in code and have a node designed around a more specific functionality, like we already do:

[bluesillybeard]

I need to move on with my project, so I created a plugin with a GLSL function that does what I want:

vec4 convolve(sampler2D texture, vec2 UV, sampler2D kernel, bool normalize)
{
    // get input UV in texel space
    ivec2 inputSize = textureSize(texture,0);
    ivec2 UVT = ivec2(UV.x * inputSize.x, UV.y * inputSize.y);
    ivec2 kernelSize = textureSize(kernel, 0);
    vec4 normalizationFactor = vec4(1.0);
    // if we're normalizing, calculate the normalization factor
    if(normalize){
        normalizationFactor = vec4(0.0);
        for(int x = 0; x<kernelSize.x; ++x){
            for(int y=0; y<kernelSize.y; ++y){
                normalizationFactor += texelFetch(kernel, ivec2(x, y), 0);
            }
        }
        normalizationFactor = vec4(1.0 / normalizationFactor.x, 1.0 / normalizationFactor.y, 1.0 / normalizationFactor.z, 1.0 / normalizationFactor.w);
    }
    //actually do the convolution
    ivec2 kernelCenter = ivec2(kernelSize.x / 2, kernelSize.y / 2);
    vec4 result = vec4(0);
    for(int xk=0; xk<kernelSize.x; ++xk){
        for(int yk=0; yk<kernelSize.y; ++yk){
            ivec2 imageCoords = UVT + kernelCenter - ivec2(xk, yk);
            vec4 kernelValue = texelFetch(kernel, ivec2(xk, yk), 0) * 2 - vec4(1);
            vec4 imageValue = texelFetch(texture, imageCoords, 0);
            result += imageValue * kernelValue;
        }
    }
    result *= normalizationFactor;
    return result;
}

The input kernel texture is mapped to allow for negative values like so:
0 -> -1
0.5 -> 0
1 -> 1

It is worth noting that the edges of the output are not accounted for, and from what I can tell texelFetch just returns all zeros when asked for a pixel outside of the texture.