History: Depth Shadow Mapping
Source of version: 7 (current)
Copy to clipboard
{maketoc}
!!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__
{CODE(wrap="1", colors="c++")}/* 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;
}{CODE}
Secondly create a file named "DepthShadowmap.program" and paste the following into it:
__DepthShadowmap.program__
{CODE(wrap="1", colors="c++")}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
}
}{CODE}
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__
{CODE(wrap="1", colors="c++")}// 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
}
}
}
}{CODE}
Now you can create your own materials using the above material as a template to make things easier to manage:
__MyMaterials.material__
{CODE(wrap="1", colors="c++")}material MyMaterial : Ogre/DepthShadowmap/BasicTemplateMaterial
{
set_texture_alias MainTexture MyTexture.jpg
}{CODE}
!!!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.
{CODE(wrap="1", colors="c++")} // 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);
{CODE}
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:
{CODE(wrap="1", colors="c++")}
param_named fixedDepthBias float 0.01
param_named gradientClamp float 0.0098
param_named gradientScaleBias float 0
{CODE}
And you can try switching PCF on by changing the line: "{MONO()}-DPCF=0{MONO}" to "{MONO()}-DPCF=1{MONO}"
---
Alias: (alias(Depth_Shadow_Mapping))
Links:
[http://www.gamedev.net/page/resources/_/technical/graphics-programming-and-theory/soft-edged-shadows-r2193|Soft Shadows]