深度缓冲基本属性#

深度缓冲与颜色缓冲宽、高完全一致，一一对应每个屏幕像素。
深度缓冲由窗口系统自动创建，无需手动开辟显存。
深度精度分为：16bit、24bit、32bit，项目最常用 24bit。

深度测试执行时机与 gl_FragCoord#

执行顺序#

完整渲染顺序：片元着色器运行之后 → 模板测试之后 → 深度测试（屏幕空间）

gl_FragCoord 内置变量#

可在片元着色器中读取片元屏幕空间信息：

x、y 分量：屏幕像素坐标，屏幕左下角为原点。
z 分量：该片元真实的屏幕空间深度值，用于和深度缓冲数据比对、判断遮挡。

Early-Z 提前深度测试#

执行时机：在片元着色器执行之前提前完成深度测试。
作用：提前剔除被遮挡片元，跳过片元着色器计算，大幅提升性能。
限制：开启 Early-Z 的前提下，片元着色器不能修改片元深度值。一旦手动修改深度，Early-Z 预判失效，硬件会自动关闭提前测试。

深度测试常用核心指令#

1
// 开启深度测试（默认关闭）
2
glEnable(GL_DEPTH_TEST);
3

4
// 清空深度缓冲（每一帧渲染前必须执行）
5
glClear(GL_DEPTH_BUFFER_BIT);
6

7
// 深度缓冲只读：只测试不写入，常用于UI、透明物体
8
glDepthMask(GL_FALSE);
9

10
// 设置深度测试比较函数（常用：小于当前深度则通过）
11
glDepthFunc(GL_LESS);

深度值完整变换流水线#

深度变换流程#

相机空间Z → 透视投影矩阵 → 裁剪空间Z → 透视除法 → NDC空间Z → 归一化映射 → 屏幕空间Z（写入深度缓冲）

各空间 Z 值范围#

相机空间、裁剪空间：[-far, -near]
NDC 空间：[-1, 1]
屏幕空间/深度缓冲存储值：[0, 1]

非线性深度#

透视除法会引入非线性关系：

NDC 的 Z 和相机空间 Z 不再是正比关系。
近处深度精度极高：近处微小空间占用大量 0~1 深度区间。
远处深度精度极低：远距离大范围空间被压缩到极小深度区间。优势：优先保证近处物体的深度精度，高效利用有限的深度缓冲位数。

深度值可视化#

深度缓冲中存储的深度值越接近 1.0，可视化颜色越白；越接近 0.0 越黑。

Z-fighting#

产生原因#

两个平面/三角面几乎平行且紧贴重合，深度缓冲精度不足以区分前后顺序，导致每一帧随机穿插闪烁、出现斑驳花纹。 远处物体更严重：远处深度精度本身极低，极容易出现深度冲突。

解决办法#

拉开偏移距离：给重叠物体设置肉眼不可察的微小空间偏移，彻底避免 Z 值重合，需逐场景测试微调。
适当拉远近平面：深度精度主要集中在近平面附近，拉远近平面可整体提升视锥体全域精度；但不能过远，否则近处物体被裁剪。
使用更高精度深度缓冲：舍弃部分性能，将默认 24bit 深度缓冲提升为 32bit，大幅缓解精度不足问题。

example1: 深度测试函数对深度测试的影响#

搭建一个简单的场景用于测试深度测试，包括带纹理的两个立方体箱子和一个平面。教程中的代码虽然加载了两张纹理，但是在绘制时仅使用了一张纹理，并没有给平面绑定上纹理，片元着色器中也是只采样了一张纹理，所以三个物体都共用一张纹理。我对此进行了修改，首先是片元着色器中定义了第二张纹理对应的uniform变量，并使用一个int型的开关变量标识当前绘制的是哪个物体，控制开启哪一张纹理。然后在main.cpp中，将两个uniform变量都赋好值，在渲染循环中，绘制箱子时，激活第一个纹理单元，绑定第一张纹理，然后设置开关变量值；绘制平面时，激活第二个纹理单元，绑定第二张纹理，同样设置开关变量值。之后由于粗心，在加载纹理时，未绑定就设置了纹理的参数，包括glTexImage（传递纹理）、glGenerateMipmap（生成mipmap）以及glTexParameteri等属性设置。导致平面纹理没有加载成功，渲染出来是黑色。

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4
#include <stb_image.h>
5

6
#include <glm/glm.hpp>
7
#include <glm/gtc/matrix_transform.hpp>
8
#include <glm/gtc/type_ptr.hpp>
9

