Added SSAO example (wip)

data/shaders/ssao/blur.frag

@@ -0,0 +1,28 @@
+#version 450
+
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+
+layout (binding = 0) uniform sampler2D samplerSSAO;
+
+layout (location = 0) in vec2 inUV;
+
+layout (location = 0) out float outFragColor;
+
+const int blurSize = 4;
+
+void main() 
+{
+	const int blurRange = 2;
+	vec2 texelSize = 1.0 / vec2(textureSize(samplerSSAO, 0));
+	float result = 0.0;
+	for (int x = -blurRange; x < blurRange; x++) 
+	{
+		for (int y = -blurRange; y < blurRange; y++) 
+		{
+			vec2 offset = vec2(float(x), float(y)) * texelSize;
+			result += texture(samplerSSAO, inUV + offset).r;
+		}
+	}
+	outFragColor = result / (blurRange * blurRange * blurRange * blurRange);
+}

data/shaders/ssao/composition.frag

@@ -0,0 +1,51 @@
+#version 450
+
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+
+layout (binding = 0) uniform sampler2D samplerposition;
+layout (binding = 1) uniform sampler2D samplerNormal;
+layout (binding = 2) uniform sampler2D samplerAlbedo;
+layout (binding = 3) uniform sampler2D samplerSSAO;
+layout (binding = 4) uniform sampler2D samplerSSAOBlur;
+layout (binding = 5) uniform UBO 
+{
+	mat4 _dummy;
+	uint ssao;
+	uint ssaoOnly;
+	uint ssaoBlur;
+} uboParams;
+
+layout (location = 0) in vec2 inUV;
+
+layout (location = 0) out vec4 outFragColor;
+
+void main() 
+{
+	vec3 fragPos = texture(samplerposition, inUV).rgb;
+	vec3 normal = texture(samplerNormal, inUV).rgb;
+	vec4 albedo = texture(samplerAlbedo, inUV);
+	 
+	float ssao = (uboParams.ssaoBlur == 1) ? texture(samplerSSAOBlur, inUV).r : texture(samplerSSAO, inUV).r;
+
+	outFragColor = vec4(vec3(0.0), 1.0);
+
+	if (uboParams.ssaoOnly == 1)
+	{
+		outFragColor.rgb = ssao.rrr;
+	}
+	else
+	{
+		if (uboParams.ssao == 1)
+		{
+			outFragColor.rgb = ssao.rrr;
+
+			if (uboParams.ssaoOnly != 1)
+				outFragColor.rgb *= albedo.rgb;
+		}
+		else
+		{
+			outFragColor.rgb = albedo.rgb;
+		}
+	}
+}

data/shaders/ssao/fullscreen.vert

@@ -0,0 +1,17 @@
+#version 450
+
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+
+layout (location = 0) out vec2 outUV;
+
+out gl_PerVertex
+{
+	vec4 gl_Position;
+};
+
+void main() 
+{
+	outUV = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
+	gl_Position = vec4(outUV * 2.0f - 1.0f, 0.0f, 1.0f);
+}

data/shaders/ssao/gbuffer.frag

@@ -0,0 +1,29 @@
+#version 450
+
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+
+layout (location = 0) in vec3 inNormal;
+layout (location = 1) in vec2 inUV;
+layout (location = 2) in vec3 inColor;
+layout (location = 3) in vec3 inPos;
+
+layout (location = 0) out vec4 outPosition;
+layout (location = 1) out vec4 outNormal;
+layout (location = 2) out vec4 outAlbedo;
+
+const float NEAR_PLANE = 0.1f; //todo: specialization const
+const float FAR_PLANE = 50.0f; //todo: specialization const 
+
+float linearDepth(float depth)
+{
+	float z = depth * 2.0f - 1.0f; 
+	return (2.0f * NEAR_PLANE * FAR_PLANE) / (FAR_PLANE + NEAR_PLANE - z * (FAR_PLANE - NEAR_PLANE));	
+}
+
+void main() 
+{
+	outPosition = vec4(inPos, linearDepth(gl_FragCoord.z));
+	outNormal = vec4(normalize(inNormal) * 0.5 + 0.5, 1.0);
+	outAlbedo = vec4(inColor * 2.0, 1.0);
+}

