Shadow Mapping with FBO problem

[fibonacci]

Hello,

I am trying to implement shadow mapping in our game project. I am using render to texture technique with two pass rendering. I have created a FBO first and bound a texture for depth component only. In the first pass, I enable this FBO, disable texture and render my scene from light POV. In the second pass, I pass the depth texture to the shader and render the scene normally. I perform the shadow related calculation in the shader.

But, my code is not working correctly. I am not able to see any shadow. Also, when I render both pass, I see a multiple drawing of the whole world trailing one after another if my camera is looking above a certain angle : 45. If I look below that angle, the rendering looks ok. I have attached the image link below(due to forum restriction, I am only able to put the link, no screenshot). If I disable the first pass, the world looks darker but the trailing scene is gone. I have also attached my codes below.

I have also another confusion. I have disabled texture for the first shadowmap pass. But I send the texture coordinates with my vertex coordinates to the VBO. Will that cause any problem?

I am unable to solve these problems for couple of days.Help is really appreciated.

Image:
dl.dropbox.com/u/4246542/render_trailing_draw.png


FBO Initialization:

bool ShadowMap::InitN(unsigned int WindowWidth, unsigned int WindowHeight)
{
 
	LightPosition = glm::vec3(50.0f, 40.0f, 50.0f);
	upVector = glm::vec3(0.0f, 1.0f, 0.0f);
 
	glGenTextures(1, &m_shadowMap);
	glBindTexture(GL_TEXTURE_2D, m_shadowMap);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
	glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32,
			WindowWidth, WindowHeight, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
	glBindTexture(GL_TEXTURE_2D, 0);
 
	glGenFramebuffers(1, &m_fbo);
	glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	glDrawBuffers(0, NULL);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_shadowMap, 0);
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_CULL_FACE);
 
 
    GLenum Status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
 
    if (Status != GL_FRAMEBUFFER_COMPLETE) {
        printf("FB error, status: 0x%x\n", Status);
        return false;
    }
 
    return true;
}

Shadow Map Pass

void Mpp::shadowMapPassW() {
 
	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, 0);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, 0);
 
 
	glViewport(0, 0, windowWidth, windowHeight);
 
	glBindFramebuffer(GL_FRAMEBUFFER, shadowMapFBO.m_fbo);
 
	glClear(GL_DEPTH_BUFFER_BIT);
 
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glm::mat4 lightProjection = glm::perspective(45.0f,
			1.0f * windowWidth / windowHeight, 0.125f, 1000.0f);
	glGetFloatv(GL_PROJECTION_MATRIX, shadowMapFBO.LightProjectionMatrix);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glm::mat4 lightModelView = glm::lookAt(shadowMapFBO.LightPosition,
			glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
	glGetFloatv(GL_MODELVIEW_MATRIX, shadowMapFBO.LightModelViewMatrix);
 
	glm::mat4 lmvp = lightProjection * lightModelView;
 
	glCullFace(GL_FRONT);
 
	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
	glDisable(GL_LIGHTING);
	glDisable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, 0);
 
	glUniform1i(Shader::id_uniform_layer, 0);
	world->render(lmvp);
	printGLError();
 
 
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
}

Render Pass:

