Adapted Escape the Dawn engine.

2014-04-04 23:14:18 +02:00
parent 6a64de37fb
commit a7985b1686
64 changed files with 3384 additions and 79 deletions
@@ -0,0 +1,17 @@
+#version 430
+
+uniform vec4 Color;
+
+in VertexData {
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoord;
+	vec3 ShadowCoord;
+} Input;
+
+out vec4 FragmentColor;
+
+void main() {
+	//FragmentColor = vec4(1.0 - gl_Color.r, 1.0 - gl_Color.g, 1.0 - gl_Color.b, 0.0);
+	FragmentColor = Color;
+}
@@ -0,0 +1,109 @@
+#version 430
+
+uniform mat4 model;
+uniform mat4 view;
+ 
+layout(binding=0) uniform sampler2D texture0;
+layout(binding=1) uniform sampler2D shadowMap;
+
+const int maxNumberOfLights = 82;
+uniform int numberOfLights;
+uniform vec3 position[maxNumberOfLights];
+uniform vec3 specular[maxNumberOfLights];
+uniform vec3 diffuse[maxNumberOfLights];
+uniform float constantAttenuation[maxNumberOfLights];
+uniform float linearAttenuation[maxNumberOfLights];
+uniform float quadraticAttenuation[maxNumberOfLights];
+uniform float spotExponent[maxNumberOfLights];
+
+in VertexData {
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoord;
+	vec3 ShadowCoord;
+} Input;
+
+vec3 scene_ambient = vec3(0.5, 0.5, 0.5);
+ 
+out vec4 fragmentColor;
+
+void main() {
+
+	// Texture
+	vec4 texel = texture2D(texture0, Input.TextureCoord);
+	//vec4 texel = (blend.x * texel0) + (blend.y * texel1) + (blend.z * texel2);
+
+	//
+	// Phong shading
+	//
+
+	// Ambient light
+	vec3 La = scene_ambient;	// Ambient light
+	vec3 Ks = vec3(0.3, 0.3, 0.3);	// Specular reflectance
+	vec3 Kd = vec3(1.0, 1.0, 1.0);	// Diffuse reflectance
+	vec3 Ka = vec3(1.0, 1.0, 1.0);	// Ambient reflectance
+	vec3 Is;
+	vec3 Id;
+
+	// Shadows
+	//float cosTheta = clamp(dot(Input.Normal, vec3(0, 1, 0)), 0.0, 1.0);
+	//float bias = 0.001 * tan(acos(cosTheta)); // cosTheta is dot( n,l ), clamped between 0 and 1
+	//bias = clamp(bias, 0.0, 0.01);
+	float visibility = 1.0;
+	if (Input.ShadowCoord.x >= 0.0 && Input.ShadowCoord.x <= 1.0 && Input.ShadowCoord.y >= 0.0 && Input.ShadowCoord.y <= 1.0) {
+		float bias = 0.0005;
+		vec4 shadowMapValue = texture(shadowMap, Input.ShadowCoord.xy);
+		if (shadowMapValue.z < clamp(Input.ShadowCoord.z - bias, 0, 1)) {
+			visibility = 0.3;
+		}
+	}
+
+	vec3 totalLighting = La * Ka * visibility;
+
+	float attenuation;
+
+	for(int i = 0; i < numberOfLights && i < maxNumberOfLights; i++)
+	{
+		// Light
+		//vec3 lightPosition = vec3(0, 0, 2);
+		vec3 Ls = specular[i];	// Specular light
+		vec3 Ld = diffuse[i];	// Diffuse light
+	
+		vec3 lightPosView = vec3(view * vec4(position[i], 1.0));
+		vec3 surfacePosition = vec3(model * vec4(Input.Position, 1.0));
+		vec3 surfacePosView = vec3(view * vec4(surfacePosition, 1.0));
+		vec3 surfaceToLight = normalize(lightPosView - surfacePosView);
+		mat3 normalMatrix = transpose(inverse(mat3(view * model)));
+		vec3 surfaceNormal = normalize(normalMatrix * Input.Normal);
+	
+		float dist = length(position[i] - surfacePosition);
+
+		attenuation = 1.0 / (constantAttenuation[i]
+			+ linearAttenuation[i] * dist
+			+ quadraticAttenuation[i] * pow(dist, 2.0));
+		//attenuation = attenuation * pow(clampedCosine, spotExponent[i]);
+	
+		// Diffuse light
+		float dotProd = dot(surfaceToLight, surfaceNormal);
+		dotProd = max(dotProd, 0.0);
+	
+		Id = Ld * Kd * abs(dotProd) * attenuation;
+	
+		// Specular light
+		vec3 reflection = reflect(-surfaceToLight, surfaceNormal);
+		float dotSpecular = dot(reflection, normalize(-surfacePosView));
+		dotSpecular = max(dotSpecular, 0.0);
+		float specularFactor = pow(dotSpecular, 30.0); // Specular factor
+	
+		Is = attenuation * Ls * Ks * specularFactor;
+
+		totalLighting = totalLighting + Id + Is;
+	}
+
+	fragmentColor = vec4(totalLighting, 1.0) * texel;	
+	
+
+	//fragmentColor = vec4(Id, 1.0) * texel;
+
+	//fragmentColor = texel;
+}
@@ -0,0 +1,9 @@
+#version 430
+
+uniform mat4 MVP;
+
+out vec4 FragmentColor;
+
+void main() {
+	FragmentColor = vec4(1.0, 1.0, 1.0, 1.0);
+}
@@ -0,0 +1,34 @@
+#version 430
+
+uniform mat4 MVP;
+
+layout(triangles) in;
+layout(line_strip, max_vertices = 6) out;
+
+in VertexData {
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoord;
+} Input[3];
+
+out VertexData {
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoord;
+} Output;
+
+void main()
+{
+	for (int i = 0; i < gl_in.length(); i++)
+	{
+		gl_Position = MVP * vec4(Input[i].Position, 1.0);
+		EmitVertex();
+		gl_Position = MVP * vec4(Input[i].Position + Input[i].Normal, 1.0);
+		EmitVertex();
+		EndPrimitive();
+
+		Output.Position = Input[i].Position;
+		Output.Normal = Input[i].Normal;
+		Output.TextureCoord = Input[i].TextureCoord;
+	}
+}
@@ -0,0 +1,9 @@
+#version 430
+
+uniform mat4 MVP;
+
+layout(location = 0) out float FragmentDepth;
+
+void main() {
+	FragmentDepth = gl_FragCoord.z;
+}
@@ -0,0 +1,22 @@
+#version 430
+
+uniform mat4 MVP;
+
+layout(location = 0) in vec3 Position;
+layout(location = 1) in vec3 Normal;
+layout(location = 2) in vec2 TextureCoord;
+
+out VertexData {
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoord;
+} Output;
+
+void main()
+{
+	gl_Position = MVP * vec4(Position, 1.0);
+
+	Output.Position = Position;
+	Output.Normal = Normal;
+	Output.TextureCoord = TextureCoord;
+}
@@ -0,0 +1,15 @@
+#version 430
+
+uniform samplerCube CubemapTexture;
+
+in VertexData {
+	vec3 TextureCoord;
+} Input;
+
+out vec4 FragColor;
+
+void main()
+{
+	FragColor = texture(CubemapTexture, Input.TextureCoord);
+	//FragColor = vec4(1.0, 1.0, 1.0, 0.0);
+}
@@ -0,0 +1,15 @@
+#version 430
+
+uniform mat4 MVP;
+
+layout(location = 0) in vec3 Position;
+
+out VertexData {
+	vec3 TextureCoord;
+} Output;
+
+void main()
+{
+	gl_Position = MVP * vec4(Position, 1.0);
+	Output.TextureCoord = Position;
+}
@@ -0,0 +1,25 @@
+#version 430
+
+uniform mat4 MVP;
+uniform mat4 DepthMVP;
+
+layout(location = 0) in vec3 Position;
+layout(location = 1) in vec3 Normal;
+layout(location = 2) in vec2 TextureCoord;
+
+out VertexData {
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoord;
+	vec3 ShadowCoord;
+} Output;
+
+void main()
+{
+	gl_Position = MVP * vec4(Position, 1.0);
+
+	Output.Position = Position;
+	Output.Normal = Normal;
+	Output.TextureCoord = TextureCoord;
+	Output.ShadowCoord = vec3(DepthMVP * vec4(Position, 1.0));
+}
@@ -0,0 +1,24 @@
+#version 430
+
+layout(binding = 0) uniform sampler2D DepthTexture;
+
+in VertexData {
+	vec3 Position;
+	vec2 TextureCoord;
+} Input;
+
+out vec4 FragmentColor;
+
+float LinearizeDepth(float z)
+{
+  float n = 0.1; // camera z near
+  float f = 800.0; // camera z far
+  return (2.0 * n) / (f + n - z * (f - n));	
+}
+
+void main() {
+	float z = texture(DepthTexture, Input.TextureCoord).x;
+	vec4 color = vec4(z, z, z, 0);
+
+	FragmentColor = color;
+}
@@ -0,0 +1,17 @@
+#version 430
+
+layout(location = 0) in vec3 Position;
+layout(location = 2) in vec2 TextureCoord;
+
+out VertexData {
+	vec3 Position;
+	vec2 TextureCoord;
+} Output;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+
+	Output.Position = Position;
+	Output.TextureCoord = TextureCoord;
+}