uniform sampler2D Texture0;   // Color - Texture
uniform sampler2D Texture1;   // Normal - Texture
uniform sampler2D Texture2;   // Depth - Texture

varying mat4 matProjectionInverse;
varying mat4 matModelView;

const float f = 10000.0;
const float n = 0.1;

void main() {
   vec2 texcoord = vec2(gl_TexCoord[0]);

   vec4 vColor = texture2D(Texture0, texcoord);
   float fDepth = texture2D(Texture2, texcoord).x;

   // Infinity = no light
   if(fDepth >= 1.0) {
      gl_FragColor = vec4(vColor.rgb, 1.0);
      discard;
   }

   vec4 vNormal = texture2D(Texture1, texcoord);
   vNormal.xyz = vNormal.xyz * 2.0 - 1.0;


   // === Hier liegt das Problem ===

   float fZ = (2.0 * n) / (f + n - fDepth * (f - n));

   vec4 vVertex = vec4(texcoord.xy, fDepth, 1.0) * matProjectionInverse;
   vVertex.xyz /= vVertex.w;

   // ==============================


   vec3 ISpecular = vec3(0.0, 0.0, 0.0);
   vec3 IDiffuse = vec3(0.0, 0.0, 0.0);
   vec3 vEye = normalize(-vVertex.xyz);
   float lightFactor;

   for(int i = 0; i < 8; i++) {
      if(gl_LightSource[i].constantAttenuation > 0.0) {
         if(gl_LightSource[i].position.w == 1.0) {
            lightFactor = 1.0 - min(distance(gl_LightSource[i].position.xyz, vVertex.xyz) / gl_LightSource[i].constantAttenuation, 1.0);
         }
         else {
            lightFactor = 1.0;
         }

         if(lightFactor > 0.0) {
            vec3 vLight = normalize(gl_LightSource[i].position.xyz - vVertex.xyz);
            vec3 Reflected = normalize(reflect(-vLight, vNormal.xyz));
            float fDiffuse = lightFactor * (vColor.w * gl_LightSource[i].diffuse.x);
            float fSpecular = lightFactor * (vNormal.w * gl_LightSource[i].specular.x);

            IDiffuse  += fDiffuse * max(dot(vNormal.xyz, vLight), 0.0);
            ISpecular += fSpecular * pow(max(dot(Reflected, vEye), 0.0), 128.0);
         }
      }
   }

   gl_FragColor = vec4((IDiffuse + ISpecular) * vColor.rgb, 1.0);
}

uniform float fProj[16];

varying mat4 matProjectionInverse;
varying mat4 matModelView;

void main(void) {
   mat4 matProjection;

   matProjection[0][0] = fProj[0];
   matProjection[0][1] = fProj[1];
   matProjection[0][2] = fProj[2];
   matProjection[0][3] = fProj[3];

   matProjection[1][0] = fProj[4];
   matProjection[1][1] = fProj[5];
   matProjection[1][2] = fProj[6];
   matProjection[1][3] = fProj[7];

   matProjection[2][0] = fProj[8];
   matProjection[2][1] = fProj[9];
   matProjection[2][2] = fProj[10];
   matProjection[2][3] = fProj[11];

   matProjection[3][0] = fProj[12];
   matProjection[3][1] = fProj[13];
   matProjection[3][2] = fProj[14];
   matProjection[3][3] = fProj[15];

   matProjectionInverse = gl_ModelViewProjectionMatrixInverse;
   matModelView = gl_ModelViewMatrix;

   gl_TexCoord[0] = gl_MultiTexCoord0;
   gl_Position = matProjection * gl_Vertex;
}

void main() {
   gl_Position = vec4(gl_Vertex.xy, 0, 1);

   gl_TexCoord[0].st = gl_Vertex.st * vec2(0.5,0.5) + vec2(0.5,0.5);
   gl_TexCoord[0].pq = vec2(0,0);
}

const float vertices[] = {
      -1.0,  1.0,
      1.0,  1.0,
      -1.0, -1.0,
      -1.0, -1.0,
      1.0,  1.0,
      1.0, -1.0
};

vec4 vertex;
vertex.xy = gl_TexCoord[0].st * 2.0 - 1.0;

vertex.z = fDepth * 2.0 - 1.0;

vertex.w = 1.0;
vertex = vertex * gl_ProjectionMatrixInverse;
vertex *= 1.0/vertex.w;

uniform sampler2D Texture0;   // Color - Texture
uniform sampler2D Texture1;   // Normal - Texture
uniform sampler2D Texture2;   // Depth - Texture

varying mat4 matProjectionInverse;

void main() {
   vec2 texcoord = vec2(gl_TexCoord[0]);
   vec4 vColor = texture2D(Texture0, texcoord);
   float fDepth = texture2D(Texture2, texcoord).x;

   if(fDepth >= 1.0) {
      gl_FragColor = vec4(vColor.rgb, 1.0);
      discard;
   }

   vec4 vNormal = texture2D(Texture1, texcoord);
   vNormal.xyz = vNormal.xyz * 2.0 - 1.0;

   vec4 vVertex;
   vVertex.xy = gl_TexCoord[0].st * 2.0 - 1.0;
   vVertex.z = fDepth * 2.0 - 1.0;
   vVertex.w = 1.0;
   vVertex *= matProjectionInverse;
   vVertex *= 1.0/vVertex.w;

   float ISpecular = 0.0;
   float IDiffuse = 0.0;
   float lightFactor;

   vec3 vEye = normalize(-vVertex.xyz);

   for(int i = 0; i < 8; i++) {
      if(gl_LightSource[i].constantAttenuation > 0.0) {
         if(gl_LightSource[i].position.w == 1.0) {
            lightFactor = 1.0 - min(distance(gl_LightSource[i].position.xyz, vVertex.xyz) / gl_LightSource[i].constantAttenuation, 1.0);
         }
         else {
            lightFactor = 1.0;
         }

         if(lightFactor > 0.0) {
            vec3 vLight = normalize(gl_LightSource[i].position.xyz - vVertex.xyz);
            vec3 Reflected = normalize(reflect(-vLight, vNormal.xyz));
            float fDiffuse = lightFactor * (vColor.w * gl_LightSource[i].diffuse.x);
            float fSpecular = lightFactor * (vNormal.w * gl_LightSource[i].specular.x);

            IDiffuse  += fDiffuse * max(dot(vNormal.xyz, vLight), 0.0);
            ISpecular += fSpecular * pow(max(dot(Reflected, vEye), 0.0), 128.0);
         }
      }
   }

   gl_FragColor = vec4((IDiffuse + ISpecular) * vColor.rgb, 1.0);
}

varying mat4 matProjectionInverse;

void main(void) {
   matProjectionInverse = gl_ProjectionMatrixInverseTranspose;

   gl_TexCoord[0].st = gl_Vertex.st * vec2(0.5, 0.5) + vec2(0.5, 0.5);
   gl_TexCoord[0].pq = vec2(0.0, 0.0);

   gl_Position = vec4(gl_Vertex.xy, 0.0, 1.0);
}

varying vec3 vNormal;

void main(void) {
   vec3 vResult = (vNormal + 1.0) / 2.0;
   gl_FragColor = vec4(vResult, gl_FrontMaterial.specular.x);
}

uniform sampler2D Texture0;

void main(void) {
   vec2 texcoord = vec2(gl_TexCoord[0]);
   vec3 vColor = texture2D(Texture0, texcoord).rgb;
   gl_FragColor = vec4(vColor, gl_FrontMaterial.diffuse.x);
}