/*VERTEX_PROGRAM*/

#version 120

const int MaxLights = 8;

//varying vec3 EyePos;
varying vec2 TexCoord0;
varying vec3 ViewDir;
varying vec3 LightDir[MaxLights];
varying vec3 Normal;

uniform vec4 LightPosition[MaxLights];  // in camera space: premultiplied with ModelView
uniform vec4 LightColor[MaxLights];
uniform float NumLights;

void main(void)
{
  gl_Position = ftransform();

  TexCoord0 = vec2(gl_MultiTexCoord0);
  Normal = gl_NormalMatrix * gl_Normal;
  vec4 ObjectPosition = gl_ModelViewMatrix * gl_Vertex;
  ViewDir = -(gl_ModelViewMatrix * gl_Vertex).xyz;

  for (int i = 0; i != int(NumLights); ++i)
  {
    LightDir[i] = LightPosition[i].xyz - (gl_ModelViewMatrix * gl_Vertex).xyz;
  }
}

/*FRAGMENT_PROGRAM*/

#version 120

const int MaxLights = 8;

uniform sampler2D Texture0; // Diffuse
uniform vec4 LightColor[MaxLights];
uniform float NumLights;


varying vec2 TexCoord0;
varying vec3 ViewDir;
varying vec3 LightDir[MaxLights];
varying vec3 Normal;

void main(void)
{
  vec4 AmbientColor = vec4(0.5, 0.5, 0.5, 1.0);
  float SpecularPower = float(20.0);

//  vec3 nLightDir = normalize(LightDir[MaxLights]);

  vec3 nLightDir = vec3(0.0, 0.0, 0.0);
  for (int i = 0; i != NumLights; ++i )
  {
    nLightDir =  normalize( LightDir[i] );
  } 

  vec3 nNormal = normalize(Normal);
  vec3 nViewDir = normalize(ViewDir);

  vec4 DiffuseColor  = texture2D(Texture0, TexCoord0);  
//  vec4 SpecularColor = vec4( DiffuseColor.a ) * LightColor[MaxLights];

  vec4 SpecularColor = vec4(0.0, 0.0, 0.0, 0.0);
  for (int i = 0; i != NumLights; ++i )
  {
    SpecularColor = vec4( DiffuseColor.a ) * LightColor[i];
  } 

  vec4 CompleteAmbient = AmbientColor * DiffuseColor;

  float NormalDotLight = 0.0;

  for (int i = 0; i != NumLights; ++i )
  {
    NormalDotLight = dot( normalize( LightDir[i] ), nNormal );
  }

  vec4 CompleteDiffuse = DiffuseColor * NormalDotLight * DiffuseColor;

  vec3 Reflection = normalize(2.0 * nNormal * NormalDotLight - nLightDir);

  float ReflectionDotView = max(0.0, dot(Reflection, nViewDir));

  vec4 CompleteSpecular = SpecularColor * pow(ReflectionDotView, SpecularPower);

  gl_FragColor = CompleteAmbient + CompleteDiffuse + CompleteSpecular;
} 

/*VERTEX_PROGRAM*/

//
// all ligting is done in camera space
//

const int MaxLights = 8;

varying vec2 TexCoord0;
varying vec3 eyeNormal;
varying vec3 viewVec;
varying vec3 lightDir[MaxLights];

uniform float ENGINE_TIME;

// lights
uniform vec3 LightPosition[MaxLights];  // in camera space: premultiplied with ModelView
uniform vec4 LightColor[MaxLights];     // RGBA
uniform float NumLights;                // number of active lights

void main()
{
   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

   TexCoord0 = vec2(gl_MultiTexCoord0);
   eyeNormal = gl_NormalMatrix * gl_Normal;
   viewVec = -(gl_ModelViewMatrix * gl_Vertex).xyz;

   // if no lights are used setup dummy directional light
   lightDir[0] = vec3( 0.408250, 0.408250, 0.8165 );

   for (int i = 0; i != int(NumLights); ++i)
   {
      lightDir[i] = LightPosition[i] - (gl_ModelViewMatrix * gl_Vertex).xyz;
   }
}

/*FRAGMENT_PROGRAM*/

//#define DISABLE_LIGHTS

const int MaxLights = 8;

varying vec2 TexCoord0;
varying vec3 eyeNormal;
varying vec3 viewVec;
varying vec3 lightDir[MaxLights];

uniform vec4 LightColor[MaxLights];
uniform vec3 Attenuation[MaxLights];
uniform float NumLights;
uniform sampler2D Texture0; // Diffuse

//varying float OPACITY

vec3 GetNormal()
{
   vec3 LNormal = normalize( eyeNormal );
   return LNormal;
}

float GetAttenuation(int LightN)
{
   float Dist = length( lightDir[LightN] );

   float Att  = 1.0 / dot( Attenuation[LightN], vec3( 1.0, Dist, Dist * Dist ) );

   return Att;
}

vec4 GetAmbient()
{
   vec4 AmbientColor = vec4(0.5, 0.5, 0.5, 1.0);

   vec4 Color = vec4 (AmbientColor);

   return Color;
}

vec4 GetDiffuse(vec3 Normal)
{
   vec4 Ambient = GetAmbient();

   // accumulators
   vec4  KdVec = vec4( 0.0, 0.0, 0.0, 0.0 );

   // accumulate diffuse light from all light sources
   for (int i = 0; i != NumLights; ++i )
   {
      float LdotN = dot( normalize( lightDir[i] ), Normal );

      vec4 Kd = vec4( max( LdotN, 0.0 ) );

      Kd *= LightColor[i];

      KdVec += Kd * GetAttenuation( i );
   }

   vec4 Color = texture2D(Texture0, TexCoord0);

   Color += vec4 (Color) ;

   return Color * (vec4(1.0)-Ambient) * KdVec + Ambient * Color;
}

vec4 GetSpecular(vec3 Normal)
{
//   vec4 Color = vec4( DiffuseColor.a );
  float Color = texture2D(Texture0, TexCoord0).a;
   
   Color *= float (Color) ;


   vec4  Ks = vec4( 0.0, 0.0, 0.0, 0.0 );

   // accumulate diffuse light from all light sources
   for (int i = 0; i != NumLights; ++i )
   {
      vec3 R = reflect( -lightDir[i], Normal );

      float RdotE = max( dot( normalize(R), normalize(viewVec) ), 0.0  );

      Ks += RdotE * LightColor[i] * GetAttenuation( i );
   }

   return Color * pow( clamp( Ks, 0.0, 1.0 ), vec4(32.0) );
}

void main()
{
   vec3 EN = GetNormal();

   vec4 Diffuse  = GetDiffuse( EN );
   vec4 Specular = GetSpecular( EN );

   vec4 FinalColor = Diffuse + Specular;

   gl_FragColor = FinalColor;
}