I'm currently (attempting) to add SSAO to my engine, except it's...not really work, to say the least. I use a deferred renderer to render my scene. I have four render targets: Albedo, Light, Normal, and Depth.
Here are the parameters for all of them (Surface Format, Depth Format):
Albedo: 32-bit ARGB, Depth24Stencil8
Light: 32-bit ARGB, None
Normal: 32-bit ARGB, None
Depth: 8-bit R (Single), Depth24Stencil8
To generate my random noise map for the SSAO, I do the following for each pixel in the noise map:
Vector3 v3 = Vector3.Zero;
double z = rand.NextDouble() * 2.0 - 1.0;
double r = Math.Sqrt(1.0 - z * z);
double angle = rand.NextDouble() * MathHelper.TwoPi;
v3.X = (float)(r * Math.Cos(angle));
v3.Y = (float)(r * Math.Sin(angle));
v3.Z = (float)z;
v3 += offset;
v3 *= 0.5f;
result[i] = new Color(v3);
This is my GBuffer rendering effect:
PixelInput RenderGBufferColorVertexShader(VertexInput input)
{
PixelInput pi = ( PixelInput ) 0;
pi.Position = mul(input.Position, WorldViewProjection);
pi.Normal = mul(input.Normal, WorldInverseTranspose);
pi.Color = input.Color;
pi.TPosition = pi.Position;
pi.WPosition = input.Position;
return pi;
}
GBufferTarget RenderGBufferColorPixelShader(PixelInput input)
{
GBufferTarget output = ( GBufferTarget ) 0;
float3 position = input.TPosition.xyz / input.TPosition.w;
output.Albedo = lerp(float4(1.0f, 1.0f, 1.0f, 1.0f), input.Color, ColorFactor);
output.Normal = EncodeNormal(input.Normal);
output.Depth = position.z;
return output;
}
And here is the SSAO effect:
float4 EncodeNormal(float3 normal)
{
return float4((normal.xyz * 0.5f) + 0.5f, 0.0f);
}
float3 DecodeNormal(float4 encoded)
{
return encoded * 2.0 - 1.0f;
}
float Intensity;
float Size;
float2 NoiseOffset;
float4x4 ViewProjection;
float4x4 ViewProjectionInverse;
texture DepthMap;
texture NormalMap;
texture RandomMap;
const float3 samples[16] =
{
float3(0.01537562, 0.01389096, 0.02276565),
float3(-0.0332658, -0.2151698, -0.0660736),
float3(-0.06420016, -0.1919067, 0.5329634),
float3(-0.05896204, -0.04509097, -0.03611697),
float3(-0.1302175, 0.01034653, 0.01543675),
float3(0.3168565, -0.182557, -0.01421785),
float3(-0.02134448, -0.1056605, 0.00576055),
float3(-0.3502164, 0.281433, -0.2245609),
float3(-0.00123525, 0.00151868, 0.02614773),
float3(0.1814744, 0.05798516, -0.02362876),
float3(0.07945167, -0.08302628, 0.4423518),
float3(0.321987, -0.05670302, -0.05418307),
float3(-0.00165138, -0.00410309, 0.00537362),
float3(0.01687791, 0.03189049, -0.04060405),
float3(-0.04335613, -0.00530749, 0.06443053),
float3(0.8474263, -0.3590308, -0.02318038),
};
sampler DepthSampler = sampler_state
{
Texture = DepthMap;
MipFilter = Point;
MinFilter = Point;
MagFilter = Point;
AddressU = Clamp;
AddressV = Clamp;
AddressW = Clamp;
};
sampler NormalSampler = sampler_state
{
Texture = NormalMap;
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
AddressU = Clamp;
AddressV = Clamp;
AddressW = Clamp;
};
sampler RandomSampler = sampler_state
{
Texture = RandomMap;
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
};
struct VertexInput
{
float4 Position : POSITION0;
float2 TextureCoordinates : TEXCOORD0;
};
struct PixelInput
{
float4 Position : POSITION0;
float2 TextureCoordinates : TEXCOORD0;
};
PixelInput SSAOVertexShader(VertexInput input)
{
PixelInput pi = ( PixelInput ) 0;
pi.Position = input.Position;
pi.TextureCoordinates = input.TextureCoordinates;
return pi;
}
float3 GetXYZ(float2 uv)
{
float depth = tex2D(DepthSampler, uv);
float2 xy = uv * 2.0f - 1.0f;
xy.y *= -1;
float4 p = float4(xy, depth, 1);
float4 q = mul(p, ViewProjectionInverse);
return q.xyz / q.w;
}
float3 GetNormal(float2 uv)
{
return DecodeNormal(tex2D(NormalSampler, uv));
}
float4 SSAOPixelShader(PixelInput input) : COLOR0
{
float depth = tex2D(DepthSampler, input.TextureCoordinates);
float3 position = GetXYZ(input.TextureCoordinates);
float3 normal = GetNormal(input.TextureCoordinates);
float occlusion = 1.0f;
float3 reflectionRay = DecodeNormal(tex2D(RandomSampler, input.TextureCoordinates + NoiseOffset));
for (int i = 0; i < 16; i++)
{
float3 sampleXYZ = position + reflect(samples[i], reflectionRay) * Size;
float4 screenXYZW = mul(float4(sampleXYZ, 1.0f), ViewProjection);
float3 screenXYZ = screenXYZW.xyz / screenXYZW.w;
float2 sampleUV = float2(screenXYZ.x * 0.5f + 0.5f, 1.0f - (screenXYZ.y * 0.5f + 0.5f));
float frontMostDepthAtSample = tex2D(DepthSampler, sampleUV);
if (frontMostDepthAtSample < screenXYZ.z)
{
occlusion -= 1.0f / 16.0f;
}
}
return float4(occlusion * Intensity * float3(1.0, 1.0, 1.0), 1.0);
}
technique SSAO
{
pass Pass0
{
VertexShader = compile vs_3_0 SSAOVertexShader();
PixelShader = compile ps_3_0 SSAOPixelShader();
}
}
However, when I use the effect, I get some pretty bad distortion:
Here's the light map that goes with it -- is the static-like effect supposed to be like that? I've noticed that even if I'm looking at nothing, I still get the static-like effect. (you can see it in the screenshot; the top half doesn't have any geometry yet it still has the static-like effect)
Also, does anyone have any advice on how to effectively debug shaders?