10
#include <myShader.h>
11
#include <myCamera.h>
12
#include <Model.h>
13

14
#include <iostream>
15

16
const unsigned int SCR_WIDTH = 800;
17
const unsigned int SCR_HEIGHT = 400;
18

19
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
20
float lastX = (float)SCR_WIDTH / 2.0;
21
float lastY = (float)SCR_HEIGHT / 2.0;
22
bool firstCamera = true;
23

24
float deltaTime = 0.0f;
25
float lastFrame = 0.0f;
26

27
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
28
        glViewport(0, 0, width, height);
29
}
30
void processInput(GLFWwindow* window) {
31
        if (glfwGetKey(window, GLFW_KEY_ESCAPE)) {
32
                glfwSetWindowShouldClose(window, true);
33
        }
34
        if (glfwGetKey(window, GLFW_KEY_W)) {
35
                camera.ProcessKeyboard(FORWARD, deltaTime);
36
        }
37
        if (glfwGetKey(window, GLFW_KEY_S)) {
38
                camera.ProcessKeyboard(BACKWARD, deltaTime);
39
        }
40
        if (glfwGetKey(window, GLFW_KEY_A)) {
41
                camera.ProcessKeyboard(LEFT, deltaTime);
42
        }
43
        if (glfwGetKey(window, GLFW_KEY_D)) {
44
                camera.ProcessKeyboard(RIGHT, deltaTime);
45
        }
46
}
47
void processMovement(GLFWwindow* window, double xpos, double ypos) {
48
        if (firstCamera) {
49
                lastX = static_cast<float>(xpos);
50
                lastY = static_cast<float>(ypos);
51
                firstCamera = false;
52
        }
53
        float xoffset = static_cast<float>(xpos) - lastX;
54
        float yoffset = lastY - static_cast<float>(ypos);
55
        lastX = static_cast<float>(xpos);
56
        lastY = static_cast<float>(ypos);
57
        camera.ProcessMouseMovement(xoffset, yoffset);
58
}
59
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
60
        camera.ProcessScroll(static_cast<float>(yoffset));
61
}
62
unsigned int loadTexture(const char* path) {
63
        unsigned int texture;
64
        glGenTextures(1, &texture);
65

66
        int width, height, nrChannels;
67
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
68
        if (data) {
69
                GLenum format;
70
                if (nrChannels == 1) {
71
                        format = GL_RED;
72
                }
73
                else if (nrChannels == 3) {
74
                        format = GL_RGB;
75
                }
76
                else if (nrChannels == 4) {
77
                        format = GL_RGBA;
78
                }
79
                glBindTexture(GL_TEXTURE_2D, texture);
80

81
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
82
                glGenerateMipmap(GL_TEXTURE_2D);
83

84
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
85
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
86
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
87
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
88
        }
89
        else {
90
                cout << "failed to load tetxure" << endl;
91
        }
92
        stbi_image_free(data);
93

94
        return texture;
95
}
96
int main() {
97
        glfwInit();
98
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
99
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
100
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
101

102
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "learnOpenGL", NULL, NULL);
103

104
        if (window == NULL) {
105
                cout << "failed to create GLFW window" << endl;
106
                glfwTerminate();
107
                return -1;
108
        }
109

110
        glfwMakeContextCurrent(window);
111
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
112
        glfwSetCursorPosCallback(window, processMovement);
113
        glfwSetScrollCallback(window, processScroll);
114

115
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
116

117
        if (!gladLoadGLLoader(GLADloadproc(glfwGetProcAddress))) {
118
                cout << "failed to initialize glad" << endl;
119
                glfwTerminate();
120
                return -1;
121
        }
122

123
        stbi_set_flip_vertically_on_load(true);
124

125
        glEnable(GL_DEPTH_TEST);
126
        glDepthFunc(GL_LESS);
127

128
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
129

130
        float cubeVertices[] = {
131
                -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
132
                 0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
133
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
134
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
135
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
136
                -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
137

138
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
139
                 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
140
                 0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
141
                 0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
142
                -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
143
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
144

145
                -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
146
                -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
147
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
148
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
149
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
150
                -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
151

152
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
153
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
154
                 0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
155
                 0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
156
                 0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
157
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
158

159
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
160
                 0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
161
                 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
162
                 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
163
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
164
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
165

166
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
167
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
168
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
169
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
170
                -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
171
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
172
        };
173

