Shadow Mapping Artifacts

Question

I just started messing around with shadow mapping. I understand the algorithm used. The thing is I cannot for the life of me figure out where I am messing up in the HLSL code. Here it is:

//These change
float4x4    worldViewProj;
float4x4    world;
texture     tex;

//These remain constant
float4x4    lightSpace;
float4x4    lightViewProj;
float4x4    textureBias;
texture     shadowMap;



sampler TexS = sampler_state
{
    Texture = <tex>;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    MipFilter = LINEAR;
    AddressU = WRAP;
    AddressV = WRAP;
};

sampler TexShadow = sampler_state
{
    Texture = <shadowMap>;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    MipFilter = LINEAR;
};

struct A2V
{   
    float3 posL : POSITION0;
    float2 texCo    : TEXCOORD0;
};

struct OutputVS
{
    float4 posH : POSITION0;
    float2 texCo    : TEXCOORD0;
    float4 posW : TEXCOORD2;
};

//Vertex Shader Depth Pass
OutputVS DepthVS(A2V IN)
{
    OutputVS OUT = (OutputVS)0;

    //Get screen coordinates in light space for texture map
    OUT.posH = mul(float4(IN.posL, 1.f), lightViewProj);
    //Get the depth by performing a perspective divide on the projected coordinates
    OUT.posW.x = OUT.posH.z/OUT.posH.w;
    return OUT;
}


//Pixel shader depth Pass
float4  DepthPS(OutputVS IN) : COLOR
{
    //Texture only uses red channel, just store it there
    return float4(IN.posW.x, 0, 0, 1);
}


//VertexShader Draw Pass
OutputVS DrawVS(A2V IN)
{
    OutputVS OUT = (OutputVS)0;

    //Get the screen coordinates for this pixel
    OUT.posH = mul(float4(IN.posL, 1.f), worldViewProj);
    //Send texture coordinates through
    OUT.texCo = IN.texCo;
    //Pass its world coordinates through
    OUT.posW = mul(float4(IN.posL, 1.f), world);
    return OUT;
}

//PixelShader Draw Pass
float4 DrawPS(OutputVS IN) : COLOR
{   
    //Get the pixels screen position in light space
    float4 texCoord = mul(IN.posW, lightViewProj);
    //Perform perspective divide to normalize coordinates [-1,1]
    //texCoord.x = texCoord.x/texCoord.w;
    //texCoord.y = texCoord.y/texCoord.w;
    //Multiply by texture bias to bring in range 0-1
    texCoord = mul(texCoord, textureBias);
    //Get corresponding depth value
    float prevDepth = tex2D(TexShadow, texCoord.xy);
    //Check if it is in shadow
    float4 posLight = mul(IN.posW, lightViewProj);
    float currDepth = posLight.z/posLight.w;
    if (currDepth >= prevDepth)
        return float4(0.f, 0.f, 0.f, 1.f);
    else
        return tex2D(TexS, IN.texCo);
}


//Effect info
technique ShadowMap
{
    pass p0
    {
        vertexShader = compile vs_2_0 DepthVS();
        pixelShader = compile ps_2_0 DepthPS();
    }

    pass p1
    {
        vertexShader = compile vs_2_0 DrawVS();
        pixelShader = compile ps_2_0 DrawPS();
    }
}

I have verified that all my matrices are correct and the depth map is being drawn correctly. Rewrote all of the C++ that handles this code and made it neater and I am still getting the same problem. I am not currently blending the shadows, just drawing them flat black until I can get them to draw correctly. The light uses an orthogonal projection because it is a directional light. I dont have enough reputation points to embed images but here are the URLs: Depth Map - https://i.sstatic.net/rNZV1.png Program output - https://i.sstatic.net/3AYmn.png

Any help or insight would be greatly appreciated as its for a school project. Thanks

Answer 1

The value you get from the depth buffer is float value that is from 0 to 1. As you probably already know, floating points are not accurate and the more decimal places you request the less accurate it is and this is where you end up with artifacts.

There are some things you can do. The easiest way is to make the value of the far and near Z in the projection matrix closer to each other so that the depth buffer will not use so many decimal places to represent how far away the object is. I usually find that having a value of 1-200 gives me a fairly good accurate result.

Another easy thing you can do is increase the size of the texture you are drawing on as that will give you more pixels and therefore it will represent the scene more accurately.

There are also a lot of complex things that games engines can do to improve on shadow mapping artifacts but you can write a book about that and if you really do want to get into it than I would recommended you start with the blog.