normalspot.shader

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

attribute vec3 tangent;

uniform int vShadowCount;
varying vec4 vProjected;

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 half vector
    vTmp = gl_LightSource[0].halfVector.xyz;
    vHalf.x = dot( vTmp, vT );
    vHalf.y = dot( vTmp, vB );
    vHalf.z = dot( vTmp, vN );

    // Get the spot direction
    vTmp = gl_LightSource[0].spotDirection;
    vSpot.x = dot( vTmp, vT );
    vSpot.y = dot( vTmp, vB );
    vSpot.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 = gl_TextureMatrix[1] * vPos;

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

~~~~~

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

uniform sampler2D Texture0;
uniform sampler2DShadow Texture1;

uniform int vShadowCount;
varying vec4 vProjected;

#define KERNEL_SIZE   3.0
#define KERNEL_AREA  16.0
#define BLUR        0.003

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

    // If we have a shadow...
    if ( vShadowCount > 0 )
    {
        // Normalize the projected vector
        vec3 tmp = vProjected.xyz / vProjected.w;
    
        // If it's not in range, set depth to zero anyway
        if ( tmp.x >= 0.0 && tmp.x <= 1.0 && tmp.y >= 0.0 && tmp.y <= 1.0 )
        {
            // Mark as in shadow or not, depending on the map
            // vBase += shadow2D( Texture1, tmp );
            for ( float x = -KERNEL_SIZE + 1.0; x < KERNEL_SIZE; x += 1.0 )
            {
                for ( float y = -KERNEL_SIZE + 1.0; y < KERNEL_SIZE; y += 1.0 )
                {
                    vBase += shadow2D( Texture1, tmp + vec3( BLUR * x, BLUR * y, 0 ) );
                }
            }
            vBase /= KERNEL_AREA;
        }
    }

    // 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 );

    // Get the attenuation
    float att = 0.0;

    // Do we do specular?
    if ( NdotL > 0.0 )
    {
        // Get the spot direction
        vec3 vS = normalize( vSpot );

        // Get the effected area of the spotlight
        float effect = dot( vS, -vL );

        // If it's in range...
        if ( effect > gl_LightSource[0].spotCosCutoff )
        {
            // Boost the effect
            effect = pow( effect, gl_LightSource[0].spotExponent );

            // Get the attenuation
            att = effect / ( gl_LightSource[0].constantAttenuation +
                    gl_LightSource[0].linearAttenuation * vDist +
                    gl_LightSource[0].quadraticAttenuation * vDist * vDist );

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

            // Get the half vector
            vec3 vH = normalize( vHalf );

            // Dot it with the eye
            NdotL = max( dot( vN, vH ), 0.0 ); 

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

    // Output the fragment colour
    gl_FragColor = vec4( vBase.xyz, 1 ) * vLight;
}

---