174
        float planeVertices[] = {
175
                5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
176
                -5.0f, -0.5f,  5.0f,  0.0f, 0.0f,
177
                -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
178

179
                 5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
180
                -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
181
                 5.0f, -0.5f, -5.0f,  2.0f, 2.0f
182
        };
183

184
        unsigned int cubeVAO, cubeVBO;
185
        glGenVertexArrays(1, &cubeVAO);
186
        glGenBuffers(1, &cubeVBO);
187

188
        glBindVertexArray(cubeVAO);
189
        glBindBuffer(GL_ARRAY_BUFFER,cubeVBO);
190
        glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), cubeVertices, GL_STATIC_DRAW);
191

192
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
193
        glEnableVertexAttribArray(0);
194

195
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
196
        glEnableVertexAttribArray(1);
197

198
        glBindVertexArray(0);
199

200
        unsigned int planeVAO, planeVBO;
201
        glGenVertexArrays(1, &planeVAO);
202
        glGenBuffers(1, &planeVBO);
203

204
        glBindVertexArray(planeVAO);
205
        glBindBuffer(GL_ARRAY_BUFFER,planeVBO);
206
        glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), planeVertices, GL_STATIC_DRAW);
207

208
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
209
        glEnableVertexAttribArray(0);
210

211
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
212
        glEnableVertexAttribArray(1);
213

214
        glBindVertexArray(0);
215

216
        unsigned int cubeTexture = loadTexture("resources/textures/marble.jpg");
217
        unsigned int floorTexture = loadTexture("resources/textures/metal.jpg");
218

219
        shader.use();
220
        shader.setInt("texture1", 0);
221
        shader.setInt("texture2", 1);
222

223
        while (!glfwWindowShouldClose(window)) {
224
                float currentFrame = (float)glfwGetTime();
225
                deltaTime = currentFrame - lastFrame;
226
                lastFrame = currentFrame;
227

228
                processInput(window);
229

230
                glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
231
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
232

233
                shader.use();
234
                glm::mat4 model = glm::mat4(1.0f);
235
                glm::mat4 view = camera.GetCameraView();
236
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
237
                shader.setMatrix("view", view);
238
                shader.setMatrix("project", project);
239

240
                glBindVertexArray(cubeVAO);
241
                glActiveTexture(GL_TEXTURE0);
242
                glBindTexture(GL_TEXTURE_2D, cubeTexture);
243
                shader.setInt("useFloorTex", 0);
244
                model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
245
                shader.setMatrix("model", model);
246
                glDrawArrays(GL_TRIANGLES, 0, 36);
247

248
                model = glm::mat4(1.0f);
249
                model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
250
                shader.setMatrix("model", model);
251
                glDrawArrays(GL_TRIANGLES, 0, 36);
252

253
                glBindVertexArray(0);
254

255
                glBindVertexArray(planeVAO);
256
                glActiveTexture(GL_TEXTURE1);
257
                glBindTexture(GL_TEXTURE_2D, floorTexture);
258
                shader.setInt("useFloorTex", 1);
259
                shader.setMatrix("model", glm::mat4(1.0f));
260
                glDrawArrays(GL_TRIANGLES, 0, 6);
261
                glBindVertexArray(0);
262

263
                glfwSwapBuffers(window);
264
                glfwPollEvents();
265
        }
266
        glDeleteVertexArrays(1, &cubeVAO);
267
        glDeleteVertexArrays(1, &planeVAO);
268
        glDeleteBuffers(1, &cubeVBO);
269
        glDeleteBuffers(1, &planeVBO);
270

271
        glfwTerminate();
272
        return 0;
273
}

1
//vertexShader
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4
layout (location = 1) in vec2 aTexCoords;
5

6
out vec2 TexCoords;
7

8
uniform mat4 model;
9
uniform mat4 view;
10
uniform mat4 project;
11

12
void main(){
13
        TexCoords=aTexCoords;
14
        gl_Position=project*view*model*vec4(aPos,1.0);
15
}

1
//fragmentShader
2
#version 330 core
3
in vec2 TexCoords;
4
out vec4 FragColor;
5
uniform sampler2D texture1;
6
uniform sampler2D texture2;
7

8
uniform int useFloorTex;
9
void main(){
10
        if(useFloorTex==1){
11
                FragColor=texture(texture2,TexCoords);
12
        }else{
13
                FragColor=texture(texture1,TexCoords);
14
        }
15
}

