Skip to main content
Depth Shadow Mapping         How to implement depth shadow mapping in your own project as seen in the Shadows demo
1
Page actions
Print

Beginners guide to Depth Shadow Mapping

This short guide is intended to help those who have limited knowledge of shaders and want to implement Depth Shadow Mapping into their ogre application as shown in the Shadows demo.

I'm going to assume you have already read the Basic Tutorial 2 about shadows, if you have not please do so now (Basic Tutorial 2). Depth Shadow Mapping is done using texture shadows, and is basically an extension of what you get from just using setShadowTechnique(SHADOWTYPE_TEXTURE_ADDITIVE). The problems with setting SHADOWTYPE_TEXTURE_ADDITIVE alone are:

  • You need to separate shadow casters from shadow receivers
  • Shadow casters cannot receive shadows (thus self-shadowing is not possible)
  • You will see shadows where there shouldn't be any if you shadow receiver ever gets between a shadow caster and the light source


Depth Shadow Mapping can be used to solve all of these issues, however it requires using shaders which can be difficult for those not familiar with them. My aim is to give a step by step guide on how to implement the shaders without giving all the details and theory behind the technique (these details can be found elsewhere, see links at the bottom of the page).

The first step is to get shadows working as described in Basic Tutorial 2 using the SHADOWTYPE_TEXTURE_ADDITIVE technique.

Once you have done this, the following additional steps must be followed:

  • Define the necessary shaders (2 fragment programs and 2 vertex programs for casting and receiving shadows + at least 1 custom shader)
  • Define the necessary materials (1 generic material for casting shadows, materials for all the entities you want shadows to be cast on)
  • Make a few modifications to the C++ code to set up shadows



Defining the shaders

The shaders used in the Shadows demo are stored in the ogre folder under Samples/Media/materials/programs and have file names starting with "DepthShadowmap". In fact each shader is implemented twice, once for OpenGL and once for DirectX. I am going to present the shaders written in Cg instead so that you only need to define each shader once (these will still work in both OpenGL and DirectX). The reason this wasn't done in the first place is that there where some bugs with Cg at the time the shadows demo was implement but these have now been resolved.

Since I'm assuming your shader knowledge is quite limited, I'm not going to attempt to explain what the lines of code do and just expect you to follow the steps 😊.

First create a file named "DepthShadowmap.cg" and put the following contents:

DepthShadowmap.cg

Copy to clipboard
/* This file implements standard programs for depth shadow mapping. 
   These particular ones are suitable for additive lighting models, and
   include 3 techniques to reduce depth fighting on self-shadowed surfaces,
   constant bias, gradient (slope-scale) bias, and a fuzzy shadow map comparison*/

// Shadow caster vertex program.
void casterVP(
    float4 position            : POSITION,
    out float4 outPos        : POSITION,
    out float2 outDepth        : TEXCOORD0,

    uniform float4x4 worldViewProj,
    uniform float4 texelOffsets,
    uniform float4 depthRange
    )
{
    outPos = mul(worldViewProj, position);

    // fix pixel / texel alignment
    outPos.xy += texelOffsets.zw * outPos.w;
    // linear depth storage
    // offset / scale range output
#if LINEAR_RANGE
    outDepth.x = (outPos.z - depthRange.x) * depthRange.w;
#else
    outDepth.x = outPos.z;
#endif
    outDepth.y = outPos.w;
}

// Shadow caster fragment program for high-precision single-channel textures    
void casterFP(
    float2 depth            : TEXCOORD0,
    out float4 result        : COLOR)
    
{
#if LINEAR_RANGE
    float finalDepth = depth.x;
#else
    float finalDepth = depth.x / depth.y;
#endif
    // just smear across all components 
    // therefore this one needs high individual channel precision
    result = float4(finalDepth, finalDepth, finalDepth, 1);
}

void receiverVP(
    float4 position        : POSITION,
    float4 normal        : NORMAL,

    out float4 outPos            : POSITION,
    out float4 outColour        : COLOR,
    out float4 outShadowUV        : TEXCOORD0,

    uniform float4x4 world,
    uniform float4x4 worldIT,
    uniform float4x4 worldViewProj,
    uniform float4x4 texViewProj,
    uniform float4 lightPosition,
    uniform float4 lightColour,
    uniform float4 shadowDepthRange
    )
{
    float4 worldPos = mul(world, position);
    outPos = mul(worldViewProj, position);

    float3 worldNorm = mul(worldIT, normal).xyz;

    // calculate lighting (simple vertex lighting)
    float3 lightDir = normalize(
        lightPosition.xyz -  (worldPos.xyz * lightPosition.w));

    outColour = lightColour * max(dot(lightDir, worldNorm), 0.0);

    // calculate shadow map coords
    outShadowUV = mul(texViewProj, worldPos);
#if LINEAR_RANGE
    // adjust by fixed depth bias, rescale into range
    outShadowUV.z = (outShadowUV.z - shadowDepthRange.x) * shadowDepthRange.w;
#endif
}

