Hey guys!
I'm having some serious trouble implementing shadow mapping in my OpenGL/OpenGL ES application. There are many sources and discussions out there, but they often cover different versions of the API or omit some details. The way I'm doing it is by first constructing an orthographic projection matrix based on a light source. The "frustum" is adjusted to contain a terrain mesh.
Vector3 offset = {1.0f, -1.0f, 1.0f}; // Light direction
offset.Normalize();
offset *= 30.0f;
Vector3 center = {15.0f, 0.0f, 15.0f};
Vector3 eye = center - offset;
Vector3 up = {0.0f, 1.0f, 0.0f};
Matrix4 viewMatrix = LookAt(eye, center, up);
Matrix4 projectionMatrix = Ortho(-30.0f, 30.0f, -30.0f, 30.0f, 0.0f, 60.0f); // Depth range is 60.0
Matrix4 shadowMatrix = viewMatrix * projectionMatrix;
Then I am drawing all the models that populate the world to the shadow map, and projecting it onto the terrain. It looks great for things that are positioned above ground. The problem emerges when they are not, in which case they are projected just the same. Naturally they should appear in the shadow map, so I am assuming that it is the depth comparison that fails. The shadow map is being rendered directly to a texture (no render buffer involved), with settings GL_RGBA and GL_UNSIGNED_BYTE. The attachment is done through GL_COLOR_ATTACHMENT0, and for the color value I have tried to use a linearized and normalized gl_FragCoord.z, but now I am more inclined to use the same manually projected vertex z that is used in the other render step. The shaders look roughly like this:
// Shadow vertex shader
attribute vec4 a_Position;
uniform mat4 u_ShadowMatrix;
uniform mat4 u_WorldMatrix;
varying vec4 v_ShadowCoordinate;
void main()
{
v_ShadowCoordinate = u_ShadowMatrix * u_WorldMatrix * a_Position;
gl_Position = v_ShadowCoordinate;
}
// Shadow fragment shader
varying vec4 v_ShadowCoordinate;
void main()
{
gl_FragColor = vec4(v_ShadowCoordinate.z / 60.0); // Without packing
}
// Render vertex shader
uniform mat4 u_WorldMatrix;
uniform mat4 u_ViewProjectionMatrix;
uniform mat4 u_ShadowMatrix;
attribute vec4 a_Position;
attribute vec2 a_TextureCoordinate;
varying vec2 v_TextureCoordinate;
varying vec4 v_ShadowCoordinate;
void main()
{
// I have a suspicion this might mess up the z, but it's vital for the projection
mat4 shadowBiasMatrix = mat4(
0.5f, 0.0f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 0.5f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f);
v_TextureCoordinate = a_TextureCoordinate;
v_ShadowCoordinate = shadowBiasMatrix * u_ShadowMatrix * u_WorldMatrix * a_Position;
gl_Position = u_ViewProjectionMatrix * u_WorldMatrix * a_Position;
}
// Render fragment shader
uniform sampler2D u_Texture;
uniform sampler2D u_ShadowMap;
varying vec2 v_TextureCoordinate;
varying vec4 v_ShadowCoordinate;
void main()
{
vec4 textureColor = texture2D(u_Texture, v_TextureCoordinate);
vec4 shadowMapColor = texture2D(u_ShadowMap, v_ShadowCoordinate.xy);
if ((shadowMapColor.x * 60.0) < v_ShadowCoordinate.z) // Same projection as in the shadow shader, right?
shadowMapColor = vec4(vec3(0.5), 1.0);
else
shadowMapColor = vec4(1.0); // No shadow
gl_FragColor = textureColor * shadowMapColor;
}
I have tried different ways of computing the shadow map, with more elaborate packing methods. Ultimately I am assuming that OpenGL clamps the values between 0.0 and 1.0, or rather 0 and 255 as in the case of my texture format. There has to be a more obvious problem with my implementation. I can mention that changes to the render state such as dither, depth test and face culling doesn't make a noticeable difference. Can anyone think of a possible flaw? Any tips are greatly appreciated.
- David
