#version 120
const int max_lights = 4;

uniform sampler2D projMap0;
uniform sampler2D projMap1;
uniform sampler2D projMap2;
uniform sampler2D projMap3;

uniform sampler2D shadowMaps0;
uniform sampler2D shadowMaps1;
uniform sampler2D shadowMaps2;
uniform sampler2D shadowMaps3;
uniform sampler2D Texture0;

uniform vec4 LampColors[max_lights];       //Lichtfarbe und intensität
uniform int GlobalLight;                //gibt an ob globales Punktlicht verwendet werden soll
uniform vec4 LightPos[max_lights];          //Lampenpositionen für evtl. weitere Berechnungen
uniform vec4 ShadowActive;                //Gibt an ob Schatten für Lampe 1-4 Aktiv
uniform float GlobalLightFactor;           //Gibt an wie stark alle Lichter sind
 


//MAX 32 FLOATS!!      
varying vec3 anormal;
varying vec4 posEye;
varying vec3 globalLightVec;
varying vec4 projCoord[max_lights];
 
 
void main (void)
{
 vec4  ProjMapColor[max_lights];
 vec4  backgroundColor, projColor;
 vec4  global_color;
 vec3  lightDir, L; 
 float d, att, lambertTerm;
 vec3 normal = normalize(anormal);

 //Hintergrund Farbe
  if (gl_FrontMaterial.ambient.a > 0.0) {
  //keine Textur
     backgroundColor = gl_FrontMaterial.ambient;
   }   else
      backgroundColor = texture2D(Texture0, gl_TexCoord[0].xy);


 //Globales Punktlicht
  if (GlobalLight>0) {
     
     vec3 Reflected = normalize(reflect( -globalLightVec, normal)); 
     vec3 Eye = normalize(-posEye.xyz);      
    vec4 IAmbient  = gl_LightSource[0].ambient * gl_FrontMaterial.ambient;
    vec4 IDiffuse  =   gl_LightSource[0].diffuse * max(dot(normal, globalLightVec), 0.0) * gl_FrontMaterial.diffuse;
    vec4 ISpecular = gl_LightSource[0].specular * pow(max(dot(Reflected, Eye), 0.0), gl_FrontMaterial.shininess) * gl_FrontMaterial.specular;
    global_color = vec4((gl_FrontLightModelProduct.sceneColor + IAmbient + IDiffuse) * backgroundColor + ISpecular);
    }

 vec4 final_color;
 
 
 
 //GoboTexturen abrufen
 ProjMapColor[0] = texture2DProj(projMap0, projCoord[0]);
 ProjMapColor[1] = texture2DProj(projMap1, projCoord[1]);
 ProjMapColor[2] = texture2DProj(projMap2, projCoord[2]);
 ProjMapColor[3] = texture2DProj(projMap3, projCoord[3]);

   vec4  shadowCoordWdiv[max_lights];
   float distanceFromLight[max_lights];
   if (any(greaterThan(ShadowActive, vec4(0.0, 0.0, 0.0, 0.0))))    {
   
   //Schatten
     for (int i=0; i < max_lights; ++i) 
         if(projCoord[i].q < 0.0) {   
    
       vec4 SK = projCoord[i]; 
          SK = (SK+1) * 0.5;         
         SK.z += 2;      
         shadowCoordWdiv[i] =  (SK / SK.w);      
         shadowCoordWdiv[i].z += 0.0005;            
       }
      
     distanceFromLight[0] = texture2D(shadowMaps0, shadowCoordWdiv[0].st).z;   
     distanceFromLight[1] = texture2D(shadowMaps1, shadowCoordWdiv[1].st).z;
     distanceFromLight[2] = texture2D(shadowMaps2, shadowCoordWdiv[2].st).z;
     distanceFromLight[3] = texture2D(shadowMaps3, shadowCoordWdiv[3].st).z;
 
 }
 
 
 float shadow = 1.0;
 //Projektion für jede Lampe 
  for (int i=0; i < max_lights; ++i) 
   if(projCoord[i].q < 0.0) {
     {
      lightDir = vec3(LightPos[i].xyz - posEye.xyz);   
               
      L = normalize(lightDir);
      lambertTerm = dot(normal, L);
       if (lambertTerm>0) {
      
         shadow = 1.0;
      if (ShadowActive[i]>0)
        shadow = distanceFromLight[i] < shadowCoordWdiv[i].z ? 0 : 1.0;
   
      
      if (shadow==1)    
        {      
         d = length(lightDir);
         att = 1.0 / ( gl_LightSource[1].constantAttenuation +
         (gl_LightSource[1].linearAttenuation*d) +
         ((gl_LightSource[1].quadraticAttenuation/2)*d*d));       
 
               
         projColor = LampColors[i] * lambertTerm * att * LampColors[i].a;          
         final_color += ProjMapColor[i] * projColor   * GlobalLightFactor ; 
        }
      }
    }
     } 
   gl_FragColor = (final_color * backgroundColor) + global_color;
}

shadow = distanceFromLight[i] < shadowCoordWdiv[i].z ? 0.0 : 1.0;