Hi everyone!
Quite some time ago i posted here a SSAO shader with color bleeding that got some attention but unfortunately many people had problems with it, because it was slow, hard to understand and was impractical for games.
That shader used 3 buffers: depth, color, normals, and had trig functions and normalizations everywhere (that by the way were not needed :P).
I´ve been working on a simpler shader that can be used in games. The color bleeding is not very accurate but it looks ok to me.
I have nicknamed it Gauss SSGI. I hope you find it useful. You can use it any way you like. :)
INFO:
Screenshots:
Fragment Shader:
uniform sampler2D som; // Depth texture
uniform sampler2D rand; // Random texture
uniform sampler2D color; // Color texture
uniform vec2 camerarange = vec2(1.0, 1024.0);
float pw = 1.0/800.0*0.5;
float ph = 1.0/600.0*0.5;
float readDepth(in vec2 coord)
{
if (coord.x<0||coord.y<0) return 1.0;
float nearZ = camerarange.x;
float farZ =camerarange.y;
float posZ = texture2D(som, coord).x;
return (2.0 * nearZ) / (nearZ + farZ - posZ * (farZ - nearZ));
}
vec3 readColor(in vec2 coord)
{
return texture2D(color, coord).xyz;
}
float compareDepths(in float depth1, in float depth2)
{
float gauss = 0.0;
float diff = (depth1 - depth2)*100.0; //depth difference (0-100)
float gdisplace = 0.2; //gauss bell center
float garea = 3.0; //gauss bell width
//reduce left bell width to avoid self-shadowing
if (diff<gdisplace) garea = 0.2;
gauss = pow(2.7182,-2*(diff-gdisplace)*(diff-gdisplace)/(garea*garea));
return max(0.2,gauss);
}
vec3 calAO(float depth,float dw, float dh, inout float ao)
{
float temp = 0;
vec3 bleed = vec3(0.0,0.0,0.0);
float coordw = gl_TexCoord[0].x + dw/depth;
float coordh = gl_TexCoord[0].y + dh/depth;
if (coordw < 1.0 && coordw > 0.0 && coordh < 1.0 && coordh > 0.0){
vec2 coord = vec2(coordw , coordh);
temp = compareDepths(depth, readDepth(coord));
bleed = readColor(coord);
}
ao += temp;
return temp*bleed;
}
void main(void)
{
//randomization texture:
vec2 fres = vec2(20,20);
vec3 random = texture2D(rand, gl_TexCoord[0].st*fres.xy);
random = random*2.0-vec3(1.0);
//initialize stuff:
float depth = readDepth(gl_TexCoord[0]);
vec3 gi = vec3(0.0,0.0,0.0);
float ao = 0.0;
for(int i=0; i<8; ++i)
{
//calculate color bleeding and ao:
gi += calAO(depth, pw, ph,ao);
gi += calAO(depth, pw, -ph,ao);
gi += calAO(depth, -pw, ph,ao);
gi += calAO(depth, -pw, -ph,ao);
//sample jittering:
pw += random.x*0.0005;
ph += random.y*0.0005;
//increase sampling area:
pw *= 1.4;
ph *= 1.4;
}
//final values, some adjusting:
vec3 finalAO = vec3(1.0-(ao/32.0));
vec3 finalGI = (gi/32)*0.6;
gl_FragColor = vec4(readColor(gl_TexCoord[0])*finalAO+finalGI,1.0);
}
Vertex Shader: standard stuff, no ssao code in there.
Pros:
-It´s faster than other methods because it doesn´t use a normals buffer.
-It does not suffer from the "flat syndrome".
-Does not need blurring if a good randomization texture is used.
-It´s simple to understand.
Cons:
-It is slower than traditional SSAO.
-It suffers from halos (it has a parameter that helps reducing them).
EXPLANATION:
The "new" stuff is in the depth comparison function. There i take the depth difference and i plug it in two different gauss functions. The first one has a more pronounced shape to avoid self-occlusion issues and the second one is softer. These two functions map the depths directly to an occlusion value. Then i just multiply that value with a blurred version of the color buffer to get the color bleeding. The SSAO term together with the color bleeding fake some sort of "local" GI.
You will also need a random-colors texture to randomize the sampling, tomorrow i will post the one i´m using since it gives pretty good results.
[Edited by - ArKano22 on October 16, 2009 10:01:57 AM]
