uniform sampler2DShadow ShadowMap;

uniform sampler2DShadow ShadowMapFar;

uniform sampler2D NormalMap;

 

varying vec4 ShadowCoord;

varying vec4 ShadowCoord2;

varying vec3 vertex_normal;

varying vec3 vertex_light_position;

 

uniform float xPixelOffset;

uniform float yPixelOffset;

 

 

float lookupNear(vec2 offSet)

{

    return shadow2D(ShadowMap, vec3(ShadowCoord) + vec3(offSet.x * xPixelOffset * ShadowCoord.r, offSet.y * yPixelOffset * ShadowCoord.r, 0.0)).r;

}

 

float lookupFar(vec2 offSet)

{

    return shadow2D(ShadowMapFar, vec3(ShadowCoord2) + vec3(offSet.x * xPixelOffset * ShadowCoord2.r, offSet.y * yPixelOffset * ShadowCoord2.r, 0.0)).r;

}

 

 

void main()

{  

    float shadow=0.0, x, y;

 

    vec2 o = mod(floor(gl_FragCoord.xy), 2.0);

    shadow = lookupNear(vec2(-1.5, 1.5) + o);

    shadow += lookupNear(vec2( 0.5, 1.5) + o);

    shadow += lookupNear(vec2(-1.5, -0.5) + o);

    shadow += lookupNear(vec2( 0.5, -0.5) + o);

    shadow = (shadow * 0.25) + 0.3;

 

    if (shadow >= 0.5) {

        shadow = lookupFar(vec2(-1.5, 1.5) + o);

        shadow += lookupFar(vec2( 0.5, 1.5) + o);

        shadow += lookupFar(vec2(-1.5, -0.5) + o);

        shadow += lookupFar(vec2( 0.5, -0.5) + o);

        shadow = (shadow * 0.25) + 0.3;

    }

 

    float diffuse_value = max(dot(vertex_normal, vertex_light_position), 0.0) + 0.3;

    vec4 texel = texture2DProj(NormalMap, gl_TexCoord[0]);

    if (diffuse_value < shadow)

        texel.rgb *= diffuse_value;

    else

        texel.rgb *= shadow;

 

    gl_FragColor = texel * gl_Color;

}

varying vec4 ShadowCoord;

varying vec4 ShadowCoord2;

varying vec3 vertex_normal;

varying vec3 vertex_light_position;

 

void main()

{

    ShadowCoord = gl_TextureMatrix[1] * gl_Vertex;

    ShadowCoord2 = gl_TextureMatrix[2] * gl_Vertex;

    gl_TexCoord[0] = gl_MultiTexCoord0;

    gl_Position = ftransform();

 

    vertex_normal = normalize(gl_NormalMatrix * gl_Normal);

    vertex_light_position = normalize(gl_LightSource[0].position.xyz);

    gl_FrontColor = gl_Color;

}

procedure TglEngine.RenderShadow(const aFBO: TgluFrameBufferObject; const Size: Integer = 1024);

var

  lVec, p: TgluVector4f;

  Cam: TgluCamera;

 

  procedure SaveTextureMatrix(const aTextureUnit: glEnum);

  var

    mMod, mPro, mBias: TgluMatrix4f;

  begin

    mBias[maAxisX] := gluVector4f(0.5, 0.0, 0.0, 0.0);

    mBias[maAxisY] := gluVector4f(0.0, 0.5, 0.0, 0.0);

    mBias[maAxisZ] := gluVector4f(0.0, 0.0, 0.5, 0.0);

    mBias[maPos]   := gluVector4f(0.5, 0.5, 0.5, 1.0);

 

    glGetFloatv(GL_MODELVIEW_MATRIX, @mMod[0,0]);

    glGetFloatv(GL_PROJECTION_MATRIX, @mPro[0,0]);

 

    glMatrixMode(GL_TEXTURE);

    glActiveTexture(aTextureUnit);

    glLoadIdentity;

    glLoadMatrixf(@mBias[0,0]);

    glMultMatrixf(@mPro[0,0]);

    glMultMatrixf(@mMod[0,0]);

    glActiveTexture(GL_TEXTURE0);

    glMatrixMode(GL_MODELVIEW);

  end;

 