void Mpp::renderPassW() {
	static glm::vec3 cCameraPosition = glm::vec3(0.0f, 5.0f, 10.0f);
	static glm::vec3 cLightPosition = glm::vec3(50.0f, 40.0f, 50.0f);
 
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	glViewport(0, 0, windowWidth, windowHeight);
 
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glm::mat4 modelView = player->getView();
 
	float viewAngle = 45.0f;
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glm::mat4 projection = glm::perspective(viewAngle,
			1.0f * windowWidth / windowHeight, 0.01f, 1000.0f);
	glm::mat4 mvp = projection * modelView;
 
 
	glEnable(GL_TEXTURE_2D);
 
	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, shadowMapFBO.m_shadowMap);
 
	glMatrixMode(GL_TEXTURE);
	glLoadIdentity();
	glTranslatef(0.5f, 0.5f, 0.5f);
	glScalef(0.5f, 0.5f, 0.5f);
	glMultMatrixf(shadowMapFBO.LightProjectionMatrix);
	glMultMatrixf(shadowMapFBO.LightModelViewMatrix);
 
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, id_texture_blocks);
 
	glUseProgram(Shader::id_program);
 
	glUniform3fv(Shader::id_uniform_lightPosition, 1,
			glm::value_ptr(cLightPosition));
	glUniform3fv(Shader::id_uniform_CameraPosition, 1,
			glm::value_ptr(*(player->getCoordinates())));
 
	//Enabling color write (previously disabled for light POV z-buffer rendering)
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
	glUniform1i(Shader::id_shader_shadow, 1);
 
	glUniformMatrix4fv(Shader::id_uniform_mvp, 1, GL_FALSE, glm::value_ptr(mvp));
 
	glEnable(GL_POLYGON_OFFSET_FILL);
	glEnable(GL_CULL_FACE);
 
	glCullFace(GL_BACK);
 
	glUniform1i(Shader::id_uniform_layer, 0);
	world->render(mvp);
	printGLError();
 
}

Vertex shader:

attribute vec4 coordinates;
uniform   mat4 mvp;
 
//Fragment shader forward variables.
varying vec4 voxel;
 
//shadow map
// Used for shadow lookup
varying vec4 ShadowCoord;
 
uniform vec3 LightPosition, CameraPosition;
 
varying vec3 LightDirection, LightDirectionReflected, CameraDirection, Normal;
 
void main(void) {
 
    //shadow map
    LightDirection = LightPosition - gl_Vertex.xyz;
	LightDirectionReflected = reflect(-LightDirection, gl_Normal);
	CameraDirection = CameraPosition - gl_Vertex.xyz;
	Normal = gl_Normal;
	gl_TexCoord[0] = gl_MultiTexCoord0;
	gl_TexCoord[1] = gl_TextureMatrix[1] * gl_Vertex;
 
    voxel = coordinates;
    //Calculates projection on xyz.
    gl_Position = mvp * vec4(coordinates.xyz, 1);
}

Fragment Shader

 
 
#extension GL_EXT_gpu_shader4 : enable
 
 
//Rendering layer.
uniform int layer;
 
 
//Colors.
uniform float colorRed;
uniform float colorGreen;
uniform float colorBlue;
uniform float colorAlpha;
 
//Fog density.
uniform float fogDensity;
 
varying vec4 voxel;
 
uniform sampler2D texture;
 
const float N_TEXTURES = 32.0;
 
//////////////////////shadow map
uniform sampler2DShadow ShadowMap;
 
varying vec4 ShadowCoord;
 
varying vec3 LightDirection, LightDirectionReflected, CameraDirection, Normal;
 
void main(void) {
 
    vec2  coord2d;
    float intensity;
 
    vec4 color = texture2D(texture, coord2d);
 
    float z = gl_FragCoord.z / gl_FragCoord.w;
    float fog = clamp(exp(-fogDensity * z * z), 0.2, 1.0);
 
    color.xyz = color.xyz * intensity;
 
	//shadow map
	float Shadow = shadow2DProj(ShadowMap, gl_TexCoord[1]).r;
 
	float NdotLD = max(dot(normalize(LightDirection), Normal), 0.0) * Shadow;
	float Spec = pow(max(dot(normalize(LightDirectionReflected), normalize(CameraDirection)), 0.0), 32.0) * Shadow;
	color.xyz = color.xyz * (0.25 + NdotLD * 0.75 + Spec);
 
    //Final color.
    vec4 fogColor = vec4(colorRed, colorGreen, colorBlue, colorAlpha);
    gl_FragColor = mix(fogColor, color, fog);
 
 
}