const int MAX_POINT_LIGHTS = 8;
 
struct PLPointLight {
    vec4 vLightPosition;
   
    vec3 vDiffuse;
    vec3 vSpecular;
   
    float fConstantAttenuation;
    float fLinearAttenuation;
    float fQuadraticAttenuation;
    float fCubicAttenuation;
    float fQuarticAttenuation;
};
 
uniform mat4 pl_ModelViewMatrix;
uniform mat4 pl_ProjectionMatrix;
uniform mat4 pl_ModelViewProjectionMatrix;
 
uniform vec3 pl_GlobalAmbient;
 
uniform PLPointLight pl_PointLights[MAX_POINT_LIGHTS];
 
varying vec3 vNormal;
varying vec4 vEyeCameraPosition;
 
void main() {
    // Set up color vector.
    vec3 vColor = pl_GlobalAmbient;
   
    // Loop from 0 to MAX_POINT_LIGHTS:
    for(int i=0; i<2; ++i) {
        // Calculate aux vector.
        vec3 vAux = pl_PointLights[i].vLightPosition.xyz - vec3(vEyeCameraPosition);
       
        // Calculate light direction and light distance.
        vec3 vLightDir = normalize(vAux);
        float fDistance = length(vAux);
       
        // Calculate half vector.
        vec3 vHalfVector = normalize(vLightDir - normalize(vec3(vEyeCameraPosition)));
       
        // Calculate interpolated normal.
        vec3 vInterpNormal = normalize(vNormal);
       
        // Calculate dot product of normal vector and light vector.
        float fNDotL = max(0.0, dot(vInterpNormal, normalize(vLightDir)));
       
        if(fNDotL > 0.0) {
            // Calculate light attenuation.
            float fAttenuation = 1.0 / (pl_PointLights[i].fConstantAttenuation +
                                        pl_PointLights[i].fLinearAttenuation * fDistance +
                                        pl_PointLights[i].fQuadraticAttenuation * fDistance * fDistance +
                                        pl_PointLights[i].fCubicAttenuation * fDistance * fDistance * fDistance +
                                        pl_PointLights[i].fQuarticAttenuation * fDistance * fDistance * fDistance * fDistance);
           
            // Add diffuse and ambient components to color.
            vColor += fAttenuation * (pl_PointLights[i].vDiffuse * fNDotL);
           
            // Calculated interpolated half vector.
            vec3 vInterpHalfVector = normalize(vHalfVector);
           
            // Calculate dot product of normal vector and half vector.
            float fNDotHV = max(0.0, dot(vInterpNormal, vInterpHalfVector));
           
            // Add specular component to color.
            vColor += fAttenuation * pl_PointLights[i].vSpecular * pow(fNDotHV, 64.0);
        }
    }
   
    // Set final color.
    gl_FragColor = vec4(vColor, 1.0);
}