uniform sampler2D texture;
uniform sampler2D normalTexture;

uniform vec4 lightOneAmbient;
uniform vec4 lightOneDiffuse;
uniform vec4 lightOneSpecular;
uniform vec4 lightOneDirection;
varying vec3 lightOneVector;

uniform vec4 lightTwoAmbient;
uniform vec4 lightTwoDiffuse;
uniform vec4 lightTwoSpecular;
uniform vec4 lightTwoDirection;
varying vec3 lightTwoVector;

uniform float shininess;

varying vec2 textureCoordinate;

varying vec3 viewVector;

varying vec3 normal;

/*
 * This function is based on the function from the Orange Book.
 */
void DirectionalLight( in vec3 normal,
                       in vec3 lightHalfVector,
                       in vec3 lightPosition,
                       in vec4 lightAmbient,
                       in vec4 lightDiffuse,
                       in vec4 lightSpecular,
                       inout vec4 ambient,
                       inout vec4 diffuse,
                       inout vec4 specular )
{
   float nDotVP; // normal dot lightDir
   float pf;     // power factor
   
   nDotVP = max( 0.0, dot( normal, lightPosition ) );
   
   if ( nDotVP == 0.0 )
   {
      pf = 0.0;
   }
   else
   {
      float nDotHV = max( 0.0, dot( normal, vec3( lightHalfVector ) ) );
      pf = pow( nDotHV, shininess );
   }

   ambient += lightAmbient;
   diffuse += lightDiffuse * nDotVP;
   specular += lightSpecular * pf;
}

void main(void)
{
   vec3 normalReading = texture2D( normalTexture, textureCoordinate ).xyz;
   vec3 direction = ( normalize( lightOneDirection.xyz ) + normalize( lightTwoDirection.xyz ) ) / 2.0;
   vec3 bump = vec3( dot( normalReading, direction ) );
   
   vec3 bumpedNormal = bump * normal;
   
   vec4 ambientColor = vec4( 0.0 );
   vec4 diffuseColor = vec4( 0.0 );
   vec4 specularColor = vec4( 0.0 );

   DirectionalLight( bumpedNormal,
                     normalize( normalize( viewVector ) + normalize( lightOneVector.xyz ) ),
                     lightOneVector,
                     lightOneAmbient,
                     lightOneDiffuse,
                     lightOneSpecular,
                     ambientColor,
                     diffuseColor,
                     specularColor );
               
   DirectionalLight( bumpedNormal,
                     normalize( normalize( viewVector ) + normalize( lightTwoVector.xyz ) ),
                     lightTwoVector,
                     lightTwoAmbient,
                     lightTwoDiffuse,
                     lightTwoSpecular,
                     ambientColor,
                     diffuseColor,
                     specularColor );

   ambientColor = clamp( ambientColor, 0.0, 1.0 );
   diffuseColor = clamp( diffuseColor, 0.0, 1.0 );
   specularColor = clamp( specularColor, 0.0, 1.0 );

   gl_FragColor = ( ambientColor + diffuseColor ) * texture2D( texture, textureCoordinate ) + specularColor;  
}