Move shaders into glsl and hlsl directories

Move `data/shaders` to `data/shaders/glsl`
Move `data/hlsl` to `data/shaders/hlsl`

Fix up shader paths in the cpp files to point to the new glsl location.

`data/shaders/hlsl/compile.py` still overwrites the glsl .spv files (for
now).

Issue: #723

data/shaders/glsl/ssao/blur.frag

@@ -0,0 +1,25 @@
+#version 450
+
+layout (binding = 0) uniform sampler2D samplerSSAO;
+
+layout (location = 0) in vec2 inUV;
+
+layout (location = 0) out float outFragColor;
+
+void main() 
+{
+	const int blurRange = 2;
+	int n = 0;
+	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;
+			n++;
+		}
+	}
+	outFragColor = result / (float(n));
+}

data/shaders/glsl/ssao/composition.frag

@@ -0,0 +1,52 @@
+#version 450
+
+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;
+	int ssao;
+	int ssaoOnly;
+	int ssaoBlur;
+} uboParams;
+
+layout (location = 0) in vec2 inUV;
+
+layout (location = 0) out vec4 outFragColor;
+
+void main() 
+{
+	vec3 fragPos = texture(samplerposition, inUV).rgb;
+	vec3 normal = normalize(texture(samplerNormal, inUV).rgb * 2.0 - 1.0);
+	vec4 albedo = texture(samplerAlbedo, inUV);
+	 
+	float ssao = (uboParams.ssaoBlur == 1) ? texture(samplerSSAOBlur, inUV).r : texture(samplerSSAO, inUV).r;
+
+	vec3 lightPos = vec3(0.0);
+	vec3 L = normalize(lightPos - fragPos);
+	float NdotL = max(0.5, dot(normal, L));
+
+	if (uboParams.ssaoOnly == 1)
+	{
+		outFragColor.rgb = ssao.rrr;
+	}
+	else
+	{
+		vec3 baseColor = albedo.rgb * NdotL;
+
+		if (uboParams.ssao == 1)
+		{
+			outFragColor.rgb = ssao.rrr;
+
+			if (uboParams.ssaoOnly != 1)
+				outFragColor.rgb *= baseColor;
+		}
+		else
+		{
+			outFragColor.rgb = baseColor;
+		}
+	}
+}

data/shaders/glsl/ssao/fullscreen.vert

@@ -0,0 +1,14 @@
+#version 450
+
+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/glsl/ssao/gbuffer.frag

@@ -0,0 +1,26 @@
+#version 450
+
+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 = 64.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/glsl/ssao/gbuffer.vert

@@ -0,0 +1,39 @@
+#version 450
+
+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 (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/glsl/ssao/ssao.frag

@@ -0,0 +1,71 @@
+#version 450
+
+layout (binding = 0) uniform sampler2D samplerPositionDepth;
+layout (binding = 1) uniform sampler2D samplerNormal;
+layout (binding = 2) uniform sampler2D ssaoNoise;
+
+layout (constant_id = 0) const int SSAO_KERNEL_SIZE = 64;
+layout (constant_id = 1) const float SSAO_RADIUS = 0.5;
+
+layout (binding = 3) uniform UBOSSAOKernel
+{
+	vec4 samples[SSAO_KERNEL_SIZE];
+} uboSSAOKernel;
+
+layout (binding = 4) uniform UBO 
+{
+	mat4 projection;
+} ubo;
+
+layout (location = 0) in vec2 inUV;
+
+layout (location = 0) out float outFragColor;
+
+void main() 
+{
+	// Get G-Buffer values
+	vec3 fragPos = texture(samplerPositionDepth, inUV).rgb;
+	vec3 normal = normalize(texture(samplerNormal, inUV).rgb * 2.0 - 1.0);
+
+	// Get a random vector using a noise lookup
+	ivec2 texDim = textureSize(samplerPositionDepth, 0); 
+	ivec2 noiseDim = textureSize(ssaoNoise, 0);
+	const vec2 noiseUV = vec2(float(texDim.x)/float(noiseDim.x), float(texDim.y)/(noiseDim.y)) * 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;
+	// remove banding
+	const float bias = 0.01f;
+	for(int i = 0; i < SSAO_KERNEL_SIZE; i++)
+	{		
+		vec3 samplePos = TBN * uboSSAOKernel.samples[i].xyz; 
+		samplePos = fragPos + samplePos * SSAO_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; 
+
+#define RANGE_CHECK 1
+#ifdef RANGE_CHECK
+		// Range check
+		float rangeCheck = smoothstep(0.0f, 1.0f, SSAO_RADIUS / abs(fragPos.z - sampleDepth));
+		occlusion += (sampleDepth >= samplePos.z + bias ? 1.0f : 0.0f) * rangeCheck;           
+#else
+		occlusion += (sampleDepth >= samplePos.z + bias ? 1.0f : 0.0f);  
+#endif
+	}
+	occlusion = 1.0 - (occlusion / float(SSAO_KERNEL_SIZE));
+	
+	outFragColor = occlusion;
+}
+