Because the engine I'm building only needs to support wide outdoor environments (it's an RTS) the most important light type I need to cater for is the directional light from the sun. So no omni-directional or spotlights need to be done for now.
Let's outline the basics of the algorithm.
Part 1. Generate the shadow maps.
Bind framebuffer with render to texture for the depth buffer. Switch GPU to double speed z only rendering.
Bind framebuffer with render to texture for the depth buffer. Switch GPU to double speed z only rendering.
for each cascade
1). Calculate the truncated view frustum of the main camera in world space, use this to determine the position, bounds, and projection matrix of the light.
2). Render all relevant geometry of the scene into the shadow map.
Part 2. During the deferred lighting stage directional light shading pass.
for each pixel
1). Read corresponding depth, linearize and calculate the world space position of each pixel.
2). Project world space position into the current cascade's light space, and run the depth comparison and filtering against the depth stored in the shadow map.
That's literally it. The beautiful thing about shadow mapping, as opposed to something like shadow volumes is the conceptual simplicity of the technique. But it comes at the expense of grievances like having to manage shadow map offsets and deal with issues like duelling frusta etc. Another benefit of this way of doing it (during the deferred lighting stage) is that you get free self shadowing that's completely generic over the entire world. If there's a point in the world, it will get shadowed correctly (provided your shadow maps are generated correctly as well).
Now let's get into the details.
Calculate the view volume of the light for each cascade slice.
Calculate the view volume of the light for each cascade slice.
The most important thing you need to do here is ensure that all points that are enclosed in the frustum slice of the main camera will be included in the lights viewing volume. Not only that, but the lights viewing volume should extend from the camera frustum to the light's position itself so that any points that are outside the camera's viewing volume but potentially casting shadows onto the points that are accounted for.
This simple diagram should explain.
This simple diagram should explain.
How I defined the light's viewing volume was to define the light's camera space, and then transform all points of the cascade slice frustum into that camera space. Which, since we're dealing with an orthographic projection, makes it easy to find the maximum and minimum extents along each axis (with the exception of the near z plane, which is always set to 1.0f. From that, you can create your light basis clipping planes and then, for each element in the world, if it's inside both pairs of clipping planes, then it get's rendered into the shadow map.
A note here on level of detail:
You want to make sure that the level of detail set for the mesh of terrain node you're rendering is based off of the main camera (not the light) to avoid artifacts. But depending on how you do things these may be tolerable and will certainly be faster.
Reconstructing the world space position.
A note here on level of detail:
You want to make sure that the level of detail set for the mesh of terrain node you're rendering is based off of the main camera (not the light) to avoid artifacts. But depending on how you do things these may be tolerable and will certainly be faster.
If you read the previous article this would be an example of why you need to be able to correctly read the linear depth from the depth buffer. If you don't, your reconstructed world space positions will be swimming around and you'll notice horribly weird artifacts. A good debug view is to visualize the generated world space pixels normalized to the bounds of the current map (for me it was to calculate the world space position and divide by roughly 4000 (map size is 4km squared).
You should get something like this:
And you should note that as the camera moves around the scene the colors in the scene should not change... at all. That's the first sign you're doing something wrong.
The way I reconstructed the world space position was to calculate the vectors from the camera frustum near corners to the far corners. Translate those vectors into world space and then pass them as attributes to be interpolated over the screen during the full screen pass. From there you get the interpolated view vector and multiply it by the linear depth read from the depth buffer and you've got your world space position.
Doing the final lighting pass.
After you've got your shadow maps and you have your world space positions for each pixel, inside the final shader all you need to do is transform the pixel from world space into the light space and run your comparison. Here's the really basic fragment shader I used, there's a bunch of optimizations (and modernizations, running off of the old 1.1 GLSL spec) to do and the filtering is only the hardware PCF at the moment but it should be a good reference point to just get something on screen.
The final result.
Here's a couple of screenshots:
Just a thanks here to everyone from Turbosquid and the internet for the free models! :)
You should get something like this:
And you should note that as the camera moves around the scene the colors in the scene should not change... at all. That's the first sign you're doing something wrong.
The way I reconstructed the world space position was to calculate the vectors from the camera frustum near corners to the far corners. Translate those vectors into world space and then pass them as attributes to be interpolated over the screen during the full screen pass. From there you get the interpolated view vector and multiply it by the linear depth read from the depth buffer and you've got your world space position.
Doing the final lighting pass.
After you've got your shadow maps and you have your world space positions for each pixel, inside the final shader all you need to do is transform the pixel from world space into the light space and run your comparison. Here's the really basic fragment shader I used, there's a bunch of optimizations (and modernizations, running off of the old 1.1 GLSL spec) to do and the filtering is only the hardware PCF at the moment but it should be a good reference point to just get something on screen.
#version 110
//#define DEBUG
/// Texture units.
uniform sampler2D albedoBuffer;
uniform sampler2D normalBuffer;
uniform sampler2D depthBuffer;
uniform sampler2DShadow shadowCascade0;
uniform sampler2DShadow shadowCascade1;
uniform sampler2DShadow shadowCascade2;
uniform sampler2DShadow shadowCascade3;
varying vec2 vTexCoord0;
/// Contains the components A, B, n, f in that order.
/// Used for depth linearization.
uniform vec4 ABnf;
/// World space reconstruction.
varying vec3 vFrustumVector;
uniform vec3 cameraPosition;
/// Lighting values.
uniform vec3 viewspaceDirection;
uniform vec3 lightColor;
uniform mat4 cascade0WVP;
uniform mat4 cascade1WVP;
uniform mat4 cascade2WVP;
uniform mat4 cascade3WVP;
void ProcessCascade0(in vec4 cascadeClipSpacePosition)
{
#ifdef DEBUG
gl_FragColor.rgb *= vec3(2.0, 0.5, 0.5);
#endif
// Get depth in light space.
cascadeClipSpacePosition.xyz += 1.0;
cascadeClipSpacePosition.xyz *= 0.5;
cascadeClipSpacePosition.z -= 0.0005;
cascadeClipSpacePosition.w = 1.0;
float multiplier = shadow2DProj(shadowCascade0, cascadeClipSpacePosition).r;
gl_FragColor.rgb *= multiplier;
}
void ProcessCascade1(in vec4 cascadeClipSpacePosition)
{
#ifdef DEBUG
gl_FragColor.rgb *= vec3(0.5, 2.0, 0.5);
#endif
// Get depth in light space.
cascadeClipSpacePosition.xyz += 1.0;
cascadeClipSpacePosition.xyz *= 0.5;
cascadeClipSpacePosition.z -= 0.001;
cascadeClipSpacePosition.w = 1.0;
float multiplier = shadow2DProj(shadowCascade1, cascadeClipSpacePosition).r;
gl_FragColor.rgb *= multiplier;
}
void ProcessCascade2(in vec4 cascadeClipSpacePosition)
{
#ifdef DEBUG
gl_FragColor.rgb *= vec3(0.5, 0.5, 2.0);
#endif
// Get depth in light space.
cascadeClipSpacePosition.xyz += 1.0;
cascadeClipSpacePosition.xyz *= 0.5;
cascadeClipSpacePosition.z -= 0.002;
cascadeClipSpacePosition.w = 1.0;
float multiplier = shadow2DProj(shadowCascade2, cascadeClipSpacePosition).r;
gl_FragColor.rgb *= multiplier;
}
void ProcessCascade3(in vec4 cascadeClipSpacePosition)
{
#ifdef DEBUG
gl_FragColor.rgb *= vec3(2.0, 0.5, 0.5);
#endif
// Get depth in light space.
cascadeClipSpacePosition.xyz += 1.0;
cascadeClipSpacePosition.xyz *= 0.5;
cascadeClipSpacePosition.z -= 0.0025;
cascadeClipSpacePosition.w = 1.0;
float multiplier = shadow2DProj(shadowCascade3, cascadeClipSpacePosition).r;
gl_FragColor.rgb *= multiplier;
}
void StartCascadeSampling(in vec4 worldSpacePosition)
{
vec4 cascadeClipSpacePosition;
cascadeClipSpacePosition = cascade0WVP * worldSpacePosition;
if (abs(cascadeClipSpacePosition.x) < 1.0 &&
abs(cascadeClipSpacePosition.y) < 1.0 &&
abs(cascadeClipSpacePosition.z) < 1.0)
{
ProcessCascade0(cascadeClipSpacePosition);
return;
}
cascadeClipSpacePosition = cascade1WVP * worldSpacePosition;
if (abs(cascadeClipSpacePosition.x) < 1.0 &&
abs(cascadeClipSpacePosition.y) < 1.0 &&
abs(cascadeClipSpacePosition.z) < 1.0)
{
ProcessCascade1(cascadeClipSpacePosition);
return;
}
cascadeClipSpacePosition = cascade2WVP * worldSpacePosition;
if (abs(cascadeClipSpacePosition.x) < 1.0 &&
abs(cascadeClipSpacePosition.y) < 1.0 &&
abs(cascadeClipSpacePosition.z) < 1.0)
{
ProcessCascade2(cascadeClipSpacePosition);
return;
}
cascadeClipSpacePosition = cascade3WVP * worldSpacePosition;
if (abs(cascadeClipSpacePosition.x) < 1.0 &&
abs(cascadeClipSpacePosition.y) < 1.0 &&
abs(cascadeClipSpacePosition.z) < 1.0)
{
ProcessCascade3(cascadeClipSpacePosition);
return;
}
}
void main()
{
float A = ABnf.x;
float B = ABnf.y;
float n = ABnf.z;
float f = ABnf.w;
// Get the initial z value of the pixel.
float z = texture2D(depthBuffer, vTexCoord0).x;
z = (2.0 * z) - 1.0;
// Transform into view space.
float zView = -B / (z + A);
zView /= -f;
// Normalize zView.
vec3 intermediate = (vFrustumVector * zView);
vec4 worldSpacePosition = vec4(intermediate + cameraPosition, 1.0);
vec3 texColor = texture2D(albedoBuffer, vTexCoord0).rgb;
// Do lighting calculation.
vec3 normal = texture2D(normalBuffer, vTexCoord0).rgb * 2.0 - 1.0;
float dotProduct = dot(viewspaceDirection, normal);
gl_FragColor.rgb = (max(texColor * dotProduct, 0.0));
gl_FragColor.rgb *= lightColor;
// Now we can transform the world space position of the pixel into the shadow map spaces and
// see if they're in shadow.
StartCascadeSampling(worldSpacePosition);
gl_FragColor.rgb += texColor.rgb * 0.2;
}
The final result.
Here's a couple of screenshots:
 |
| Test scenario showing how the buildings cast shadow onto one another. |
 |
| Closer in details are still preserved with cascaded shadow maps. Self shadowing Tiger tank FTW! |
 |
| Here you can see cascades 1-3 illustrated. |
 |
| And here is cascade 0 included as well for the finer details close to the camera. |
No comments:
Post a Comment