void receiverFP(
    float4 position            : POSITION,
    float4 shadowUV            : TEXCOORD0,
    float4 vertexColour        : COLOR,

    uniform sampler2D shadowMap : register(s0),
    uniform float inverseShadowmapSize,
    uniform float fixedDepthBias,
    uniform float gradientClamp,
    uniform float gradientScaleBias,
    uniform float shadowFuzzyWidth,
    
    out float4 result        : COLOR)
{
    // point on shadowmap
#if LINEAR_RANGE
    shadowUV.xy = shadowUV.xy / shadowUV.w;
#else
    shadowUV = shadowUV / shadowUV.w;
#endif
    float centerdepth = tex2D(shadowMap, shadowUV.xy).x;
    
    // gradient calculation
      float pixeloffset = inverseShadowmapSize;
    float4 depths = float4(
        tex2D(shadowMap, shadowUV.xy + float2(-pixeloffset, 0)).x,
        tex2D(shadowMap, shadowUV.xy + float2(+pixeloffset, 0)).x,
        tex2D(shadowMap, shadowUV.xy + float2(0, -pixeloffset)).x,
        tex2D(shadowMap, shadowUV.xy + float2(0, +pixeloffset)).x);

    float2 differences = abs( depths.yw - depths.xz );
    float gradient = min(gradientClamp, max(differences.x, differences.y));
    float gradientFactor = gradient * gradientScaleBias;

    // visibility function
    float depthAdjust = gradientFactor + (fixedDepthBias * centerdepth);
    float finalCenterDepth = centerdepth + depthAdjust;

    // shadowUV.z contains lightspace position of current object

#if FUZZY_TEST
    // fuzzy test - introduces some ghosting in result and doesn't appear to be needed?
    //float visibility = saturate(1 + delta_z / (gradient * shadowFuzzyWidth));
    float visibility = saturate(1 + (finalCenterDepth - shadowUV.z) * shadowFuzzyWidth * shadowUV.w);

    result = vertexColour * visibility;
#else
    // hard test
#if PCF
    // use depths from prev, calculate diff
    depths += depthAdjust.xxxx;
    float final = (finalCenterDepth > shadowUV.z) ? 1.0f : 0.0f;
    final += (depths.x > shadowUV.z) ? 1.0f : 0.0f;
    final += (depths.y > shadowUV.z) ? 1.0f : 0.0f;
    final += (depths.z > shadowUV.z) ? 1.0f : 0.0f;
    final += (depths.w > shadowUV.z) ? 1.0f : 0.0f;
    
    final *= 0.2f;

    result = float4(vertexColour.xyz * final, 1);
    
#else
    result = (finalCenterDepth > shadowUV.z) ? vertexColour : float4(0,0,0,1);
#endif

#endif
}

/*
  Basic ambient lighting vertex program
*/
void ambientOneTexture_vp(float4 position : POSITION,
                          float2 uv          : TEXCOORD0,
                          
                          out float4 oPosition : POSITION,
                          out float2 oUv       : TEXCOORD0,
                          out float4 colour    : COLOR,

                          uniform float4x4 worldViewProj,
                          uniform float4 ambient)
{
    oPosition = mul(worldViewProj, position);
    oUv = uv;
    colour = ambient;
}


Secondly create a file named "DepthShadowmap.program" and paste the following into it:

DepthShadowmap.program

Copy to clipboard
vertex_program Ogre/DepthShadowmap/CasterVP cg
{
    source DepthShadowmap.cg
    entry_point casterVP
    profiles arbvp1 vs_2_0

    compile_arguments -DLINEAR_RANGE=0

    default_params
    {
        param_named_auto worldViewProj worldviewproj_matrix
        param_named_auto texelOffsets texel_offsets
        //param_named_auto depthRange scene_depth_range
    }
}

fragment_program Ogre/DepthShadowmap/CasterFP cg
{
    source DepthShadowmap.cg
    entry_point casterFP
    profiles arbfp1 ps_2_0 fp20

    compile_arguments -DLINEAR_RANGE=0

    default_params
    {
    }
}

vertex_program Ogre/DepthShadowmap/ReceiverVP cg
{
    source DepthShadowmap.cg
    entry_point receiverVP
    profiles arbvp1 vs_2_0

    compile_arguments -DLINEAR_RANGE=0

    default_params
    {
        param_named_auto world world_matrix
        param_named_auto worldIT inverse_transpose_world_matrix
        param_named_auto worldViewProj worldviewproj_matrix
        param_named_auto texViewProj texture_viewproj_matrix
        param_named_auto lightPosition light_position 0
        param_named_auto lightColour light_diffuse_colour 0
        //param_named_auto shadowDepthRange shadow_scene_depth_range 0
    }
}

fragment_program Ogre/DepthShadowmap/ReceiverFP cg
{
    source DepthShadowmap.cg
    entry_point receiverFP
    profiles arbfp1 ps_2_0 fp20

    compile_arguments -DLINEAR_RANGE=0 -DFUZZY_TEST=0 -DPCF=0

    default_params
    {
        param_named inverseShadowmapSize float 0.0009765625
        param_named fixedDepthBias float 0.01
        param_named gradientClamp float 0.0098
        param_named gradientScaleBias float 0
        //param_named shadowFuzzyWidth float 1
    }
}

// A really basic ambient pass program, support for one texture coodinate set
vertex_program Ogre/BasicVertexPrograms/AmbientOneTexture cg
{
    source DepthShadowmap.cg
    entry_point ambientOneTexture_vp
    profiles arbvp1 vs_1_1

    default_params
    {
        param_named_auto worldViewProj worldviewproj_matrix
        param_named_auto ambient ambient_light_colour
    }
}


And place these files in your application directory somewhere where ogre can find them (i.e. defined in the "resource.cfg" file). Or better yet create a new directory called "shaders" or something similar and add that to your "resource.cfg" file.

Defining the materials

Now that the shaders are defined we will need to create some materials that use them. The first material we create is used as the shadow caster, you won't need to modify this. Secondly we are going to create a template material that will be used as the base for all the materials we want shadows to be cast on. The material I have defined is pretty much the simplest you can get (even know it looks quite complex), it basically makes use of the shaders provided above to receive shadows properly and allows you to apply your own texture to it. If you want more complicated materials with multiple textures you're own your own 😊.

Again create this file with the following contents and place it somewhere your application can find it:

DepthShadowMap.material

Copy to clipboard
// Generic Shadow caster material (floating point shadowmap)
material Ogre/DepthShadowmap/Caster/Float
{
    technique
    {
        pass 
        {
            vertex_program_ref Ogre/DepthShadowmap/CasterVP
            {
            }
            fragment_program_ref Ogre/DepthShadowmap/CasterFP
            {
            }
        }
    }
}

// Basic materials which support shadows as a seperate scheme
material Ogre/DepthShadowmap/BasicTemplateMaterial
{
    // This technique supports dynamic shadows
    technique
    {
        // Base ambient pass
        pass Ambient
        {
            // base colours, not needed for rendering, but as information
            // to lighting pass categorisation routine
            ambient 1 1 1
            diffuse 0 0 0 
            specular 0 0 0 0 
            // Really basic vertex program
            vertex_program_ref Ogre/BasicVertexPrograms/AmbientOneTexture
            {
            }
        }
        // Now do the lighting pass
        // NB we don't do decal texture here because this is repeated per light
        pass Lighting
        {
            // base colours, not needed for rendering, but as information
            // to lighting pass categorisation routine
            ambient 0 0 0 
            
            // do this for each light
            iteration once_per_light

            scene_blend add

            // Vertex program reference
            vertex_program_ref Ogre/DepthShadowmap/ReceiverVP
            {
            }

            // Fragment program
            fragment_program_ref Ogre/DepthShadowmap/ReceiverFP
            {
            }

            texture_unit
            {
                content_type shadow
                tex_address_mode clamp
                filtering none
            }
        }
        
        // Decal pass
        pass Decal
        {
            // base colours, not needed for rendering, but as information
            // to lighting pass categorisation routine
            lighting off
            // Really basic vertex program
            vertex_program_ref Ogre/BasicVertexPrograms/AmbientOneTexture
            {
                param_named ambient float4 1 1 1 1
            }
            scene_blend modulate

            texture_unit
            {
                texture_alias MainTexture
                tex_address_mode clamp
            }
        }
    }
}


Now you can create your own materials using the above material as a template to make things easier to manage:

MyMaterials.material

Copy to clipboard
material MyMaterial : Ogre/DepthShadowmap/BasicTemplateMaterial
{
    set_texture_alias MainTexture MyTexture.jpg
}

Source code modification

Now that your materials and shaders are set up, there are a few modification you will need to do to the source code.

Copy to clipboard
// Allow self shadowing (note: this only works in conjunction with the shaders defined above)
 mSceneMgr->setShadowTextureSelfShadow(true);
 // Set the caster material which uses the shaders defined above
 mSceneMgr->setShadowTextureCasterMaterial("Ogre/DepthShadowmap/Caster/Float");
 // Set the pixel format to floating point
 mSceneMgr->setShadowTexturePixelFormat(Ogre::PF_FLOAT32_R);
 // You can switch this on or off, I suggest you try both and see which works best for you
 mSceneMgr->setShadowCasterRenderBackFaces(false);
 // Finally enable the shadows using texture additive integrated
 mSceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED);

And hopefully after you have completed these steps, everything should be working. Once that is the case you may want to play around with the settings in the DepthShadowmap.program file. Notably:

There are a number of settings in the Ogre/DepthShadowmap/ReceiverFP shader which can be tweaked:

Copy to clipboard
param_named fixedDepthBias float 0.01
param_named gradientClamp float 0.0098
param_named gradientScaleBias float 0

And you can try switching PCF on by changing the line: "-DPCF=0" to "-DPCF=1"

Alias: Depth_Shadow_Mapping

Links:
Soft Shadows

History Source