Pixel-Composer/shaders/sh_blur_slope/sh_blur_slope.fsh

#define MAX_STRENGTH 64.

varying vec2  v_vTexcoord;
varying vec4  v_vColour;

uniform vec2      dimension;
uniform sampler2D slopeMap;
uniform vec2      slopeMapDim;
uniform float	  stepSize;

uniform vec2      strength;
uniform int       strengthUseSurf;
uniform sampler2D strengthSurf;

uniform int	sampleMode;

vec2 tx;
vec2 txMap;

#region /////////////// SAMPLING ///////////////
	const float PI = 3.14159265358979323846;
	uniform int interpolation;
	uniform vec2 sampleDimension;

	const int RSIN_RADIUS = 1;

	float sinc ( float x ) { return x == 0.? 1. : sin(x * PI) / (x * PI); }

	vec4 texture2D_rsin( sampler2D texture, vec2 uv ) {
	    vec2 tx = 1.0 / sampleDimension;
	    vec2 p  = uv * sampleDimension - vec2(0.5);
    
		vec4 sum = vec4(0.0);
	    float weights = 0.;
    
	    for (int x = -RSIN_RADIUS; x <= RSIN_RADIUS; x++)
		for (int y = -RSIN_RADIUS; y <= RSIN_RADIUS; y++) {
	        float a = length(vec2(float(x), float(y))) / float(RSIN_RADIUS);
			if(a > 1.) continue;
	        float w = sinc(a * PI * tx.x) * sinc(a * PI * tx.y);
	        vec2 offset = vec2(float(x), float(y)) * tx;
	        vec4 sample = texture2D(texture, (p + offset + vec2(0.5)) / sampleDimension);
	        sum += w * sample;
	        weights += w;
	    }
	
	    return sum / weights;
	}

	vec4 texture2D_bicubic( sampler2D texture, vec2 uv ) {
		uv = uv * sampleDimension + 0.5;
		vec2 iuv = floor( uv );
		vec2 fuv = fract( uv );
		uv = iuv + fuv * fuv * (3.0 - 2.0 * fuv);
		uv = (uv - 0.5) / sampleDimension;
		return texture2D( texture, uv );
	}

	vec4 texture2Dintp( sampler2D texture, vec2 uv ) {
		if(interpolation == 2)		return texture2D_bicubic( texture, uv );
		else if(interpolation == 3)	return texture2D_rsin( texture, uv );
		return texture2D( texture, uv );
	}
#endregion 

vec4 sampleTexture(sampler2D texture, vec2 pos) { #region
	if(pos.x >= 0. && pos.y >= 0. && pos.x <= 1. && pos.y <= 1.)
		return texture2Dintp(texture, pos);
	
	if(sampleMode == 0) return vec4(0.);
	if(sampleMode == 1) return texture2Dintp(texture, clamp(pos, 0., 1.));
	if(sampleMode == 2) return texture2Dintp(texture, fract(pos));
	
	return vec4(0.);
} #endregion

float sampleBright(vec2 pos) { vec4 c = sampleTexture(slopeMap, pos); return (c.r + c.g + c.b) / 3.;  }

vec2 sampleSlope(vec2 pos) { #region 
	float h0 = sampleBright(pos + vec2(-txMap.x, 0.));
	float h1 = sampleBright(pos + vec2( txMap.x, 0.));
	float h2 = sampleBright(pos + vec2(0., -txMap.y));
	float h3 = sampleBright(pos + vec2(0.,  txMap.y));
	
	return vec2(h1 - h0, h3 - h2);
} #endregion

void main() {
	float str = strength.x;
	if(strengthUseSurf == 1) {
		vec4 _vMap = texture2D( strengthSurf, v_vTexcoord );
		str = mix(strength.x, strength.y, (_vMap.r + _vMap.g + _vMap.b) / 3.);
	}
	
	tx    = 1. / dimension;
	txMap = 1. / slopeMapDim;
	
	float alpha = 0.;
	vec4  colr  = vec4(0.);
	vec2  pos   = v_vTexcoord;
	
	for(float i = 0.; i < MAX_STRENGTH; i++) {
		if(i > str) break;
		
		float str = 1. - (i / str);
		vec4  c = sampleTexture(gm_BaseTexture, pos);
		colr  += c * str;
		alpha += str;
		
		vec2 slp = sampleSlope(pos);
		pos += slp * stepSize;
	}
	
    gl_FragColor = colr / alpha;
}