I really want to use 2d filters, but the really make my GPU run hot (Nvidia GTX 465). I use the DLAA filter regularly, and that one is ok. But retinex and bloom would also nice, but they actually heat up my GPU so that the framerate drop little by little.

Is this an issue with that 2d filters need downscaling? Or could we improve the filters somehow. I found two different bloom filters on the forum, which one would be faster? The second one seems a bit faster by testing.

Martinsh’s bloom filter

```
uniform sampler2D bgl_RenderedTexture;
const float BRIGHT_PASS_THRESHOLD = 0.5;
const float BRIGHT_PASS_OFFSET = 1.5;
#define blurclamp 0.002
#define bias 0.01
#define KERNEL_SIZE 3.0
vec2 texcoord = vec2(gl_TexCoord[0]).st;
vec4 bright(vec2 coo)
{
vec4 color = texture2D(bgl_RenderedTexture, coo);
color = max(color - BRIGHT_PASS_THRESHOLD, 0.0);
return color / (color + BRIGHT_PASS_OFFSET);
}
void main(void)
{
vec2 blur = vec2(clamp( bias, -blurclamp, blurclamp ));
vec4 col = vec4( 0, 0, 0, 0 );
for ( float x = -KERNEL_SIZE + 1.0; x < KERNEL_SIZE; x += 1.0 )
{
for ( float y = -KERNEL_SIZE + 1.0; y < KERNEL_SIZE; y += 1.0 )
{
col += bright( texcoord + vec2( blur.x * x, blur.y * y ) );
}
}
col /= ((KERNEL_SIZE+KERNEL_SIZE)-1.0)*((KERNEL_SIZE+KERNEL_SIZE)-1.0);
gl_FragColor = col + texture2D(bgl_RenderedTexture, texcoord);
}
```

Gh123man’s bloom filter

```
uniform sampler2D bgl_RenderedTexture;
uniform sampler2D bgl_LuminanceTexture;
void main()
{
vec4 sum = vec4(0);
vec4 bum = vec4(0);
vec2 texcoord = vec2(gl_TexCoord[0]);
int j;
int i;
for( i= -2 ;i < 2; i++)
{
for (j = -1; j < 1; j++)
{
sum += texture2D(bgl_RenderedTexture, texcoord + vec2(-i, j)*0.002) * 0.40;
bum += texture2D(bgl_RenderedTexture, texcoord + vec2(j, i)*0.003) * 0.40;
}
}
if (texture2D(bgl_RenderedTexture, texcoord).r < 2)
{
gl_FragColor = sum*sum*sum*0.0080+bum*bum*bum*0.0080+ texture2D(bgl_RenderedTexture, texcoord);
}
}
```