Hello,
for the past week or so I've been trying to get shadow mapping to work, without much success. I'll get right to it and post the relevant bits of my code. It's a huge mess but it doesn't work yet.
#define CGLE() \
{
int error_codez2 = glGetError(); \
if (error_codez2 > 0) \ { \
ERROR_OPENGL("%s (Error code: %i) at line %i in file %s.", gluErrorString(error_codez2), error_codez2, __LINE__, __FILE__); \
} \
}
void Engine::Init()
{
glGenBuffersARB = (PFNGLGENBUFFERSARBPROC) wglGetProcAddress("glGenBuffersARB");
glBindBufferARB = (PFNGLBINDBUFFERARBPROC) wglGetProcAddress("glBindBufferARB");
glBufferDataARB = (PFNGLBUFFERDATAARBPROC) wglGetProcAddress("glBufferDataARB");
glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC) wglGetProcAddress("glBufferSubDataARB");
glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) wglGetProcAddress("glDeleteBuffersARB");
// shadows
glGenTextures(1, &s_ShadowTexture); CGLE();
glBindTexture(GL_TEXTURE_2D, s_ShadowTexture); CGLE();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); CGLE();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); CGLE();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); CGLE();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); CGLE();
// enable shadow comparison
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB); CGLE();
// if r <= texture
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL); CGLE();
// return an intensity
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY); CGLE();
const GLdouble x[] = {1.0, 0.0, 0.0, 0.0};
const GLdouble y[] = {0.0, 1.0, 0.0, 0.0};
const GLdouble z[] = {0.0, 0.0, 1.0, 0.0};
const GLdouble w[] = {0.0, 0.0, 0.0, 1.0};
glEnable(GL_TEXTURE_GEN_S); CGLE();
glEnable(GL_TEXTURE_GEN_T); CGLE();
glEnable(GL_TEXTURE_GEN_R); CGLE();
glEnable(GL_TEXTURE_GEN_Q); CGLE();
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); CGLE();
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); CGLE();
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); CGLE();
glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); CGLE();
glTexGendv(GL_S, GL_EYE_PLANE, x); CGLE();
glTexGendv(GL_T, GL_EYE_PLANE, y); CGLE();
glTexGendv(GL_R, GL_EYE_PLANE, z); CGLE();
glTexGendv(GL_Q, GL_EYE_PLANE, w); CGLE();
glTexImage2D (
GL_TEXTURE_2D, // target
0, // level
GL_DEPTH_COMPONENT, // internal format
g_ShadowWidth, // width
g_ShadowHeight, // height
0, // border
GL_DEPTH_COMPONENT, // format
GL_UNSIGNED_BYTE, // type
NULL // pixels
); CGLE();
glBindTexture(GL_TEXTURE_2D, 0); CGLE();
}
void Engine::GenerateShadows()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); CGLE();
float pos[4] = { s_Lights[0]->GetPosition().x, s_Lights[0]->GetPosition().y, s_Lights[0]->GetPosition().z, 0 };
glMatrixMode(GL_PROJECTION); CGLE();
glLoadIdentity(); CGLE();
gluPerspective(g_SpotAngle, 1.f, g_ShadowNear, g_ShadowFar); CGLE();
glGetFloatv(GL_MODELVIEW_MATRIX, g_LightProjectionMatrix); CGLE();
glMatrixMode(GL_MODELVIEW); CGLE();
glLoadIdentity(); CGLE();
gluLookAt (
pos[0], pos[1], pos[2],
0, 0, 0,
0, 1, 0
); CGLE();
glGetFloatv(GL_MODELVIEW_MATRIX, g_LightModelMatrix); CGLE();
float cam[16];
glPushMatrix(); CGLE();
glMatrixMode(GL_MODELVIEW); CGLE();
glLoadIdentity(); CGLE();
Project(); CGLE();
glGetFloatv(GL_MODELVIEW_MATRIX, cam); CGLE();
glPopMatrix(); CGLE();
g_InverseCamera[0] = cam[0];
g_InverseCamera[1] = cam[4];
g_InverseCamera[2] = cam[8];
g_InverseCamera[3] = 0.0f;
g_InverseCamera[4] = cam[1];
g_InverseCamera[5] = cam[5];
g_InverseCamera[6] = cam[9];
g_InverseCamera[7] = 0.0f;
g_InverseCamera[8] = cam[2];
g_InverseCamera[9] = cam[6];
g_InverseCamera[10] = cam[10];
g_InverseCamera[11] = 0.0f;
g_InverseCamera[12] =
-(cam[12] * cam[0]) -
(cam[13] * cam[1]) -
(cam[14] * cam[2]);
g_InverseCamera[13] =
-(cam[12] * cam[4]) -
(cam[13] * cam[5]) -
(cam[14] * cam[6]);
g_InverseCamera[14] =
-(cam[12] * cam[8]) -
(cam[13] * cam[9]) -
(cam[14] * cam[10]);
g_InverseCamera[15] = 1.0f;
/*g_InverseCamera[0] = g_LightProjectionMatrix[0];
g_InverseCamera[1] = g_LightProjectionMatrix[4];
g_InverseCamera[2] = g_LightProjectionMatrix[8];
g_InverseCamera[4] = g_LightProjectionMatrix[1];
g_InverseCamera[5] = g_LightProjectionMatrix[5];
g_InverseCamera[6] = g_LightProjectionMatrix[9];
g_InverseCamera[8] = g_LightProjectionMatrix[2];
g_InverseCamera[9] = g_LightProjectionMatrix[6];
g_InverseCamera[10] = g_LightProjectionMatrix[10];
g_InverseCamera[3] = 0.0f;
g_InverseCamera[7] = 0.0f;
g_InverseCamera[11] = 0.0f;
g_InverseCamera[15] = 1.0f;
g_InverseCamera[12] =
-(g_LightProjectionMatrix[12] * g_LightProjectionMatrix[0]) -
(g_LightProjectionMatrix[13] * g_LightProjectionMatrix[1]) -
(g_LightProjectionMatrix[14] * g_LightProjectionMatrix[2]);
g_InverseCamera[13] =
-(g_LightProjectionMatrix[12] * g_LightProjectionMatrix[4]) -
(g_LightProjectionMatrix[13] * g_LightProjectionMatrix[5]) -
(g_LightProjectionMatrix[14] * g_LightProjectionMatrix[6]);
g_InverseCamera[14] =
-(g_LightProjectionMatrix[12] * g_LightProjectionMatrix[8]) -
(g_LightProjectionMatrix[13] * g_LightProjectionMatrix[9]) -
(g_LightProjectionMatrix[14] * g_LightProjectionMatrix[10]);*/
glActiveTextureARB(GL_TEXTURE7); CGLE();
glMatrixMode(GL_TEXTURE); CGLE();
glLoadIdentity(); CGLE();
glLoadMatrixf(g_ShadowBias); CGLE();
glMultMatrixf(g_LightProjectionMatrix); CGLE();
glMultMatrixf(g_LightModelMatrix); CGLE();
glMultMatrixf(g_InverseCamera); CGLE();
glMatrixMode(GL_MODELVIEW);
glViewport (
0, 0,
g_ShadowWidth, g_ShadowHeight
); CGLE();
if (!check_shadow)
{
glEnable(GL_CULL_FACE); CGLE();
glCullFace(GL_FRONT); CGLE();
glDisable(GL_LIGHTING); CGLE();
glShadeModel(GL_FLAT); CGLE();
glDisable(GL_TEXTURE_2D); CGLE();
glEnable(GL_POLYGON_OFFSET_FILL); CGLE();
glColorMask(0, 0, 0, 0); CGLE();
}
// first pass
s_Game->Render(check_shadow);
glEnable(GL_TEXTURE_2D); CGLE();
glBindTexture(GL_TEXTURE_2D, s_ShadowTexture); CGLE();
glCopyTexSubImage2D (
GL_TEXTURE_2D, // target
0, // level
0, // x offset
0, // y offset
0, // x
0, // y
g_ShadowWidth, // width
g_ShadowHeight // height
); CGLE();
if (!check_shadow)
{
glColorMask(1, 1, 1, 1); CGLE();
glDisable(GL_POLYGON_OFFSET_FILL); CGLE();
glShadeModel(GL_SMOOTH); CGLE();
glEnable(GL_LIGHTING); CGLE();
glCullFace(GL_BACK); CGLE();
glDisable(GL_CULL_FACE); CGLE();
glEnable(GL_DEPTH_TEST); CGLE();
}
glDisable(GL_TEXTURE_2D); CGLE();
glMatrixMode(GL_TEXTURE); CGLE();
glLoadIdentity(); CGLE();
if (!check_shadow)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); CGLE();
}
}
void Engine::PreRender()
{
// clear the screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
s_Game->PreRender();
}
void Engine::Render()
{
if (check_shadow)
{
GenerateShadows();
glutSwapBuffers();
}
else
{
GenerateShadows();
glViewport (
0, 0,
Window::GetWidth(), Window::GetHeight()
); CGLE();
glMatrixMode(GL_PROJECTION); CGLE();
glLoadIdentity(); CGLE();
gluPerspective (
s_FOV,
(float)Window::GetWidth() / (float)Window::GetHeight(),
s_ZNear, s_ZFar
); CGLE();
glGetFloatv(GL_MODELVIEW_MATRIX, g_ProjectionMatrix); CGLE();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); CGLE();
Project();
glGetFloatv(GL_MODELVIEW_MATRIX, g_ModelMatrix); CGLE();
glActiveTextureARB(GL_TEXTURE6); CGLE();
glMatrixMode(GL_TEXTURE); CGLE();
glLoadIdentity(); CGLE();
glLoadMatrixf(g_ModelMatrix); CGLE();
glMultMatrixf(g_ProjectionMatrix); CGLE();
//glRotatef(30.f, 0, 1, 0);
glMatrixMode(GL_MODELVIEW);
SwitchPerspective(Window::GetWidth(), Window::GetHeight());
glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); CGLE();
Project();
PreRender();
glEnable(GL_LIGHTING); CGLE();
// lights
for (std::vector<Light*>::iterator i = s_Lights.begin(); i != s_Lights.end(); ++i)
{
float pos[4] = { (*i)->GetPosition().x, (*i)->GetPosition().y, (*i)->GetPosition().z, 0 };
int options = (*i)->GetOptions();
glLightfv(GL_LIGHT0, GL_POSITION, pos); CGLE();
if (options & LIGHT_AMBIENT) { glLightfv(GL_LIGHT0, GL_AMBIENT, (*i)->GetAmbient().GetOpenGLColor()); CGLE(); }
if (options & LIGHT_DIFFUSE) { glLightfv(GL_LIGHT0, GL_DIFFUSE, (*i)->GetDiffuse().GetOpenGLColor()); CGLE(); }
if (options & LIGHT_SPECULAR) { glLightfv(GL_LIGHT0, GL_SPECULAR, (*i)->GetSpecular().GetOpenGLColor()); CGLE(); }
}
s_Game->Render();
PostRender();
}
}
void Engine::PostRender()
{
s_Game->PostRender();
// set up the camera
glLoadIdentity(); CGLE();
Project();
// draw everything and swap the display buffer
glutSwapBuffers(); CGLE();
}
void Engine::Project()
{
s_Game->m_CurrentCam->Project();
}
So this code takes the matrix from the perspective of the light and multiplies it with the inverse of the eye camera. That way we get some nice values to use for the following shader:
Lighting.vert
varying vec3 normal;
varying vec3 to_light;
varying vec3 eye;
varying vec3 pos;
varying vec4 shadow_coord;
attribute vec3 vTangent;
void main()
{
// triangle
normal = normalize(gl_NormalMatrix * gl_Normal);
vec3 tangent = normalize(gl_NormalMatrix * vec3(0, 1, 0));
vec3 binormal = cross(normal, tangent);
pos = vec3(gl_ModelViewMatrix * gl_Vertex);
vec3 light_pos = vec3(gl_LightSource[0].position) - pos;
to_light.x = dot(light_pos, tangent);
to_light.y = dot(light_pos, binormal);
to_light.z = dot(light_pos, normal);
vec3 temp = -pos;
eye.x = dot(temp, tangent);
eye.y = dot(temp, binormal);
eye.z = dot(temp, normal);
mat4 matCam = gl_TextureMatrix[6];
mat4 matModel = gl_TextureMatrix[5];
mat4 matShadow = gl_TextureMatrix[7];
// texturing
gl_TexCoord[0] = gl_MultiTexCoord0;
// camera
gl_TexCoord[1] = gl_ModelViewMatrix * gl_Vertex;
// shadow
shadow_coord = matShadow * gl_ModelViewMatrix * gl_Vertex;
gl_Position = gl_ModelViewProjectionMatrix * matModel * gl_Vertex;
}
Lighting.frag
varying vec3 normal;
varying vec3 to_light;
varying vec3 eye;
varying vec3 pos;
varying vec4 shadow_coord;
uniform sampler2D tex_diffuse;
uniform sampler2D tex_specular;
uniform sampler2D tex_bump;
uniform sampler2D tex_alphakey;
uniform sampler2DShadow tex_shadows;
varying vec3 N, L, E, R;
varying float lambert;
varying vec2 uv;
varying vec4 final;
vec4 TexturingAlpha()
{
vec4 result;
vec4 texel_color = texture2D(tex_diffuse, uv);
vec4 texel_alpha = texture2D(tex_alphakey, uv);
result = texel_color * final;
if (texel_alpha.a != 0.0)
{
float mask = (texel_alpha.r + texel_alpha.g + texel_alpha.b) / 3.0;
result.a = mask;
}
return result;
}
void main()
{
uv = gl_TexCoord[0].st;
N = normal;
L = normalize(gl_LightSource[0].position.xyz);
E = normalize(-pos);
float dist = length(normalize(gl_LightSource[0].position.xyz - pos));
float atten = 1.0 / (
gl_LightSource[0].constantAttenuation +
gl_LightSource[0].linearAttenuation * dist +
gl_LightSource[0].quadraticAttenuation * dist * dist
);
// ambient term
vec4 ambient = (gl_LightSource[0].ambient * gl_FrontMaterial.ambient);
// diffuse term
vec4 diffuse = vec4(0.0, 0.0, 0.0, 1.0);
// specular term
vec4 specular = vec4(0.0, 0.0, 0.0, 1.0);
final = ambient + (atten * gl_FrontMaterial.ambient);
lambert = dot(N, L);
if (lambert > 0.0)
{
final += gl_LightSource[0].diffuse * gl_FrontMaterial.diffuse * lambert * atten;
float shiny = normalize(-reflect(L, N));
float shiny2 = dot(shiny, E);
if (shiny2 > 0.0)
{
float amount = pow(shiny2, gl_FrontMaterial.shininess);
final += gl_LightSource[0].specular * gl_FrontMaterial.specular * amount * atten;
}
}
vec4 shadow_color = vec4(0.0, 0.0, 0.0, 1.0);
float shadowness = shadow2DProj(tex_shadows, shadow_coord).r;
shadowness = clamp(shadowness, 0.0, 1.0);
vec3 coord_pos = shadow_coord.xyz / shadow_coord.w;
if (coord_pos.x >= 0.0 && coord_pos.y >= 0.0 && coord_pos.x <= 10.0 && coord_pos.y <= 10.0)
{
shadow_color.rgb = TexturingAlpha() * shadowness * final.rgb;
gl_FragColor = shadow_color;
}
else
{
gl_FragColor = final;
}
}
However, this code does not do what I want it to do. It does something like this:
http://imgur.com/CHKHx.png (I apologize to future Googlers if the link is no longer available. Imagine a complex scene shaded in red, except for a square in the middle that is textured)
Instead of checking if something is in the shade, it renders a nice light blob in front of everything.
How can I fix my shadow mapping?
Thanks in advance.
[Edited by - knight666 on April 4, 2010 3:37:44 AM]
