एफबीओ के साथ ओपनजीएल छाया मैपिंग - एकाधिक पीछे ड्रॉ

Question

मैं अपने गेम प्रोजेक्ट में छाया मैपिंग को लागू करने की कोशिश कर रहा हूं। मैं दो पास प्रतिपादन के साथ बनावट तकनीक में प्रस्तुत करने का उपयोग कर रहा हूँ। मैंने पहले एक एफबीओ बनाया है और केवल गहराई घटक के लिए एक बनावट बांध दी है। पहले पास में, मैं इस एफबीओ को सक्षम करता हूं, बनावट को अक्षम करता हूं और हल्के पीओवी से अपना दृश्य प्रस्तुत करता हूं। दूसरे पास में, मैं शेडर को गहराई बनावट पास करता हूं और सामान्य रूप से दृश्य प्रस्तुत करता हूं। मैं शेडर में छाया से संबंधित गणना करता हूं।

लेकिन, मेरा कोड सही तरीके से काम नहीं कर रहा है। मैं कोई छाया नहीं देख पा रहा हूँ। साथ ही, जब मैं दोनों पास प्रस्तुत करता हूं, तो मुझे लगता है कि मेरा कैमरा एक निश्चित कोण से ऊपर देख रहा है, तो मैं पूरी दुनिया की एक से अधिक ड्राइंग देखता हूं: 45. अगर मैं उस कोण से नीचे देखता हूं, तो प्रतिपादन ठीक दिखता है। इस समस्या का स्रोत क्या हो सकता है? । अगर मैं पहला पास अक्षम करता हूं, तो दुनिया गहरा लगती है लेकिन पिछला दृश्य चला गया है। मैंने नीचे अपने कोड भी संलग्न किए हैं।

मैं भी एक और भ्रम की स्थिति है। मैंने पहले छायाडोप पास के लिए बनावट को अक्षम कर दिया है। लेकिन मैं वीबीओ को अपने वर्टेक्स निर्देशांक के साथ बनावट निर्देशांक भेजता हूं। क्या इससे कोई समस्या आएगी?

FBO प्रारंभ

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; 

छाया मानचित्र पास:

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); 

प्रस्तुत पास:

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(); 

शीर्ष 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); 
} 

टुकड़ा 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); 


} 

Answer 1

एक नज़र में ऐसा लगता है कि आपके द्वारा उपयोग नहीं glClear तो आकाश जो कुछ भी अंतिम फ्रेम में किया गया है, या कम से कम अपने काम नहीं कर लग रहा है। glClearColor का अल्फा मान क्या है?