begin

  if Assigned(fScene) and Assigned(aFBO) then begin

    aFBO.Bind;

    glClear(GL_DEPTH_BUFFER_BIT or GL_COLOR_BUFFER_BIT);

 

    p := gluVector4f(0, 0, 0, 0);

    Cam := fScene.ActiveCam;

    if Assigned(Cam) then

      p := gluMatrixInvert(Cam.Position)[maPos];

    p[3] := Size/2;

 

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity;

    glOrtho(-p[3], p[3], -p[3], p[3], -p[3], p[3]);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity;

 

    lVec := fScene.GlobLight.Position;

    gluLookAt(

      p[0], p[1], p[2],                             //Pos

      -lVec[0]+p[0], -lVec[1]+p[1], -lVec[2]+p[2],  //Center

      0, 1, 0);                                     //UP-Vec

 

    glEnable(GL_DEPTH_TEST);

    glEnable(GL_CULL_FACE);

    glCullFace(GL_FRONT);

    SaveTextureMatrix(GL_TEXTURE7);

    RenderScene([rmShadowMapObj]);

    glCullFace(GL_BACK);

 

    aFBO.Unbind;

  end;

end;    

varying vec3 N;

varying vec3 V;

varying vec3 LightVec;

varying vec4 ShadowPos;

 

void main(void)

{

    gl_TexCoord[0]  = gl_MultiTexCoord0;

    gl_Position     = gl_ModelViewProjectionMatrix * gl_Vertex;

    N               = normalize(gl_NormalMatrix * gl_Normal);

    V               = vec3(gl_ModelViewMatrix * gl_Vertex);

    LightVec        = normalize(gl_LightSource[0].position.xyz - V * gl_LightSource[0].position.w);

    ShadowPos       = gl_TextureMatrix[7] * gl_Vertex;

}

varying vec3 N;

varying vec3 V;

varying vec3 LightVec;

varying vec4 ShadowPos;

 

void main(void){

    vec2 TexCoord = gl_TexCoord[0].xy;

    vec3 Eye = normalize(-V);

 

    vec3 Reflected = normalize(reflect(-LightVec, N));

    vec4 IAmbient  = gl_LightSource[0].ambient  * gl_FrontMaterial.ambient;

    vec4 IDiffuse  = gl_LightSource[0].diffuse  * gl_FrontMaterial.diffuse  * max(dot(/*IFDEF NORMALMAP*/normal/*ELSE*/N/*ENDIF*/, LightVec), 0.0);

    vec4 ISpecular = gl_LightSource[0].specular * gl_FrontMaterial.specular * pow(max(dot(Reflected, Eye), 0.0), gl_FrontMaterial.shininess);

 

    float shadow = 1.0;

    if (ShadowPos.w > 0.0){

        vec4 NormalShadowPos = ShadowPos / ShadowPos.w;

        float distanceFromLight = texture2D(uShadowMap, NormalShadowPos.xy).r;

        shadow = ((NormalShadowPos.z - distanceFromLight) > 0.0 ? 0.0 : 1.0);

       

        float depth = texture2D(uShadowMap, NormalShadowPos.xy).r;

        vec4 border = vec4(0.0, 0.0, 0.0, 0.0);

        border.xy = smoothstep(0.0, 0.1, NormalShadowPos.xy);

        border.zw = smoothstep(0.0, 0.1, -NormalShadowPos.xy + vec2(1.0, 1.0));

        float f = border.x * border.y * border.z * border.w * smoothstep(0.0, 0.1, -depth + 1.0) * smoothstep(0.0, 0.1, depth);

        shadow = shadow * f + (1.0 - f);

    }  

 

    gl_FragColor = (IAmbient + (IDiffuse + ISpecular) * shadow);

}