#shadow mapping

(Source: Wallace Pires @h_wallacepires)

This is literally how videogame shadows have worked for decades now and I often apply some of it when drawing stuff myself.

My shading process was also affected when I discovered how normal maps work.

It's a very interesting feedback cycle.

Shimmering effect in shadow mapping is the ‘shaking edges’ of the shadows with the movement of camera.

(Shimmering effect is obvious when rendering shadow map with bilinear filter)

This artifact is caused by the arbitrary movement of light view casting discrete shadow depth information on shadow maps. To fix this issue, an offset will be applied on light view, making it aligned to the shadow map pixels:

RVec3 viewForward = (shadowTarget - shadowEyePos).GetNormalizedVec3(); RVec3 viewRight = (RVec3(0, 1, 0).Cross(viewForward)).GetNormalizedVec3(); RVec3 viewUp = (viewForward.Cross(viewRight)).GetNormalizedVec3();

// Calculate texel offset in world space

float shadowMapSize = 1024.0f;

float texel_unit = s0.radius * 2.0f / shadowMapSize;

float dx = shadowEyePos.Dot(viewRight); float dy = shadowEyePos.Dot(viewUp); float offset_x = dx - floorf(dx / texel_unit) * texel_unit; float offset_y = dy - floorf(dy / texel_unit) * texel_unit;

shadowTarget -= viewRight * offset_x + viewUp * offset_y;

shadowEyePos -= viewRight * offset_x + viewUp * offset_y;

Comparing to light view frustum based splitting, A better way to split cascaded shadow levels is to split base on distance to camera. With this approach, the splitting planes are more nature to the users.

(Cascaded levels splitting by view distance)

With some psudo code, the idea behind splitting can be explain as:

if (PixelDepth < Level_0_Distance)

    Apply Shadow 0

else if (PixelDepth < Level_1_Distance)

    Apply Shadow 1

else if (PixelDepth < Level_2_Distance)

    Apply Shadow 2

else

    No Shadow

On issue with my project is that I have frustum split in world space and I only have pixel depth in projection space. The pixel depth cannot be used for the comparison directly since depth buffer stores exponent depth values. This can be solved by multiplying splitting point positions with projection matrix in cpu and pass them to shaders.

Here is an image of final rendering result:

Cascaded shadow map technique is the idea that rendering objects with different quality of shadow based on their distance to camera. The closer and object is to camera, the higher detailed shadow is used.

A common way to split shadow map into different detailed ones is based on distance from camera point. In my case, I’m dividing the camera’s frustum into three levels.

(Visualize frustum dividing)

Then, a bounding sphere will be calculated for each sub-frustum, marking shadow area for each level.

(Large spheres represent render area in different levels)

The sphere represents the smallest volume needed to be rendered to receive shadow in this shadow level. The light orthogonal projection will be set up encapsulating the sphere. Anything lying outside the projection volume can be ignored since they won’t be seen casing shadow in this level. A frustum culling can be done at this step to increase program performance.

For the final rendering, I find the smallest shadow frustum that a pixel is completely inside during pixel shading and sample shadow from corresponding shadow depth map. This gives me a similar result as the Cascaded Shadow Maps sample in DirectX SDK.

(Colors represent different level of cascaded shadow map)

(Cascaded shadow maps, notice the split line of two levels in the upper middle of image)

Comparing to my previous simple shadow map, a cascaded shadow map can provide me with great shadow details at close distance without sacrificing a large render area.

References:

I have implemented a basic shadow mapping in my project for a while. Since I picked up a fixed position for the light view, the light volume covers the entire scene and render everything onto a 1024x1024 depth buffer.

(Scene with shadow map)

(Light view depth buffer)

As you can see the shadow has a low resolution and it’s moved away for its casting object. I started fixing this issue by applying a slope offset.

A slope offset is an offset based on surface normal direction and light direction. The less angle between two directions, the less offset will be applied.

(Shadow depth with/without slope offset)

Slope offset can be calculated as:

SlopeOffset = SlopeOffsetFactor * saturate(1 - dot(N, L))

With a slope offset, constant offset can be reduced so shadow map is closer to the object without causing artifacts.

Still, that is not an acceptable to fix the ‘detaching shadow’ issue. Realized that this may not be fixed with a simple change to offset, I decided my next step would be implementing cascaded shadow map.

Reference: