当前位置:   article > 正文

南邮——计算机图形学——阴影映射_debugdepthquad

debugdepthquad

阴影映射

阴影映射(Shadow Mapping)背后的思路非常简单:我们以光的位置为视角进行渲染,我们能看到的东西都将被点亮,看不见的一定是在阴影之中了。

如果我们从光源的透视图来渲染场景,并把深度值的结果储存到纹理中会怎样?通过这种方式,我们就能对光源的透视图所见的最近的深度值进行采样。最终,深度值就会显示从光源的透视图下见到的第一个片元了。我们管储存在纹理中的所有这些深度值,叫做深度贴图(depth map)或阴影贴图。

通过储存到深度贴图中的深度值,我们就能找到最近点,用以决定片元是否在阴影中。我们使用一个来自光源的视图和投影矩阵来渲染场景就能创建一个深度贴图。这个投影和视图矩阵结合在一起成为一个TT变换,它可以将任何三维位置转变到光源的可见坐标空间。

我们渲染一个点P¯P¯处的片元,需要决定它是否在阴影中。我们先得使用TT把P¯P¯变换到光源的坐标空间里。既然点P¯P¯是从光的透视图中看到的,它的z坐标就对应于它的深度,例子中这个值是0.9。使用点P¯P¯在光源的坐标空间的坐标,我们可以索引深度贴图,来获得从光的视角中最近的可见深度,结果是点C¯C¯,最近的深度是0.4。因为索引深度贴图的结果是一个小于点P¯P¯的深度,我们可以断定P¯P¯被挡住了,它在阴影中了。

深度映射由两个步骤组成:首先,我们渲染深度贴图,然后我们像往常一样渲染场景,使用生成的深度贴图来计算片元是否在阴影之中。听起来有点复杂,但随着我们一步一步地讲解这个技术,就能理解了。

1、深度贴图

第一步我们需要生成一张深度贴图(Depth Map)。深度贴图是从光的透视图里渲染的深度纹理,用它计算阴影。因为我们需要将场景的渲染结果储存到一个纹理中,我们将再次需要帧缓冲。

首先,我们要为渲染的深度贴图创建一个帧缓冲对象:

  1. GLuint depthMapFBO;
  2. glGenFramebuffers(1, &depthMapFBO);

然后,创建一个2D纹理,提供给帧缓冲的深度缓冲使用:

  1. const GLuint SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
  2. GLuint depthMap;
  3. glGenTextures(1, &depthMap);
  4. glBindTexture(GL_TEXTURE_2D, depthMap);
  5. glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
  6. SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
  7. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  8. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  9. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  10. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

生成深度贴图不太复杂。因为我们只关心深度值,我们要把纹理格式指定为GL_DEPTH_COMPONENT。我们还要把纹理的高宽设置为1024:这是深度贴图的解析度。

把我们把生成的深度纹理作为帧缓冲的深度缓冲:

  1. glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
  2. glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap, 0);
  3. glDrawBuffer(GL_NONE);
  4. glReadBuffer(GL_NONE);
  5. glBindFramebuffer(GL_FRAMEBUFFER, 0);

我们需要的只是在从光的透视图下渲染场景的时候深度信息,所以颜色缓冲没有用。然而帧缓冲对象不是完全不包含颜色缓冲的,所以我们需要显式告诉OpenGL我们不适用任何颜色数据进行渲染。我们通过将调用glDrawBuffer和glReadBuffer把读和绘制缓冲设置为GL_NONE来做这件事。

合理配置将深度值渲染到纹理的帧缓冲后,我们就可以开始第一步了:生成深度贴图。两个步骤的完整的渲染阶段,看起来有点像这样:

  1. // 1. 首选渲染深度贴图
  2. glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
  3. glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
  4. glClear(GL_DEPTH_BUFFER_BIT);
  5. ConfigureShaderAndMatrices();
  6. RenderScene();
  7. glBindFramebuffer(GL_FRAMEBUFFER, 0);
  8. // 2. 像往常一样渲染场景,但这次使用深度贴图
  9. glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);
  10. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  11. ConfigureShaderAndMatrices();
  12. glBindTexture(GL_TEXTURE_2D, depthMap);
  13. RenderScene();

