# pouët.net

Go to bottom

category: gfx [glöplog]

hi,
im working on a small pixelshader effect, where some triangles should have blurred edges.

now the edges of those triangles should have blurred edges.
i could just measure the distance of each pixel to that edge and blur accordingly, but that would use a couple of sqrts and i am afraid it affects performance.

is there an easier way to do this?
I don't think you need an actual distance calculation, you can always take Y as granted and just test for horizontal distance in X.
One lazy solution is to perform a deltaColor vertical blur (edge means the color changes), but I'm not sure it won't hit performance if many iterations are performed. Try pasting this in your shadertoy:
Code:``` float calc1tri(float c, vec2 uv, int i, float ydecal) { vec2 p = getTriPoint(float(i)); vec2 left = vec2(-p.x+0.5, p.y-ydecal); vec2 right = vec2(p.x+0.5, p.y-ydecal); if (PointInTriangle(uv, right, left, vec2(0.5,0.0) )) { float distanceToEdge = length(uv-left); float d = clamp(distanceToEdge, 0.0, 1.0); c += 0.081; } return c; } void mainImage( out vec4 fragColor, in vec2 fragCoord ) { vec2 uv = fragCoord.xy / iResolution.xy; float c = 0.0; float c2 = 0.0; const int halfIterCount = 5; for (int i=0;i<11;i++) { c2=0.0; c = calc1tri(c, uv, i, 0.0); float localc = c; for (int j=-halfIterCount;j<halfIterCount;j++) { float fj = float(j); localc = calc1tri(localc, uv, i, fj/iResolution.y); c2 += max(0.0,localc-c); // delta color: take in account only if different from original color } c += c2/float(halfIterCount*2); } float lum = c/float(halfIterCount*2); fragColor = vec4(0.98,0.7,0.5,1.0) + lum; } ```
Lazier solution! ;D
Code:``` for (int i=0;i<7;i++) { vec2 p = getTriPoint(float(i)*0.9); vec2 left = vec2(-p.x+0.5, p.y); vec2 right = vec2(p.x+0.5, p.y); for (int j=0; j<16; ++j ) { for ( int k=0; k<16; ++k ) { vec2 uv2 = uv + vec2( j, k ) / iResolution.xy; if (PointInTriangle(uv2, right, left, vec2(0.5,0.0) )) { float distanceToEdge = length(uv2-left); float d = clamp(distanceToEdge, 0.0, 1.0); c += 0.081; } } } } c /= (16.0*16.0); ```
thanks guys!

@Gargaj: but that would only blur in one direction. they should be blurred in both.

@Soundy: thats a pretty much what i was going for. and performance seems also good!

@hornet: looks also cool, but the double for loop is an impact on performance.
Get depth zbuffer. Use filter that measures local contrast of zfuffer. Bilinear can already be good enough
. Blur with linear function of The filtered Image. Dumb but a simple parallel pipe may sometimes be faster.
@motte: This should do roughly what you want: https://www.shadertoy.com/view/XsXSz4