Everywhere: Work towards lighting support

assets/glsl/batch-3d.frag

@@ -1,7 +1,10 @@
 #version 450 core
 
-layout(location = 0) out vec4 color;
+layout(location = 0) out vec4 albedoSpec; // RGB diffuse color
+layout(location = 1) out vec4 position;
+layout(location = 2) out vec4 normal;
 
+in vec3 v_position;
 in vec3 v_normal;
 in vec4 v_color;
 in vec2 v_textureCoordinates;
@@ -46,5 +49,9 @@ void main()
 		case 30: textureColor *= texture(u_textures[30], v_textureCoordinates); break;
 		case 31: textureColor *= texture(u_textures[31], v_textureCoordinates); break;
 	}
-    color = textureColor;
+
+	albedoSpec.rgb = textureColor.rgb;
+	albedoSpec.a = 1.0; // TODO: read specular from model material
+	position = vec4(v_position, 1.0f);
+	normal = vec4(normalize(v_normal), 1.0f);
 }

assets/glsl/batch-3d.vert

@@ -6,6 +6,7 @@ layout(location = 2) in vec4 a_color;
 layout(location = 3) in vec2 a_textureCoordinates;
 layout(location = 4) in uint a_textureIndex;
 
+out vec3 v_position;
 out vec3 v_normal;
 out vec4 v_color;
 out vec2 v_textureCoordinates;
@@ -14,10 +15,12 @@ out flat uint v_textureIndex;
 layout(std140, binding = 0) uniform Camera
 {
 	mat4 u_projectionView;
+	vec3 u_position;
 };
 
 void main()
 {
+	v_position = a_position;
 	v_normal = a_normal;
 	v_color = a_color;
 	v_textureCoordinates = a_textureCoordinates;

assets/glsl/batch-cubemap.vert

@@ -8,7 +8,7 @@ out vec4 v_color;
 out vec3 v_textureCoordinates;
 out flat uint v_textureIndex;
 
-uniform mat4 u_projectionView;
+uniform mat4 u_projectionView2;
 
 void main()
 {
@@ -16,5 +16,5 @@ void main()
 	v_textureCoordinates = a_position;
 	v_textureIndex = a_textureIndex;
 	// Vclip = Camera projection * Camera view * Model transform * Vlocal
-	gl_Position = u_projectionView * vec4(a_position, 1.0f);
+	gl_Position = u_projectionView2 * vec4(a_position, 1.0f);
 }

assets/glsl/lightsource.frag

@@ -0,0 +1,14 @@
+#version 450 core
+
+layout(location = 0) out vec4 color;
+
+in vec4 v_color;
+in vec3 v_textureCoordinates;
+in flat uint v_textureIndex;
+
+uniform samplerCube u_textures[32];
+
+void main()
+{
+	color = v_color;
+}

assets/glsl/lightsource.vert

@@ -0,0 +1,24 @@
+#version 450 core
+
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec4 a_color;
+layout(location = 2) in uint a_textureIndex;
+
+out vec4 v_color;
+out vec3 v_textureCoordinates;
+out flat uint v_textureIndex;
+
+layout(std140, binding = 0) uniform Camera
+{
+	mat4 u_projectionView;
+	vec3 u_position;
+};
+
+void main()
+{
+	v_color = a_color;
+	v_textureCoordinates = a_position;
+	v_textureIndex = a_textureIndex;
+	// Vclip = Camera projection * Camera view * Model transform * Vlocal
+	gl_Position = u_projectionView * vec4(a_position, 1.0f);
+}

assets/glsl/post-process.frag

@@ -0,0 +1,78 @@
+#version 450 core
+
+layout(location = 0) out vec4 color;
+
+in vec4 v_color;
+in vec2 v_textureCoordinates;
+in flat uint v_textureIndex;
+
+uniform sampler2D u_textures[32];
+
+// -----------------------------------------
+
+layout(std140, binding = 0) uniform Camera {
+	mat4 u_projectionView;
+	vec3 u_position;
+};
+
+// -----------------------------------------
+
+struct DirectionalLight {
+	vec3 direction;
+
+	vec3 ambient;
+	vec3 diffuse;
+	vec3 specular;
+};
+
+const int MAX_DIRECTIONAL_LIGHTS = 32;
+layout(std140, binding = 1) uniform DirectionalLights {
+	DirectionalLight u_directionalLight[MAX_DIRECTIONAL_LIGHTS];
+};
+
+// -----------------------------------------
+
+void main()
+{
+	float isObject = texture(u_textures[v_textureIndex + 1], v_textureCoordinates).a;
+	if (isObject == 0.0f) {
+		color = vec4(0,0,0,0);
+		return;
+	}
+
+	vec3 albedo    = texture(u_textures[v_textureIndex + 0], v_textureCoordinates).rgb;
+	float specular = texture(u_textures[v_textureIndex + 0], v_textureCoordinates).a;
+	vec3 position  = texture(u_textures[v_textureIndex + 1], v_textureCoordinates).rgb;
+	vec3 normal    = texture(u_textures[v_textureIndex + 2], v_textureCoordinates).rgb;
+
+
+	vec3 lighting = vec3(0.0f, 0.0f, 0.0f);//albedo * v_color.xyz;
+	vec3 viewDirection = normalize(u_position - position);
+
+	// Loop through all directional lights
+	for (int i = 0; i < MAX_DIRECTIONAL_LIGHTS; ++i) {
+		// Diffuse
+		vec3 lightDirection = normalize(-u_directionalLight[i].direction);
+		float diffuse = max(dot(normal, lightDirection), 0.0f);
+
+		// Specular
+		vec3 reflectionDirection = reflect(-lightDirection, normal);
+		float specular = pow(max(dot(viewDirection, reflectionDirection), 0.0f), 32);
+
+		lighting +=
+			(albedo * u_directionalLight[i].ambient) +
+			(albedo * diffuse * u_directionalLight[i].diffuse) +
+			(specular * u_directionalLight[i].specular);
+	}
+
+	// Loop through all point lights
+		// TODO
+		// vec3 lightDirection = normalize(lightPosition - position);
+		// float diffuse = max(dot(normal, lightDirection), 0.0f);
+		// lighting += diffuse * albedo * u_lightColor;
+
+	// Loop through all spot lights
+		// TODO
+
+	color = vec4(lighting, 1.0f);
+}

assets/glsl/post-process.vert

@@ -0,0 +1,25 @@
+#version 450 core
+
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec4 a_color;
+layout(location = 2) in vec2 a_textureCoordinates;
+layout(location = 3) in uint a_textureIndex;
+
+out vec4 v_color;
+out vec2 v_textureCoordinates;
+out flat uint v_textureIndex;
+
+layout(std140, binding = 0) uniform Camera
+{
+	mat4 u_projectionView;
+	vec3 u_position;
+};
+
+void main()
+{
+	v_color = a_color;
+	v_textureCoordinates = a_textureCoordinates;
+	v_textureIndex = a_textureIndex;
+	// Vclip = Model transform * Vlocal
+	gl_Position = vec4(a_position, 1.0f);
+}