这段代码隐去了一些细节,但它表达了阴影映射的基本思路。

前面那段代码中一个不清楚的函数是ConfigureShaderAndMatrices

2、光空间的变换矩阵

它是用来在第二个步骤确保为每个物体设置了合适的投影和视图矩阵,以及相关的模型矩阵。

出于这个原因,我们将为光源使用正交投影矩阵,透视图将没有任何变形:

  1. glm::vec3 lightPos(-2.0f, 4.0f, -1.0f);
  2. GLfloat near_plane = 1.0f, far_plane = 7.5f;
  3. glm::mat4 lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, near_plane, far_plane);

为了创建一个视图矩阵来变换每个物体,把它们变换到从光源视角可见的空间中,我们将使用glm::lookAt函数;这次从光源的位置看向场景中央。

glm::mat4 lightView = glm::lookAt(glm::vec(-2.0f, 4.0f, -1.0f), glm::vec3(0.0f), glm::vec3(1.0));

二者相结合为我们提供了一个光空间的变换矩阵,它将每个世界空间坐标变换到光源处所见到的那个空间;这正是我们渲染深度贴图所需要的。

glm::mat4 lightSpaceMatrix = lightProjection * lightView;

这个lightSpaceMatrix正是前面我们称为TT的那个变换矩阵。有了lightSpaceMatrix只要给shader提供光空间的投影和视图矩阵,我们就能像往常那样渲染场景了。

3、渲染至深度贴图

当我们以光的透视图进行场景渲染的时候,我们会用一个比较简单的着色器,这个着色器除了把顶点变换到光空间以外,不会做得更多了。这个简单的着色器叫做simpleDepthShader,就是使用下面的这个着色器:

  1. #version 330 core
  2. layout (location = 0) in vec3 position;
  3. uniform mat4 lightSpaceMatrix;
  4. uniform mat4 model;
  5. void main()
  6. {
  7. gl_Position = lightSpaceMatrix * model * vec4(position, 1.0f);
  8. }

这个顶点着色器将一个单独模型的一个顶点,使用lightSpaceMatrix变换到光空间中。

由于我们没有颜色缓冲,最后的片元不需要任何处理,所以我们可以简单地使用一个空像素着色器:

  1. #version 330 core
  2. void main()
  3. {
  4. // gl_FragDepth = gl_FragCoord.z;
  5. }

这个空像素着色器什么也不干,运行完后,深度缓冲会被更新。我们可以取消那行的注释,来显式设置深度,但是这个(指注释掉那行之后)是更有效率的,因为底层无论如何都会默认去设置深度缓冲。

渲染深度缓冲现在成了:

  1. simpleDepthShader.Use();
  2. glUniformMatrix4fv(lightSpaceMatrixLocation, 1, GL_FALSE, glm::value_ptr(lightSpaceMatrix));
  3. glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
  4. glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
  5. glClear(GL_DEPTH_BUFFER_BIT);
  6. RenderScene(simpleDepthShader);
  7. glBindFramebuffer(GL_FRAMEBUFFER, 0);

这里的RenderScene函数的参数是一个着色器程序(shader program),它调用所有相关的绘制函数,并在需要的地方设置相应的模型矩阵。

4、渲染阴影

正确地生成深度贴图以后我们就可以开始生成阴影了。这段代码在像素着色器中执行,用来检验一个片元是否在阴影之中,不过我们在顶点着色器中进行光空间的变换:

  1. #version 330 core
  2. layout (location = 0) in vec3 position;
  3. layout (location = 1) in vec3 normal;
  4. layout (location = 2) in vec2 texCoords;
  5. out vec2 TexCoords;
  6. out VS_OUT {
  7. vec3 FragPos;
  8. vec3 Normal;
  9. vec2 TexCoords;
  10. vec4 FragPosLightSpace;
  11. } vs_out;
  12. uniform mat4 projection;
  13. uniform mat4 view;
  14. uniform mat4 model;
  15. uniform mat4 lightSpaceMatrix;
  16. void main()
  17. {
  18. gl_Position = projection * view * model * vec4(position, 1.0f);
  19. vs_out.FragPos = vec3(model * vec4(position, 1.0));
  20. vs_out.Normal = transpose(inverse(mat3(model))) * normal;
  21. vs_out.TexCoords = texCoords;
  22. vs_out.FragPosLightSpace = lightSpaceMatrix * vec4(vs_out.FragPos, 1.0);
  23. }

