normalpoint.shader

varying vec4 vColour;
varying vec3 vEye;
varying vec3 vLightDir;
varying float vDist;
varying vec4 vProjected;

attribute vec3 tangent;

void main() 
{
    //Put the color in a varying variable
    vColour = gl_Color * gl_FrontMaterial.diffuse;

    //Use the first set of texture coordinates in the fragment shader 
    gl_TexCoord[0] = gl_MultiTexCoord0;

    // Get the normal and normalize
    vec3 vN = normalize( gl_NormalMatrix * gl_Normal );

    // Get this fragment's position
    vec4 vPos = gl_ModelViewMatrix * gl_Vertex;

    // Get the light's direction
    vec3 vTmp = gl_LightSource[0].position.xyz - vPos.xyz;

    // Get the distance
    vDist = length( vTmp );

///// Normal mapping specific:

    // Get the tangent and normalise
    vec3 vT = normalize( gl_NormalMatrix * tangent );

    // Get the binormal
    vec3 vB = cross( vN, vT );

    // Get the light's direction
    vLightDir.x = dot( vTmp, vT );
    vLightDir.y = dot( vTmp, vB );
    vLightDir.z = dot( vTmp, vN );

    // Get the eye vector
    vTmp = -vPos.xyz;
    vEye.x = dot( vTmp, vT );
    vEye.y = dot( vTmp, vB );
    vEye.z = dot( vTmp, vN );

///// Shadow specific:

    // Get the projected position
    vProjected = vPos;

    // Transform the position to screen space
    gl_Position = ftransform(); 
}

~~~~~

varying vec4 vColour;
varying vec3 vEye;
varying vec3 vLightDir;
varying float vDist;

uniform sampler2D Texture0;
uniform sampler2DShadow Texture1;
uniform sampler2DShadow Texture2;
uniform sampler2DShadow Texture3;
uniform sampler2DShadow Texture4;
uniform sampler2DShadow Texture5;
uniform sampler2DShadow Texture6;

uniform int vShadowCount;
varying vec4 vProjected;

void main() 
{
    // Get the ambient colour as a base
    vec4 vBase = vec4( 0, 0, 0, 0 ); 
    vec4 vLight = vec4( 0, 0, 0, 0 );
    float att = 0.0;

    // If we have a shadow...
    if ( vShadowCount > 0 )
    {
        // Transform the projected vector
        vec4 tmp[6];
        tmp[0] = gl_TextureMatrix[1] * vProjected;
        tmp[1] = gl_TextureMatrix[2] * vProjected;
        tmp[2] = gl_TextureMatrix[3] * vProjected;
        tmp[3] = gl_TextureMatrix[4] * vProjected;
        tmp[4] = gl_TextureMatrix[5] * vProjected;
        tmp[5] = gl_TextureMatrix[6] * vProjected;
    
        // Get the shadow
        vBase += shadow2D( Texture1, tmp[0].xyz / tmp[0].w );
        /*
        vBase += shadow2D( Texture2, tmp[1].xyz / tmp[1].w );
        vBase += shadow2D( Texture3, tmp[2].xyz / tmp[2].w );
        vBase += shadow2D( Texture4, tmp[3].xyz / tmp[3].w );
        vBase += shadow2D( Texture5, tmp[4].xyz / tmp[4].w );
        vBase += shadow2D( Texture6, tmp[5].xyz / tmp[5].w );
        */
    }

    // Get the bump vector
    vec3 vN = normalize( texture2D( Texture0, gl_TexCoord[0].xy ).xyz * 2.0 - 1.0 );
    vN.y = -vN.y;

    // Get the light vector
    vec3 vL = normalize( vLightDir );

    // Get NdotL and make sure it's +ve before getting the specular
    float NdotL = dot( vN, vL );

    // Do we do specular?
    if ( NdotL > 0.0 )
    {
        // Get the attenuation
        att = 1.0 / ( gl_LightSource[0].constantAttenuation +
                gl_LightSource[0].linearAttenuation * vDist +
                gl_LightSource[0].quadraticAttenuation * vDist * vDist );

        // Add the diffuse component of the light
        vLight = NdotL * gl_LightSource[0].diffuse;

        // Get the eye vector
        vec3 vE = normalize( vEye );

        // Get the reflection vector
        vec3 R = reflect( -vL,  vN );

        // Dot it with the eye
        NdotL = max( dot( R, vE ), 0.0 ); 

        // Now add the specular component
        vLight +=   pow( NdotL, gl_FrontMaterial.shininess ) *      // Power
                    gl_FrontMaterial.specular *                     // Material Specular
                    gl_LightSource[0].specular;                     // Light Specular
    }

    // Output the fragment colour
    gl_FragColor = vBase * att * vLight;
}

---