uniform sampler2D som; //depth 
uniform sampler2D rand; //random colors

//unpack vector for linear depth
const vec3 unpack = vec3( 255.0/256, 255.0/(256*256), 255.0/(256*256*256) );

//sampling positions:
const vec2 points[8] = {
vec2(-1,1),vec2(0,1),vec2(1,1),vec2(1,0),vec2(1,-1),vec2(0,-1),vec2(-1,-1),vec2(-1,0)
};

void main()
{    
float sum = 0.0;
float prof = dot(texture2D(som, gl_TexCoord[0].st).xyz,unpack);//I unpack the rgb encoded depth, remove the dot product if you use a standard zbuffer.
//with a non-linear buffer, results are a lot uglier so try to avoid using it.

vec2 fres = vec2(60,60);//tiling of the random texture across screen.
vec3 random = texture2D(rand, gl_TexCoord[0].st*fres.xy);
random = random-vec4(0.5); //we obtain the difference (color-gray) so that there are negative values also.

//calculate sampling rates:
float radx = (1.0/800.0)*1; //800x600 resolution
float rady = (1.0/600.0)*1;

for (int i = 0;i<8;i++){

      vec2 point = vec2(points[i].x*radx,points[i].y*rady)+random.xy*0.06;
      vec2 sp = gl_TexCoord[0].xy+point/prof; //divide by the depth value so that the sampling area gets smaller with depth.
      
      float prof2 = dot(texture2D(som, sp).xyz,unpack);

      float zd = max(prof-prof2,0.0)*50; //depth difference*50
      float gauss = pow(2.7182,-2*zd*zd); //gaussian falloff
      sum += zd*gauss*2; //depth difference*gaussian fallof (so that big differences contribute less, this avoids "flatness")
}

float occ = (1.0-sum/8.0); //white-occlusion
gl_FragColor = vec4(occ,occ,occ,1.0);
}

//
// VERTEX SHADER
//

VS_OUTPUT VS_SSAO( in VS_INPUT IN )
{
    VS_OUTPUT Out = (VS_OUTPUT)0;

    //Out.pos = IN.Position;	// for some weird reason passing direct screen coords doesnt work ?!? need to transform by WVP
	Out.pos = mul( worldViewProj, IN.Position ); 

	IN.Position.xy = sign( IN.Position.xy );
    Out.TexCoord = (float2(IN.Position.x, -IN.Position.y) + float2( 1.0f, 1.0f )) * 0.5f;

	float4 pos = IN.Position;
	float3 worldPos = mul( matWorld, pos ).xyz;

	float3 eyevec = worldPos - cameraPos;

	float3 eyeview = mul( matView, float4(eyevec, 1) ).xyz;
	normalize( eyeview );

	Out.viewDirection = eyeview;

    return Out;
}

//
// PIXEL SHADER
//

float4 PS_SSAO( in VS_OUTPUT IN ) : COLOR
{
	float4 samples[16] =
	{
		float4(0.355512, 	-0.709318, 	-0.102371,	0.0 ),
		float4(0.534186, 	0.71511, 	-0.115167,	0.0 ),
		float4(-0.87866, 	0.157139, 	-0.115167,	0.0 ),
		float4(0.140679, 	-0.475516, 	-0.0639818,	0.0 ),
		float4(-0.0796121, 	0.158842, 	-0.677075,	0.0 ),
		float4(-0.0759516, 	-0.101676, 	-0.483625,	0.0 ),
		float4(0.12493, 	-0.0223423,	-0.483625,	0.0 ),
		float4(-0.0720074, 	0.243395, 	-0.967251,	0.0 ),
		float4(-0.207641, 	0.414286, 	0.187755,	0.0 ),
		float4(-0.277332, 	-0.371262, 	0.187755,	0.0 ),
		float4(0.63864, 	-0.114214, 	0.262857,	0.0 ),
		float4(-0.184051, 	0.622119, 	0.262857,	0.0 ),
		float4(0.110007, 	-0.219486, 	0.435574,	0.0 ),
		float4(0.235085, 	0.314707, 	0.696918,	0.0 ),
		float4(-0.290012, 	0.0518654, 	0.522688,	0.0 ),
		float4(0.0975089, 	-0.329594, 	0.609803,	0.0 )
	};

	float depth = tex2D( depthSampler, IN.TexCoord ).r;

	float3 se = (depth * IN.viewDirection.xyz) / IN.viewDirection.z;

	//float3 viewnormal = tex2D(depthSampler, IN.TexCoord).rgb;

	float3 randNormal = tex2D( randSampler, IN.TexCoord * 200 ).rgb;
	//randNormal = randNormal - float3(0.5);
	randNormal = randNormal * 2 - 1.0;

	float finalColor = 0.0f;
	for( int i=0; i<16; i++ )
	{
		float3 ray = se + sampleRadius * reflect(samples[i].xyz, randNormal);

		float2 ss = (ray.xy/ray.z) * float2( 0.75, 1.0 );
        float2 sn = ss*.5 + float2(0.5);
        float sz = tex2D( depthSampler, sn ).r;

        float zd = 50.0*max( ray.z-sz, 0.0 );
        finalColor += 1.0 / (1.0+zd*zd);
	}

	return float4( finalColor/16, finalColor/16, finalColor/16, 1.0f );
}