这儿的新的地方是FragPosLightSpace这个输出向量。我们用同一个lightSpaceMatrix,把世界空间顶点位置转换为光空间。顶点着色器传递一个普通的经变换的世界空间顶点位置vs_out.FragPos和一个光空间的vs_out.FragPosLightSpace给像素着色器。

像素着色器使用Blinn-Phong光照模型渲染场景。我们接着计算出一个shadow值,当fragment在阴影中时是1.0,在阴影外是0.0。然后,diffuse和specular颜色会乘以这个阴影元素。由于阴影不会是全黑的(由于散射),我们把ambient分量从乘法中剔除。

像素着色器大部分是从高级光照教程中复制过来,只不过加上了个阴影计算。我们声明一个shadowCalculation函数,用它计算阴影。像素着色器的最后,我们我们把diffuse和specular乘以(1-阴影元素),这表示这个片元有多大成分不在阴影中。这个像素着色器还需要两个额外输入,一个是光空间的片元位置和第一个渲染阶段得到的深度贴图。

5、渲染深度贴图

  1. // 1. render depth of scene to texture (from light's perspective)
  2. // --------------------------------------------------------------
  3. glm::mat4 lightProjection, lightView;
  4. glm::mat4 lightSpaceMatrix;
  5. float near_plane = 1.0f, far_plane = 7.5f;
  6. lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, near_plane, far_plane);
  7. lightView = glm::lookAt(lightPos, glm::vec3(0.0f), glm::vec3(0.0, 1.0, 0.0));
  8. lightSpaceMatrix = lightProjection * lightView;
  9. // render scene from light's point of view
  10. simpleDepthShader.use();
  11. simpleDepthShader.setMat4("lightSpaceMatrix", lightSpaceMatrix);
  12. glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
  13. glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
  14. glClear(GL_DEPTH_BUFFER_BIT);
  15. glActiveTexture(GL_TEXTURE0);
  16. glBindTexture(GL_TEXTURE_2D, woodTexture);
  17. renderScene(simpleDepthShader);
  18. glBindFramebuffer(GL_FRAMEBUFFER, 0);
  19. // reset viewport
  20. glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);
  21. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  22. // render Depth map to quad for visual debugging
  23. // ---------------------------------------------
  24. debugDepthQuad.use();
  25. debugDepthQuad.setFloat("near_plane", near_plane);
  26. debugDepthQuad.setFloat("far_plane", far_plane);
  27. glActiveTexture(GL_TEXTURE0);
  28. glBindTexture(GL_TEXTURE_2D, depthMap);
  29. renderQuad();

将深度贴图渲染到四边形上的像素着色器:

  1. #version 330 core
  2. out vec4 FragColor;
  3. in vec2 TexCoords;
  4. uniform sampler2D depthMap;
  5. uniform float near_plane;
  6. uniform float far_plane;
  7. // required when using a perspective projection matrix
  8. float LinearizeDepth(float depth)
  9. {
  10. float z = depth * 2.0 - 1.0; // Back to NDC
  11. return (2.0 * near_plane * far_plane) / (far_plane + near_plane - z * (far_plane - near_plane));
  12. }
  13. void main()
  14. {
  15. float depthValue = texture(depthMap, TexCoords).r;
  16. // FragColor = vec4(vec3(LinearizeDepth(depthValue) / far_plane), 1.0); // perspective
  17. FragColor = vec4(vec3(depthValue), 1.0); // orthographic
  18. }

参考文献:

https://learnopengl-cn.github.io/05%20Advanced%20Lighting/03%20Shadows/01%20Shadow%20Mapping/

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/爱喝兽奶帝天荒/article/detail/768914
推荐阅读
相关标签
  

闽ICP备14008679号