深度测试函数默认是GL_LESS，可以通过glDepthFunc(xx)修改。 GL_LESS: BQACAgUAAyEGAASHRsPbAAEWKvhqP2YJenK6SQivG4LdbDnbu7-8OgACKSQAAk05AVbplyixfcLYsjwE.png **GL_ALWAYS:**永远通过深度测试，那么最后绘制的片段会遮挡之前绘制的片段。下图中，最后绘制的地板会遮挡之前绘制的立方体箱子。 BQACAgUAAyEGAASHRsPbAAEWKwhqP2dU1kfqT8T7nEQLHNOIn904lwACTyQAAk05AVacE9longww2TwE.png

example2: 可视化深度缓冲#

在片元着色器中通过gl_FragCoord访问每个片元的屏幕坐标，其z值为屏幕空间深度值。将这个值直接作为颜色输出。

1
//fragmentShader
2
#version 330 core
3
in vec2 TexCoords;
4
out vec4 FragColor;
5
uniform sampler2D texture1;
6
uniform sampler2D texture2;
7

8
uniform int useFloorTex;
9
void main(){
10
        FragColor=vec4(vec3(gl_FragCoord.z),1.0);
11
}

刚渲染出来时，几乎所有物体都是白色的，即深度值非常大。当移动相机靠近其中一个物体，观察到近处区域开始变暗，且有渐变，但远处区域仍然全白。这很清楚地展示了深度值的非线性性质。近处的物体比起远处的物体对深度值有着更大的影响。只需要移动几厘米就能让颜色从暗完全变白。 BQACAgUAAyEGAASHRsPbAAEWKw5qP2e32a5xdFoG05Bx65HYiuXnMwACWCQAAk05AVZxnLQZi7BwvTwE.png

BQACAgUAAyEGAASHRsPbAAEWKw9qP2fb9SS0i5t6b98N5xx-qBO46QACWSQAAk05AVZK7_HBcR-iXDwE.png

example3: 线性化深度值#

即把NDC空间的z值变换到相机空间下，需要逆归一化、逆投影变换以及透视除法。得到的相机空间深度值是[near,far]范围的，直接显示的话，大部分深度值都大于1，则画面全白。所以为了便于显示，除以far进行归一化到[0,1]。

1
//fragmentShader
2
#version 330 core
3
in vec2 TexCoords;
4
out vec4 FragColor;
5
uniform sampler2D texture1;
6
uniform sampler2D texture2;
7

8
uniform int useFloorTex;
9

10
float near=0.1;
11
float far=100.0;
12

13
float LinearizeDepth(float depth){
14
        float z=depth*2.0-1.0;
15
        return (2.0*near*far) / (far+near-z*(far-near));
16
}
17
void main(){
18
        //if(useFloorTex==1){
19
        //        FragColor=texture(texture2,TexCoords);
20
        //}else{
21
        //        FragColor=texture(texture1,TexCoords);
22
        //}
23
        float depth=LinearizeDepth(gl_FragCoord.z);
24
        FragColor=vec4(vec3(depth/far),1.0);
25
}

BQACAgUAAyEGAASHRsPbAAEWKxVqP2gmo7JOsq0VqAZXbaKIfN9HYwACYSQAAk05AVb-wgw7fh8LuDwE.png 可以看到越接近远平面的区域越亮，越接近近平面的区域越暗。此外，画面很暗，这是因为线性深度值在[0.1,100]，归一化后在[0.001,1]，距离相机10个单位以内的物体的深度值在[0.001,0.1]之间，而且场景中的物体都集中在这个区间，所以画面偏暗。测试：将far改为10.0 当相机离物体较远->物体深度值较大->较亮 BQACAgUAAyEGAASHRsPbAAEWKxZqP2hqMZe6NmTqmi3EBINuy29E9QACYiQAAk05AVZ_rROnU2FgsjwE.png 当相机离物体较近->物体深度值较小->较暗 BQACAgUAAyEGAASHRsPbAAEWKxdqP2iIjro80Sq6zPj9-bhgSwaGqQACYyQAAk05AVYga_MzwYR9PjwE.png

example4: 深度冲突#

将相机移动到其中一个箱子的内部，观察底面，发现底面的纹理不断在平面纹理和箱子纹理之间切换，且有明显的锯齿状花纹。 BQACAgUAAyEGAASHRsPbAAEWKxpqP2jArvgtxTg1gJwCcyPp1DO6BgACZyQAAk05AVYdFWZEjQ_MKzwE.png