data/shaders/ssao/gbuffer.vert

@@ -0,0 +1,43 @@
+#version 450
+
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+
+layout (location = 0) in vec4 inPos;
+layout (location = 1) in vec2 inUV;
+layout (location = 2) in vec3 inColor;
+layout (location = 3) in vec3 inNormal;
+layout (location = 4) in vec3 inTangent;
+
+layout (binding = 0) uniform UBO 
+{
+	mat4 projection;
+	mat4 model;
+	mat4 view;
+} ubo;
+
+layout (location = 0) out vec3 outNormal;
+layout (location = 1) out vec2 outUV;
+layout (location = 2) out vec3 outColor;
+layout (location = 3) out vec3 outPos;
+
+out gl_PerVertex
+{
+	vec4 gl_Position;
+};
+
+void main() 
+{
+	gl_Position = ubo.projection * ubo.view * ubo.model * inPos;
+	
+	outUV = inUV;
+
+	// Vertex position in view space
+	outPos = vec3(ubo.view * ubo.model * inPos);
+
+	// Normal in view space
+	mat3 normalMatrix = transpose(inverse(mat3(ubo.view * ubo.model)));
+	outNormal = normalMatrix * inNormal;
+
+	outColor = inColor;
+}

data/shaders/ssao/ssao.frag

@@ -0,0 +1,67 @@
+#version 450
+
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+
+layout (binding = 0) uniform sampler2D samplerPositionDepth;
+layout (binding = 1) uniform sampler2D samplerNormal;
+layout (binding = 2) uniform sampler2D ssaoNoise;
+
+layout (binding = 3) uniform UBOSSAOKernel
+{
+	vec4 samples[64]; // todo: specialization const
+} uboSSAOKernel;
+
+layout (binding = 4) uniform UBO 
+{
+	mat4 projection;
+} ubo;
+
+layout (location = 0) in vec2 inUV;
+
+layout (location = 0) out float outFragColor;
+
+// todo: specialization const
+const int kernelSize = 64;
+const float radius = 1.0;
+
+void main() 
+{
+	// Get G-Buffer values
+	vec3 fragPos = texture(samplerPositionDepth, inUV).rgb;
+	vec3 normal = normalize(texture(samplerNormal, inUV).rgb) * 2.0 - 1.0f;
+
+	// Get a random vector using a noise lookup
+	ivec2 texDim = textureSize(samplerPositionDepth, 0); 
+	const vec2 noiseUV = vec2(float(texDim.x)/4.0f, float(texDim.y)/4.0f) * inUV;  
+	vec3 randomVec = texture(ssaoNoise, noiseUV).xyz * 2.0 - 1.0;  
+	
+	// Create TBN matrix
+	vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal));
+	vec3 bitangent = cross(tangent, normal);
+	mat3 TBN = mat3(tangent, bitangent, normal);
+
+	// Calculate occlusion value
+	float occlusion = 0.0f;
+	for(int i = 0; i < kernelSize; i++)
+	{		
+		vec3 samplePos = TBN * uboSSAOKernel.samples[i].xyz; 
+		samplePos = fragPos + samplePos * radius; 
+		
+		// project
+		vec4 offset = vec4(samplePos, 1.0f);
+		offset = ubo.projection * offset; 
+		offset.xyz /= offset.w; 
+		offset.xyz = offset.xyz * 0.5f + 0.5f; 
+		
+		float sampleDepth = -texture(samplerPositionDepth, offset.xy).w; 
+
+		// Range check
+		float rangeCheck = smoothstep(0.0f, 1.0f, radius / abs(fragPos.z - sampleDepth));
+		occlusion += (sampleDepth >= samplePos.z ? 1.0f : 0.0f) * rangeCheck;           
+	}
+	occlusion = 1.0 - (occlusion / float(kernelSize));
+	
+	outFragColor = occlusion;
+}
+