光源空间坐标转换原理#

使用光源的视图矩阵和投影矩阵，可以将场景中任意三维位置点变换到光源的可见坐标空间。硬件会在投影矩阵计算完成后自动执行透视除法，将坐标从裁剪空间转换至 NDC 归一化设备空间。经过归一化处理后：坐标的 XY 分量用于采样阴影贴图，Z 分量代表当前片元相对于光源的真实深度值。

阴影贴图生成与特殊 FBO 配置规则#

深度贴图（阴影贴图）的生成逻辑：从光源视角渲染整个场景，仅将场景深度数据存入深度纹理，最终得到一张记录光源可视深度信息的 Shadow Map。生成阴影贴图需要自定义帧缓冲，且帧缓冲仅绑定深度纹理附件，无任何颜色附件。OpenGL 规范中，无颜色缓冲的帧缓冲会被判定为不完整帧缓冲，因此需要手动指定帧缓冲不启用颜色读写。通过将读写缓冲目标设置为 GL_NONE 解决帧缓冲不完整问题。 FBO 读写缓冲区补充规则

普通单颜色附件 FBO、窗口默认渲染：无需手动设置，OpenGL 自动绑定COLOR0/BACK 缓冲。
需要手动调用 glDrawBuffer / glReadBuffer 三种特殊场景：多颜色附件 MRT 渲染、手动切换读写附件、纯深度无颜色渲染。
阴影贴图专属特例：仅挂载深度附件、无颜色附件的 FBO，是单附件场景中唯一需要手动设置 GL_NONE 的情况。

平行光阴影投影矩阵规则#

制作平行光阴影贴图时，光源统一使用正交投影矩阵，贴合平行光无透视、光线平行照射的物理特性。

阴影投射与阴影接收的区分逻辑#

阴影投射体：深度贴图中记录的深度对应的物体，也就是能够产生阴影的物体。若物体/片元未参与深度贴图渲染，不会投射任何阴影。
阴影接收体：通过采样深度贴图判断明暗的物体。若物体/片元未采样深度贴图，则不会接收任何阴影效果。

颜色缓冲与深度缓冲的生成、写入规则#

颜色数据规则#

颜色数据仅由片元着色器生成，硬件不会自动生成像素颜色。若片元着色器无输出颜色，GPU 不会填充颜色缓冲区，颜色缓冲会保留原有垃圾数据。

深度数据规则#

深度数据默认来源于光栅化阶段插值后的片元 Z 坐标，不由片元着色器生成，但片元着色器可以手动修改深度值。

最终写入规则#

将颜色、深度数据写入帧缓冲的操作均由硬件完成：

颜色：硬件读取片元着色器输出颜色，写入颜色缓冲。
深度：若片元着色器修改过深度，硬件读取着色器输出深度写入深度缓冲；否则直接使用光栅化插值的片元 Z 坐标。

阴影光照分量作用范围#

由于现实中存在空气光散射效果，阴影并非纯黑。因此阴影效果仅限制漫反射、镜面反射分量，完全不作用于环境光分量，保证阴影区域保留基础环境亮度，效果更真实。

光源视锥体域外阴影异常修复方案#

异常成因#

片元处于光源正交视锥体范围外时，NDC 坐标会超出 [-1,1] 区间，转换后的纹理采样坐标超出 [0,1]。若阴影纹理环绕模式为 GL_REPEAT，超出范围的坐标会循环采样有效区域纹理，导致视锥体域外本应完全受光的区域产生错误阴影。

解决方案#

将阴影贴图纹理环绕模式改为 GL_CLAMP_TO_BORDER，并设置白色边框颜色。纹理坐标超出范围时，统一读取边框深度值 1.0。场景片元真实深度永远小于 1.0，域外片元深度测试永远通过，保持正常受光，彻底解决错误阴影问题。

边框颜色参数说明#

边框颜色参数：float borderColor[] = { 1.0, 1.0, 1.0, 1.0 } 四个分量依次对应 RGBA 通道。由于深度贴图为单通道纹理，坐标越界时 OpenGL 仅读取第一个 R 分量作为深度值。

深度值线性化与深度比较核心误区纠正#

无论是透视投影矩阵还是正交投影矩阵，阴影深度比较不需要线性化深度值，仅在可视化展示深度贴图时必须线性化。

closestDepth：从阴影贴图采样得到的原始非线性窗口深度值。
currentDepth：当前片元换算得到的同标准非线性窗口深度值。二者处于同一套非线性坐标系，取值规则完全一致，可直接对比大小，对比结果绝对准确。深度线性化仅用于将非线性深度值还原为真实物理距离，不会改变数值大小关系，因此不影响阴影判断逻辑。

example1: 渲染深度贴图#

阴影贴图可视化整体流程分为两个渲染 Pass：生成深度贴图、可视化深度贴图。

Pass1：生成深度贴图#

该阶段需要渲染完整场景，仅写入深度数据、不写入任何颜色数据。深度数据不输出到屏幕默认帧缓冲，而是渲染到自定义帧缓冲的深度纹理附件中，最终生成一张完整的场景深度贴图。

顶点着色器工作逻辑#

负责将物体世界空间坐标变换至光源空间，运算依赖光源视线矩阵 + 光源投影矩阵，完成场景坐标的光源空间转换。

片元着色器工作逻辑#

片元着色器无需输出颜色，保持空实现即可。深度数据由渲染管线硬件自动写入，无需着色器手动计算与输出。

Pass2：可视化深度贴图#

该阶段通过全屏四边形渲染，将上一阶段生成的深度贴图直接渲染至屏幕默认帧缓冲。四边形的每一个片元对深度贴图进行纹理采样，获取对应深度值，按需转换为线性灰度后输出画面。

平行光与非平行光#

平行光（正交投影）#

平行光采用正交投影矩阵，深度贴图中存储的窗口深度值本身就在 [0~1] 区间且完全线性，无需任何线性化处理，可直接将采样得到的深度值作为灰度颜色输出。

非平行光（透视投影）#

非平行光采用透视投影矩阵，深度贴图中的窗口深度值虽处于 [0~1] 区间，但属于非线性深度。特点为：近处深度数值变化剧烈，远处深度数值变化极小。若直接可视化，画面绝大部分区域会呈现纯白色，深度层次被严重压缩，肉眼无法分辨梯度变化，因此必须进行深度线性化处理。

透视深度线性化#

线性化的核心目的：将非线性窗口深度还原为符合真实物理距离的线性深度。

逆归一化：将 [0~1] 的窗口深度还原为 [-1,1] 的 NDC 坐标；
逆投影运算：通过逆投影矩阵将 NDC 坐标转换至相机视图空间，此时深度值为真实线性深度，范围 [-near,-far]；
二次归一化：将视图空间线性深度重新映射至 [0~1] 区间，方可作为灰度值正常可视化输出。本次案例基于平行光实现阴影效果，深度贴图深度值天然线性，因此直接采样深度值输出灰度画面即可，无需线性化处理。

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

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

9
#include <stb_image.h>
10
#include <iostream>
11
#include <vector>
12

13
#include <myShader.h>
14
#include <myCamera.h>
15
#include <Model.h>
16

17
using namespace std;
18

19
const unsigned int SCR_WIDTH = 800;
20
const unsigned int SCR_HEIGHT = 400;
21
bool gammaEnabled = false;
22
bool gammaKeyPressed = false;
23

24
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
25
float lastX = (float)SCR_WIDTH / 2.0f;
26
float lastY = (float)SCR_HEIGHT / 2.0f;
27
float deltaTime = 0.0f;
28
float lastFrame = 0.0f;
29
bool firstCamera = true;
30

31
unsigned int planeVAO;
32

33
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
34
        glViewport(0, 0, width, height);
35
}
36
void processInput(GLFWwindow* window) {
37
        if(glfwGetKey(window,GLFW_KEY_ESCAPE)==GLFW_PRESS){
38
                glfwSetWindowShouldClose(window, true);
39
        }
40
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
41
                camera.ProcessKeyboard(FORWARD, deltaTime);
42
        }
43
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
44
                camera.ProcessKeyboard(BACKWARD, deltaTime);
45
        }
46
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
47
                camera.ProcessKeyboard(LEFT, deltaTime);
48
        }
49
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
50
                camera.ProcessKeyboard(RIGHT, deltaTime);
51
        }
52
        if (glfwGetKey(window, GLFW_KEY_B) == GLFW_PRESS && !gammaKeyPressed) {
53
                gammaEnabled = !gammaEnabled;
54
                gammaKeyPressed = true;
55
        }
56
        if (glfwGetKey(window, GLFW_KEY_B) != GLFW_PRESS) {
57
                gammaKeyPressed = false;
58
        }
59
}
60
void processMovement(GLFWwindow* window, double xpos, double ypos) {
61
        if (firstCamera) {
62
                lastX = xpos;
63
                lastY = ypos;
64
                firstCamera = false;
65
        }
66
        float xoffset = xpos - lastX;
67
        float yoffset = lastY - ypos;
68
        lastX = xpos;
69
        lastY = ypos;
70
        camera.ProcessMouseMovement(xoffset, yoffset);
71
}
72
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
73
        camera.ProcessScroll(yoffset);
74
}
75
unsigned int loadTexture(const char* path) {
76
        unsigned int texture;
77
        glGenTextures(1, &texture);
78
        glBindTexture(GL_TEXTURE_2D, texture);
79

80
        int width, height, nrChannels;
81
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
82
        if (data) {
83
                GLenum dataFormat;
84
                if (nrChannels == 1) {
85
                        dataFormat = GL_RED;
86
                }
87
                else if (nrChannels == 3) {
88
                        dataFormat = GL_RGB;
89
                }
90
                else if (nrChannels == 4) {
91
                        dataFormat = GL_RGBA;
92
                }
93
                glTexImage2D(GL_TEXTURE_2D, 0, dataFormat, width, height, 0, dataFormat, GL_UNSIGNED_BYTE, data);
94
                glGenerateMipmap(GL_TEXTURE_2D);
95
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
96
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
97
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
98
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
99
        }
100
        else {
101
                cout << "Failed to load texture" << endl;
102
        }
103
        stbi_image_free(data);
104
        return texture;
105
}
106
unsigned int cubeVAO = 0;
107
unsigned int cubeVBO = 0;
108
void renderCube() {
109
        if (cubeVAO == 0) {//还没有创建VAO则创建，创建了就直接绑定
110
                float vertices[] = {
111
                        // back face
112
                        -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
113
                         1.0f,  1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 1.0f, 1.0f, // top-right
114
                         1.0f, -1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 1.0f, 0.0f, // bottom-right
115
                         1.0f,  1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 1.0f, 1.0f, // top-right
116
                        -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
117
                        -1.0f,  1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 1.0f, // top-left
118
                        // front face
119
                        -1.0f, -1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 0.0f, // bottom-left
120
                         1.0f, -1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f, 0.0f, // bottom-right
121
                         1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f, 1.0f, // top-right
122
                         1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f, 1.0f, // top-right
123
                        -1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 1.0f, // top-left
124
                        -1.0f, -1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 0.0f, // bottom-left
125
                        // left face
126
                        -1.0f,  1.0f,  1.0f, -1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-right
127
                        -1.0f,  1.0f, -1.0f, -1.0f,  0.0f,  0.0f, 1.0f, 1.0f, // top-left
128
                        -1.0f, -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-left
129
                        -1.0f, -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-left
130
                        -1.0f, -1.0f,  1.0f, -1.0f,  0.0f,  0.0f, 0.0f, 0.0f, // bottom-right
131
                        -1.0f,  1.0f,  1.0f, -1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-right
132
                        // right face
133
                         1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-left
134
                         1.0f, -1.0f, -1.0f,  1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-right
135
                         1.0f,  1.0f, -1.0f,  1.0f,  0.0f,  0.0f, 1.0f, 1.0f, // top-right
136
                         1.0f, -1.0f, -1.0f,  1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-right
137
                         1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-left
138
                         1.0f, -1.0f,  1.0f,  1.0f,  0.0f,  0.0f, 0.0f, 0.0f, // bottom-left
139
                         // bottom face
140
                         -1.0f, -1.0f, -1.0f,  0.0f, -1.0f,  0.0f, 0.0f, 1.0f, // top-right
141
                          1.0f, -1.0f, -1.0f,  0.0f, -1.0f,  0.0f, 1.0f, 1.0f, // top-left
142
                          1.0f, -1.0f,  1.0f,  0.0f, -1.0f,  0.0f, 1.0f, 0.0f, // bottom-left
143
                          1.0f, -1.0f,  1.0f,  0.0f, -1.0f,  0.0f, 1.0f, 0.0f, // bottom-left
144
                         -1.0f, -1.0f,  1.0f,  0.0f, -1.0f,  0.0f, 0.0f, 0.0f, // bottom-right
145
                         -1.0f, -1.0f, -1.0f,  0.0f, -1.0f,  0.0f, 0.0f, 1.0f, // top-right
146
                         // top face
147
                         -1.0f,  1.0f, -1.0f,  0.0f,  1.0f,  0.0f, 0.0f, 1.0f, // top-left
148
                          1.0f,  1.0f , 1.0f,  0.0f,  1.0f,  0.0f, 1.0f, 0.0f, // bottom-right
149
                          1.0f,  1.0f, -1.0f,  0.0f,  1.0f,  0.0f, 1.0f, 1.0f, // top-right
150
                          1.0f,  1.0f,  1.0f,  0.0f,  1.0f,  0.0f, 1.0f, 0.0f, // bottom-right
151
                         -1.0f,  1.0f, -1.0f,  0.0f,  1.0f,  0.0f, 0.0f, 1.0f, // top-left
152
                         -1.0f,  1.0f,  1.0f,  0.0f,  1.0f,  0.0f, 0.0f, 0.0f  // bottom-left
153
                };
154

155
                glGenVertexArrays(1, &cubeVAO);
156
                glBindVertexArray(cubeVAO);
157
                glGenBuffers(1, &cubeVBO);
158
                glBindBuffer(GL_ARRAY_BUFFER,cubeVBO);
159
                glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
160
                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
161
                glEnableVertexAttribArray(0);
162
                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
163
                glEnableVertexAttribArray(1);
164
                glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
165
                glEnableVertexAttribArray(2);
166
                glBindBuffer(GL_ARRAY_BUFFER, 0);
167
                glBindVertexArray(0);
168
        }
169
        glBindVertexArray(cubeVAO);
170
        glDrawArrays(GL_TRIANGLES, 0, 36);
171
        glBindVertexArray(0);
172
}
173
//后处理的全屏四边形
174
unsigned int quadVAO = 0;
175
unsigned int quadVBO = 0;
176
void renderQuad() {
177
        if (quadVAO == 0) {
178
                float quadVertices[] = {
179
                        // positions        // texture Coords
180
                        -1.0f,  1.0f, 0.0f, 0.0f, 1.0f,
181
                        -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
182
                         1.0f,  1.0f, 0.0f, 1.0f, 1.0f,
183
                         1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
184
                };
185
                glGenVertexArrays(1, &quadVAO);
186
                glGenBuffers(1, &quadVBO);
187
                glBindVertexArray(quadVAO);
188
                glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
189
                glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW);
190
                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
191
                glEnableVertexAttribArray(0);
192
                glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
193
                glEnableVertexAttribArray(1);
194
                glBindBuffer(GL_ARRAY_BUFFER, 0);
195
                glBindVertexArray(0);
196
        }
197
        glBindVertexArray(quadVAO);
198
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
199
        //因为顶点数组只定义了四个顶点，所以必须使用三角形带的绘制模式，第三个参数表示一共要渲染几个顶点。前三和后三分别构成两个三角形
200
        //绘制模式可以改为三角形，这样顶点数组就必须是6个顶点
201
        glBindVertexArray(0);
202
}
203
void renderScene(const Shader& shader) {
204
        //floor
205
        glm::mat4 model = glm::mat4(1.0);
206
        shader.setMat4("model", model);
207
        glBindVertexArray(planeVAO);
208
        glDrawArrays(GL_TRIANGLES, 0, 6);
209

210
        //cubes
211
        model = glm::mat4(1.0f);
212
        model = glm::translate(model, glm::vec3(0.0f, 1.5f, 0.0f));
213
        model = glm::scale(model, glm::vec3(0.5f));
214
        shader.setMat4("model", model);
215
        renderCube();
216
        model = glm::mat4(1.0f);
217
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 1.0f));
218
        model = glm::scale(model, glm::vec3(0.5f));
219
        shader.setMat4("model", model);
220
        renderCube();
221
        model = glm::mat4(1.0f);
222
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, 2.0f));
223
        model = glm::rotate(model, glm::radians(60.0f), glm::normalize(glm::vec3(1.0f, 0.0f, 1.0f)));//旋转轴必须是单位向量，如果向量长度不为1，旋转矩阵会附带缩放效果，模型会被拉伸
224
        model = glm::scale(model, glm::vec3(0.25f));
225
        shader.setMat4("model", model);
226
        renderCube();
227
}
228

229
int main() {
230
        glfwInit();
231
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
232
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
233
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
234

235
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
236
        if (window == NULL) {
237
                cout << "Failed to initialize GLFW" << endl;
238
                glfwTerminate();
239
                return -1;
240
        }
241
        glfwMakeContextCurrent(window);
242
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
243
        glfwSetScrollCallback(window, processScroll);
244
        glfwSetCursorPosCallback(window, processMovement);
245

246
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
247
                cout << "failed to load glad" << endl;
248
                glfwTerminate();
249
                return -1;
250
        }
251

252
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
253

254
        //stbi_set_flip_vertically_on_load(true);
255

256
        glEnable(GL_DEPTH_TEST);
257

258
        //地面平面
259
        float planeVertices[] = {
260
                // positions            // normals         // texcoords
261
                 25.0f, -0.5f,  25.0f,  0.0f, 1.0f, 0.0f,  25.0f,  0.0f,
262
                -25.0f, -0.5f,  25.0f,  0.0f, 1.0f, 0.0f,   0.0f,  0.0f,
263
                -25.0f, -0.5f, -25.0f,  0.0f, 1.0f, 0.0f,   0.0f, 25.0f,
264

265
                 25.0f, -0.5f,  25.0f,  0.0f, 1.0f, 0.0f,  25.0f,  0.0f,
266
                -25.0f, -0.5f, -25.0f,  0.0f, 1.0f, 0.0f,   0.0f, 25.0f,
267
                 25.0f, -0.5f, -25.0f,  0.0f, 1.0f, 0.0f,  25.0f, 25.0f
268
        };
269

270
        unsigned int planeVBO;
271
        glGenVertexArrays(1, &planeVAO);
272
        glGenBuffers(1, &planeVBO);
273
        glBindVertexArray(planeVAO);
274
        glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
275
        glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), planeVertices, GL_STATIC_DRAW);
276
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
277
        glEnableVertexAttribArray(0);
278
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
279
        glEnableVertexAttribArray(1);
280
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
281
        glEnableVertexAttribArray(2);
282
        glBindVertexArray(0);
283

284
        const unsigned int SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
285
        unsigned int depthMapFBO;
286
        glGenFramebuffers(1, &depthMapFBO);
287

288
        unsigned int depthMap;
289
        glGenTextures(1, &depthMap);
290
        glBindTexture(GL_TEXTURE_2D, depthMap);
291
        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
292
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
293
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
294
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
295
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
296

297
        glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
298
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap, 0);//最后一个参数是mipmap层级，我们只用纹理第0层即原始分辨率
299
        glDrawBuffer(GL_NONE);
300
        glReadBuffer(GL_NONE);
301
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
302

303
        //第一个Shader画场景，只写深度到深度图
304
        Shader simpleDepthShader("src/Shader/depthVertexShader.txt", "src/Shader/depthFragmentShader.txt");
305
        //第二个Shader画全屏四边形，从深度图采样深度
306
        Shader debugDepthQuad("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
307

308
        unsigned int woodTexture = loadTexture("resources/textures/wood.jpg");
309

310
        debugDepthQuad.use();
311
        debugDepthQuad.setInt("depthMap", 0);
312

313
        float nearPlane = 1.0f;
314
        float farPlane = 7.5f;
315
        debugDepthQuad.setFloat("nearPlane", nearPlane);
316
        debugDepthQuad.setFloat("farPlane", farPlane);
317

318
        glm::vec3 lightPos(-2.0f, 4.0f, -1.0f);
319

320
        while (!glfwWindowShouldClose(window)) {
321
                float currentFrame = (float)glfwGetTime();
322
                deltaTime = currentFrame - lastFrame;
323
                lastFrame = currentFrame;
324

325
                processInput(window);
326

327
                glClearColor(0.1, 0.1, 0.1, 1.0);
328
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
329

330
                glm::mat4 lightProjection, lightView;
331
                glm::mat4 lightSpaceMatrix;
332
                lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, nearPlane, farPlane);
333
                lightView = glm::lookAt(lightPos, glm::vec3(0.0f), glm::vec3(0.0, 1.0, 0.0));
334
                lightSpaceMatrix = lightProjection * lightView;
335
                simpleDepthShader.use();
336
                simpleDepthShader.setMat4("lightSpaceMatrix", lightSpaceMatrix);
337

338
                glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
339
                glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
340
                glClear(GL_DEPTH_BUFFER_BIT);
341
                glActiveTexture(GL_TEXTURE0);
342
                glBindTexture(GL_TEXTURE_2D, woodTexture);
343
                renderScene(simpleDepthShader);
344
                glBindFramebuffer(GL_FRAMEBUFFER, 0);
345

346
                glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);
347
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
348

349
                debugDepthQuad.use();
350
                glActiveTexture(GL_TEXTURE0);
351
                glBindTexture(GL_TEXTURE_2D, depthMap);
352
                renderQuad();
353

354
                glfwSwapBuffers(window);
355
                glfwPollEvents();
356
        }
357
        glDeleteVertexArrays(1, &quadVAO);
358
        glDeleteBuffers(1, &quadVBO);
359
        glfwTerminate();
360
        return 0;
361
}

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
void main(){
9
        TexCoords=aTexCoords;
10
        gl_Position=vec4(aPos,1.0);
11
}
12

13
//渲染全屏四边形

1
//fragmentShader
2
#version 330 core
3
in vec2 TexCoords;
4
out vec4 FragColor;
5
uniform sampler2D depthMap;
6
uniform float near_plane;
7
uniform float far_plane;
8

9
float LinearizeDepth(float depth){//depth是窗口深度值0-1，硬件自动做了透视除法和归一化
10
        float z=depth*2.0-1.0;//逆归一化
11
        return (2.0*near_plane*far_plane)/(far_plane+near_plane-z*(far_plane-near_plane));//线性化
12
}
13

14
void main(){
15
        float depthValue=texture(depthMap,TexCoords).r;//texture采样结果是rgba四分量
16
        FragColor=vec4(vec3(depthValue),1.0);
17
}
18

19
//采样depthMap，把深度值转换为灰度图显示在屏幕上

1
//depthVertexShader
2
#version 330 core
3
layout (location=0) in vec3 aPos;
4

5
uniform mat4 lightSpaceMatrix;
6
uniform mat4 model;
7

8
void main(){
9
        gl_Position=lightSpaceMatrix*model*vec4(aPos,1.0);
10
}
11

12
//把所有顶点变换到光源空间，那么裁剪空间的z坐标就是顶点到光源的真实深度

1
//depthFragmentShader
2
#version 330 core
3
void main(){
4

5
}
6

7
//不输出颜色，深度由硬件自动写入

example2: 渲染阴影#

阴影渲染流程与深度贴图可视化流程的第一个 Pass 完全一致，二者核心区别仅体现在第二个 Pass。

公共 Pass1#

统一渲染整个场景，仅生成、写入深度贴图，不输出颜色，完成光源场景深度信息采集。

Pass2#

深度贴图可视化 Pass2#

渲染全屏四边形，采样深度贴图输出灰度画面，无需场景光照计算。

真实阴影渲染 Pass2#

不再渲染全屏四边形，而是重新渲染一次场景。该阶段不再只写入深度，而是正常写入场景颜色。因此顶点着色器与片元着色器需要额外承担光照计算、最终颜色输出的职责（常规光照计算逻辑已有教程详述，本文只聚焦阴影专属计算流程）。

顶点着色器任务#

将场景顶点坐标变换至光源裁剪空间，并将该裁剪空间坐标传递给片元着色器，为后续阴影采样计算提供数据。

片元着色器任务#

为获取深度贴图采样坐标，对传入的光源裁剪空间坐标执行透视除法，得到 NDC 空间坐标，再通过归一化换算得到屏幕坐标。处理后的数据作用：

坐标 XY 值：用于采样深度贴图
坐标 Z 值：当前片元相对于光源、位于 [0~1] 区间的真实深度值最终将深度贴图采样得到的深度值，与当前片元的光源深度值进行大小比对，计算出当前片元的阴影系数，完成阴影明暗计算。下面仅展示了main.cpp，第二个pass的顶点着色器和片元着色器。第一个渲染深度贴图的pass的顶点着色器和片元着色器与上面的例子保持一致。

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

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

9
#include <stb_image.h>
10
#include <iostream>
11
#include <vector>
12

13
#include <myShader.h>
14
#include <myCamera.h>
15
#include <Model.h>
16

17
using namespace std;
18

19
const unsigned int SCR_WIDTH = 800;
20
const unsigned int SCR_HEIGHT = 400;
21
bool gammaEnabled = false;
22
bool gammaKeyPressed = false;
23

24
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
25
float lastX = (float)SCR_WIDTH / 2.0f;
26
float lastY = (float)SCR_HEIGHT / 2.0f;
27
float deltaTime = 0.0f;
28
float lastFrame = 0.0f;
29
bool firstCamera = true;
30

31
unsigned int planeVAO;
32

33
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
34
        glViewport(0, 0, width, height);
35
}
36
void processInput(GLFWwindow* window) {
37
        if(glfwGetKey(window,GLFW_KEY_ESCAPE)==GLFW_PRESS){
38
                glfwSetWindowShouldClose(window, true);
39
        }
40
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
41
                camera.ProcessKeyboard(FORWARD, deltaTime);
42
        }
43
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
44
                camera.ProcessKeyboard(BACKWARD, deltaTime);
45
        }
46
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
47
                camera.ProcessKeyboard(LEFT, deltaTime);
48
        }
49
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
50
                camera.ProcessKeyboard(RIGHT, deltaTime);
51
        }
52
        if (glfwGetKey(window, GLFW_KEY_B) == GLFW_PRESS && !gammaKeyPressed) {
53
                gammaEnabled = !gammaEnabled;
54
                gammaKeyPressed = true;
55
        }
56
        if (glfwGetKey(window, GLFW_KEY_B) != GLFW_PRESS) {
57
                gammaKeyPressed = false;
58
        }
59
}
60
void processMovement(GLFWwindow* window, double xpos, double ypos) {
61
        if (firstCamera) {
62
                lastX = xpos;
63
                lastY = ypos;
64
                firstCamera = false;
65
        }
66
        float xoffset = xpos - lastX;
67
        float yoffset = lastY - ypos;
68
        lastX = xpos;
69
        lastY = ypos;
70
        camera.ProcessMouseMovement(xoffset, yoffset);
71
}
72
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
73
        camera.ProcessScroll(yoffset);
74
}
75
unsigned int loadTexture(const char* path) {
76
        unsigned int texture;
77
        glGenTextures(1, &texture);
78
        glBindTexture(GL_TEXTURE_2D, texture);
79

80
        int width, height, nrChannels;
81
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
82
        if (data) {
83
                GLenum dataFormat;
84
                if (nrChannels == 1) {
85
                        dataFormat = GL_RED;
86
                }
87
                else if (nrChannels == 3) {
88
                        dataFormat = GL_RGB;
89
                }
90
                else if (nrChannels == 4) {
91
                        dataFormat = GL_RGBA;
92
                }
93
                glTexImage2D(GL_TEXTURE_2D, 0, dataFormat, width, height, 0, dataFormat, GL_UNSIGNED_BYTE, data);
94
                glGenerateMipmap(GL_TEXTURE_2D);
95
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
96
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
97
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
98
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
99
        }
100
        else {
101
                cout << "Failed to load texture" << endl;
102
        }
103
        stbi_image_free(data);
104
        return texture;
105
}
106
unsigned int cubeVAO = 0;
107
unsigned int cubeVBO = 0;
108
void renderCube() {
109
        if (cubeVAO == 0) {//还没有创建VAO则创建，创建了就直接绑定
110
                float vertices[] = {
111
                        // back face
112
                        -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
113
                         1.0f,  1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 1.0f, 1.0f, // top-right
114
                         1.0f, -1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 1.0f, 0.0f, // bottom-right
115
                         1.0f,  1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 1.0f, 1.0f, // top-right
116
                        -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
117
                        -1.0f,  1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 1.0f, // top-left
118
                        // front face
119
                        -1.0f, -1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 0.0f, // bottom-left
120
                         1.0f, -1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f, 0.0f, // bottom-right
121
                         1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f, 1.0f, // top-right
122
                         1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f, 1.0f, // top-right
123
                        -1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 1.0f, // top-left
124
                        -1.0f, -1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 0.0f, // bottom-left
125
                        // left face
126
                        -1.0f,  1.0f,  1.0f, -1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-right
127
                        -1.0f,  1.0f, -1.0f, -1.0f,  0.0f,  0.0f, 1.0f, 1.0f, // top-left
128
                        -1.0f, -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-left
129
                        -1.0f, -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-left
130
                        -1.0f, -1.0f,  1.0f, -1.0f,  0.0f,  0.0f, 0.0f, 0.0f, // bottom-right
131
                        -1.0f,  1.0f,  1.0f, -1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-right
132
                        // right face
133
                         1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-left
134
                         1.0f, -1.0f, -1.0f,  1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-right
135
                         1.0f,  1.0f, -1.0f,  1.0f,  0.0f,  0.0f, 1.0f, 1.0f, // top-right
136
                         1.0f, -1.0f, -1.0f,  1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-right
137
                         1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-left
138
                         1.0f, -1.0f,  1.0f,  1.0f,  0.0f,  0.0f, 0.0f, 0.0f, // bottom-left
139
                         // bottom face
140
                         -1.0f, -1.0f, -1.0f,  0.0f, -1.0f,  0.0f, 0.0f, 1.0f, // top-right
141
                          1.0f, -1.0f, -1.0f,  0.0f, -1.0f,  0.0f, 1.0f, 1.0f, // top-left
142
                          1.0f, -1.0f,  1.0f,  0.0f, -1.0f,  0.0f, 1.0f, 0.0f, // bottom-left
143
                          1.0f, -1.0f,  1.0f,  0.0f, -1.0f,  0.0f, 1.0f, 0.0f, // bottom-left
144
                         -1.0f, -1.0f,  1.0f,  0.0f, -1.0f,  0.0f, 0.0f, 0.0f, // bottom-right
145
                         -1.0f, -1.0f, -1.0f,  0.0f, -1.0f,  0.0f, 0.0f, 1.0f, // top-right
146
                         // top face
147
                         -1.0f,  1.0f, -1.0f,  0.0f,  1.0f,  0.0f, 0.0f, 1.0f, // top-left
148
                          1.0f,  1.0f , 1.0f,  0.0f,  1.0f,  0.0f, 1.0f, 0.0f, // bottom-right
149
                          1.0f,  1.0f, -1.0f,  0.0f,  1.0f,  0.0f, 1.0f, 1.0f, // top-right
150
                          1.0f,  1.0f,  1.0f,  0.0f,  1.0f,  0.0f, 1.0f, 0.0f, // bottom-right
151
                         -1.0f,  1.0f, -1.0f,  0.0f,  1.0f,  0.0f, 0.0f, 1.0f, // top-left
152
                         -1.0f,  1.0f,  1.0f,  0.0f,  1.0f,  0.0f, 0.0f, 0.0f  // bottom-left
153
                };
154

155
                glGenVertexArrays(1, &cubeVAO);
156
                glBindVertexArray(cubeVAO);
157
                glGenBuffers(1, &cubeVBO);
158
                glBindBuffer(GL_ARRAY_BUFFER,cubeVBO);
159
                glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
160
                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
161
                glEnableVertexAttribArray(0);
162
                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
163
                glEnableVertexAttribArray(1);
164
                glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
165
                glEnableVertexAttribArray(2);
166
                glBindBuffer(GL_ARRAY_BUFFER, 0);
167
                glBindVertexArray(0);
168
        }
169
        glBindVertexArray(cubeVAO);
170
        glDrawArrays(GL_TRIANGLES, 0, 36);
171
        glBindVertexArray(0);
172
}
173
void renderScene(const Shader& shader) {
174
        //floor
175
        glm::mat4 model = glm::mat4(1.0);
176
        shader.setMat4("model", model);
177
        glBindVertexArray(planeVAO);
178
        glDrawArrays(GL_TRIANGLES, 0, 6);
179

180
        //cubes
181
        model = glm::mat4(1.0f);
182
        model = glm::translate(model, glm::vec3(0.0f, 1.5f, 0.0f));
183
        model = glm::scale(model, glm::vec3(0.5f));
184
        shader.setMat4("model", model);
185
        renderCube();
186
        model = glm::mat4(1.0f);
187
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 1.0f));
188
        model = glm::scale(model, glm::vec3(0.5f));
189
        shader.setMat4("model", model);
190
        renderCube();
191
        model = glm::mat4(1.0f);
192
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, 2.0f));
193
        model = glm::rotate(model, glm::radians(60.0f), glm::normalize(glm::vec3(1.0f, 0.0f, 1.0f)));//旋转轴必须是单位向量，如果向量长度不为1，旋转矩阵会附带缩放效果，模型会被拉伸
194
        model = glm::scale(model, glm::vec3(0.25f));
195
        shader.setMat4("model", model);
196
        renderCube();
197
}
198

199
int main() {
200
        glfwInit();
201
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
202
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
203
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
204

205
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
206
        if (window == NULL) {
207
                cout << "Failed to initialize GLFW" << endl;
208
                glfwTerminate();
209
                return -1;
210
        }
211
        glfwMakeContextCurrent(window);
212
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
213
        glfwSetScrollCallback(window, processScroll);
214
        glfwSetCursorPosCallback(window, processMovement);
215

216
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
217
                cout << "failed to load glad" << endl;
218
                glfwTerminate();
219
                return -1;
220
        }
221

222
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
223

224
        glEnable(GL_DEPTH_TEST);
225

226
        //地面平面
227
        float planeVertices[] = {
228
                // positions            // normals         // texcoords
229
                 25.0f, -0.5f,  25.0f,  0.0f, 1.0f, 0.0f,  25.0f,  0.0f,
230
                -25.0f, -0.5f,  25.0f,  0.0f, 1.0f, 0.0f,   0.0f,  0.0f,
231
                -25.0f, -0.5f, -25.0f,  0.0f, 1.0f, 0.0f,   0.0f, 25.0f,
232

233
                 25.0f, -0.5f,  25.0f,  0.0f, 1.0f, 0.0f,  25.0f,  0.0f,
234
                -25.0f, -0.5f, -25.0f,  0.0f, 1.0f, 0.0f,   0.0f, 25.0f,
235
                 25.0f, -0.5f, -25.0f,  0.0f, 1.0f, 0.0f,  25.0f, 25.0f
236
        };
237

238
        unsigned int planeVBO;
239
        glGenVertexArrays(1, &planeVAO);
240
        glGenBuffers(1, &planeVBO);
241
        glBindVertexArray(planeVAO);
242
        glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
243
        glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), planeVertices, GL_STATIC_DRAW);
244
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
245
        glEnableVertexAttribArray(0);
246
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
247
        glEnableVertexAttribArray(1);
248
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
249
        glEnableVertexAttribArray(2);
250
        glBindVertexArray(0);
251

252
        const unsigned int SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
253
        unsigned int depthMapFBO;
254
        glGenFramebuffers(1, &depthMapFBO);
255

256
        unsigned int depthMap;
257
        glGenTextures(1, &depthMap);
258
        glBindTexture(GL_TEXTURE_2D, depthMap);
259
        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
260
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
261
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
262
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
263
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
264

265
        glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
266
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap, 0);//最后一个参数是mipmap层级，我们只用纹理第0层即原始分辨率
267
        glDrawBuffer(GL_NONE);
268
        glReadBuffer(GL_NONE);
269
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
270

271
        //第一个Shader画场景，只写深度到深度图
272
        Shader simpleDepthShader("src/Shader/depthVertexShader.txt", "src/Shader/depthFragmentShader.txt");
273
        //第二个Shader画场景，从深度图采样
274
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
275

276
        unsigned int woodTexture = loadTexture("resources/textures/wood.jpg");
277

278
        shader.use();
279
        shader.setInt("depthMap", 0);
280
        shader.setInt("diffuseTexture", 1);
281
        glm::vec3 lightPos(-2.0f, 4.0f, -1.0f);
282
        shader.setVec3("lightPos", lightPos);
283

284
        float nearPlane = 1.0f;
285
        float farPlane = 7.5f;
286

287
        while (!glfwWindowShouldClose(window)) {
288
                float currentFrame = (float)glfwGetTime();
289
                deltaTime = currentFrame - lastFrame;
290
                lastFrame = currentFrame;
291

292
                processInput(window);
293

294
                glClearColor(0.1, 0.1, 0.1, 1.0);
295
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
296

297
                glm::mat4 lightProjection, lightView;
298
                glm::mat4 lightSpaceMatrix;
299
                lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, nearPlane, farPlane);
300
                lightView = glm::lookAt(lightPos, glm::vec3(0.0f), glm::vec3(0.0, 1.0, 0.0));
301
                lightSpaceMatrix = lightProjection * lightView;
302
                simpleDepthShader.use();
303
                simpleDepthShader.setMat4("lightSpaceMatrix", lightSpaceMatrix);
304

305
                glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
306
                glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
307
                glClear(GL_DEPTH_BUFFER_BIT);
308
                renderScene(simpleDepthShader);
309
                glBindFramebuffer(GL_FRAMEBUFFER, 0);
310

311
                glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);
312
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
313

314
                shader.use();
315
                glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
316
                shader.setMat4("projection", projection);
317
                glm::mat4 view = camera.GetCameraView();
318
                shader.setMat4("view", view);
319
                shader.setMat4("lightSpaceMatrix", lightSpaceMatrix);
320
                shader.setVec3("viewPos", camera.Position);
321
                glActiveTexture(GL_TEXTURE0);
322
                glBindTexture(GL_TEXTURE_2D, depthMap);
323
                glActiveTexture(GL_TEXTURE1);
324
                glBindTexture(GL_TEXTURE_2D, woodTexture);
325
                renderScene(shader);
326

327
                glfwSwapBuffers(window);
328
                glfwPollEvents();
329
        }
330
        glDeleteVertexArrays(1, &planeVAO);
331
        glDeleteBuffers(1, &planeVBO);
332
        glfwTerminate();
333
        return 0;
334
}

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

7
out VS_OUT{
8
        vec3 FragPos;
9
        vec3 Normal;
10
        vec2 TexCoords;
11
        vec4 FragPosLightSpace;
12
} vs_out;
13

14
uniform mat4 projection;
15
uniform mat4 view;
16
uniform mat4 model;
17
uniform mat4 lightSpaceMatrix;
18

19
void main(){
20
        vs_out.FragPos=vec3(model*vec4(aPos,1.0));
21
        vs_out.Normal=mat3(transpose(inverse(model)))*aNormal;
22
        vs_out.TexCoords=aTexCoords;
23
        vs_out.FragPosLightSpace=lightSpaceMatrix*vec4(vs_out.FragPos,1.0);
24
        gl_Position=projection*view*vec4(vs_out.FragPos,1.0);
25
}
26

27
//渲染场景，把所有顶点变换到光源空间，那么裁剪空间的z坐标就是顶点到光源的真实深度
28
//并向片元着色器传递一些光照计算、颜色计算的参数

1
//fragmentShader
2
#version 330 core
3
out vec4 FragColor;
4

5
in VS_OUT{
6
        vec3 FragPos;
7
        vec3 Normal;
8
        vec2 TexCoords;
9
        vec4 FragPosLightSpace;
10
} fs_in;
11

12
uniform sampler2D depthMap;
13
uniform sampler2D diffuseTexture;
14

15
uniform vec3 lightPos;
16
uniform vec3 viewPos;
17

18
float ShadowCalculation(vec4 fragPosLightSpace){
19
        //裁剪空间转NDC空间：做透视除法
20
        vec3 projCoords=fragPosLightSpace.xyz/fragPosLightSpace.w;
21
        //NDC空间转屏幕空间：归一化
22
        projCoords=projCoords*0.5+0.5;
23
        //使用屏幕空间坐标采样深度贴图
24
        float closestDepth=texture(depthMap,projCoords.xy).r;
25
        //获取当前片元的真实深度
26
        float currentDepth=projCoords.z;
27
        //两者进行比较，得到阴影系数
28
        float shadow=currentDepth > closestDepth?1.0:0.0;
29
        //shadow=1.0表示完全位于阴影中，shadow=0表示完全不位于阴影中
30
        return shadow;
31
}
32

33
void main(){
34
        vec3 color=texture(diffuseTexture,fs_in.TexCoords).rgb;
35
        vec3 normal=normalize(fs_in.Normal);
36
        vec3 lightColor=vec3(1.0);
37
        vec3 ambient=0.15*lightColor;
38
        vec3 lightDir=normalize(lightPos-fs_in.FragPos);
39
        float diff=max(dot(lightDir,normal),0.0);
40
        vec3 diffuse=diff*lightColor;
41

42
        vec3 viewDir=normalize(viewPos-fs_in.FragPos);
43
        float spec=0.0;
44
        vec3 halfDir=normalize(viewDir+lightDir);
45
        spec=pow(max(dot(halfDir,normal),0.0),64.0);
46
        vec3 specular=spec*lightColor;
47

48
        float shadow=ShadowCalculation(fs_in.FragPosLightSpace);
49
        vec3 lighting=ambient+(1-shadow)*(diffuse+specular)*color;
50

51
        FragColor=vec4(lighting,1.0);
52
}
53

54
//渲染场景，对每个片元，先采样深度贴图，得到当前点到光源的最近深度，与自己的深度比较

example3: 修复阴影痤疮#

可以看到渲染出的画面有非常多的摩尔纹。这些叫做shadow acne。产生的原因有两种：一是shadow map分辨率不够高，导致处于不同深度的相邻片元都采样到shadow map中的同一个texel，而一个texel只有一个深度，所以这些片元有的位于阴影中有的不位于阴影中，但是这些片元位于同一个表面，且由于相邻，他们应该都被照亮或都不被照亮。二是浮点误差，本是同一深度的相邻片元，由于计算精度误差，导致一个深度大于深度贴图中记录的深度，一个小于深度贴图中记录的深度，那么一个就位于阴影中，一个不位于阴影中，产生暗亮暗的条纹。解决上面问题的思路是增加一个bias，或是对表面真实深度加或是对shadow map中存储的深度加。假如是对shadow map中存储的深度加一个偏移量，即相当于对表面真实深度减一个偏移量，则物体深度更小了。 BQACAgUAAyEGAASHRsPbAAEWP7VqQQ0R4MyJ9opIzWvvJZhICrgwcQACWSMAAq3jCFYBhHqANcguUDwE.png

1
//fragmentShader
2
#version 330 core
3
out vec4 FragColor;
4

5
in VS_OUT{
6
        vec3 FragPos;
7
        vec3 Normal;
8
        vec2 TexCoords;
9
        vec4 FragPosLightSpace;
10
} fs_in;
11

12
uniform sampler2D depthMap;
13
uniform sampler2D diffuseTexture;
14

15
uniform vec3 lightPos;
16
uniform vec3 viewPos;
17

18
float ShadowCalculation(vec4 fragPosLightSpace){
19
        //裁剪空间转NDC空间：做透视除法
20
        vec3 projCoords=fragPosLightSpace.xyz/fragPosLightSpace.w;
21
        //NDC空间转屏幕空间：归一化
22
        projCoords=projCoords*0.5+0.5;
23
        //使用屏幕空间坐标采样深度贴图
24
        float closestDepth=texture(depthMap,projCoords.xy).r;
25
        //获取当前片元的真实深度
26
        float currentDepth=projCoords.z;
27
        //两者进行比较，得到阴影系数
28
        //添加偏移量以解决shadow acne
29
        float bias=0.005;
30
        float shadow=currentDepth-bias > closestDepth?1.0:0.0;
31
        //shadow=1.0表示完全位于阴影中，shadow=0表示完全不位于阴影中
32
        return shadow;
33
}
34

35
void main(){
36
        vec3 color=texture(diffuseTexture,fs_in.TexCoords).rgb;
37
        vec3 normal=normalize(fs_in.Normal);
38
        vec3 lightColor=vec3(1.0);
39
        vec3 ambient=0.15*lightColor;
40
        vec3 lightDir=normalize(lightPos-fs_in.FragPos);
41
        float diff=max(dot(lightDir,normal),0.0);
42
        vec3 diffuse=diff*lightColor;
43

44
        vec3 viewDir=normalize(viewPos-fs_in.FragPos);
45
        float spec=0.0;
46
        vec3 halfDir=normalize(viewDir+lightDir);
47
        spec=pow(max(dot(halfDir,normal),0.0),64.0);
48
        vec3 specular=spec*lightColor;
49

50
        float shadow=ShadowCalculation(fs_in.FragPosLightSpace);
51
        vec3 lighting=ambient+(1-shadow)*(diffuse+specular)*color;
52

53
        FragColor=vec4(lighting,1.0);
54
}
55

56
//渲染场景，对每个片元，先采样深度贴图，得到当前点到光源的最近深度，与自己的深度比较

但是在实际中，bias的大小和光源与表面的夹角相关，不能设置为定值。对于光源与表面垂直，同一表面上两个片元的深度差别很小，bias很小即可满足需求；对于光源和表面不垂直，光源照射方向越倾斜，同一表面上两个片元的深度差别越大，bias就需要越大。所以bias应该和dot(lightDir,normal)相关。因为各个场景中合适的偏差值都不尽相同，所以可能需要经过一番调整后才能找到合适的偏移值，但大多情况下，实际上就是增加偏移量直到所有失真都被移除的问题。 BQACAgUAAyEGAASHRsPbAAEWP7dqQQ1gblLEMSDMfTX9qplbQbZZ1AACWyMAAq3jCFYDs8vUzG0ITzwE.png

1
//fragmentShader
2
#version 330 core
3
out vec4 FragColor;
4

5
in VS_OUT{
6
        vec3 FragPos;
7
        vec3 Normal;
8
        vec2 TexCoords;
9
        vec4 FragPosLightSpace;
10
} fs_in;
11

12
uniform sampler2D depthMap;
13
uniform sampler2D diffuseTexture;
14

15
uniform vec3 lightPos;
16
uniform vec3 viewPos;
17

18
float ShadowCalculation(vec4 fragPosLightSpace,vec3 normal,vec3 lightDir){
19
        //裁剪空间转NDC空间：做透视除法
20
        vec3 projCoords=fragPosLightSpace.xyz/fragPosLightSpace.w;
21
        //NDC空间转屏幕空间：归一化
22
        projCoords=projCoords*0.5+0.5;
23
        //使用屏幕空间坐标采样深度贴图
24
        float closestDepth=texture(depthMap,projCoords.xy).r;
25
        //获取当前片元的真实深度
26
        float currentDepth=projCoords.z;
27
        //两者进行比较，得到阴影系数
28
        //添加偏移量以解决shadow acne
29
        float bias=max(0.05*(1.0-dot(normal,lightDir)),0.005);
30
        float shadow=currentDepth-bias > closestDepth?1.0:0.0;
31
        //shadow=1.0表示完全位于阴影中，shadow=0表示完全不位于阴影中
32
        return shadow;
33
}
34

35
void main(){
36
        vec3 color=texture(diffuseTexture,fs_in.TexCoords).rgb;
37
        vec3 normal=normalize(fs_in.Normal);
38
        vec3 lightColor=vec3(1.0);
39
        vec3 ambient=0.15*lightColor;
40
        vec3 lightDir=normalize(lightPos-fs_in.FragPos);
41
        float diff=max(dot(lightDir,normal),0.0);
42
        vec3 diffuse=diff*lightColor;
43

44
        vec3 viewDir=normalize(viewPos-fs_in.FragPos);
45
        float spec=0.0;
46
        vec3 halfDir=normalize(viewDir+lightDir);
47
        spec=pow(max(dot(halfDir,normal),0.0),64.0);
48
        vec3 specular=spec*lightColor;
49

50
        float shadow=ShadowCalculation(fs_in.FragPosLightSpace,normal,lightDir);
51
        vec3 lighting=ambient+(1-shadow)*(diffuse+specular)*color;
52

53
        FragColor=vec4(lighting,1.0);
54
}
55

56
//渲染场景，对每个片元，先采样深度贴图，得到当前点到光源的最近深度，与自己的深度比较

example4: 修复阴影悬浮#

但是bias过大会导致阴影悬浮，即物体和阴影分离了。解决方法是在渲染shadow map也就是第一个pass时，剔除物体的正面，只渲染背面。那么记录的也是背面的深度值，由于背面深度值比正面大，所以自然等价于给shadow map中的深度值加一个bias。这样就不再需要加很大的额外的bias，就减少了阴影悬浮的出现。此外，地板作为Plane，只有单面，所以不能开启剔除，不然会直接消失。所以第一个pass渲染深度贴图时，渲染物体时开启面剔除并剔除正面，渲染地板时关闭面剔除。且引入面剔除之后，bias可以设置的小一些。 BQACAgUAAyEGAASHRsPbAAEWP7lqQQ2zYEewk5Xlb_7Q6cJkIVqyzgACXSMAAq3jCFaZVKSE-vzVODwE.png

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

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

9
#include <stb_image.h>
10
#include <iostream>
11
#include <vector>
12

13
#include <myShader.h>
14
#include <myCamera.h>
15
#include <Model.h>
16

17
using namespace std;
18

19
const unsigned int SCR_WIDTH = 800;
20
const unsigned int SCR_HEIGHT = 400;
21
bool gammaEnabled = false;
22
bool gammaKeyPressed = false;
23

24
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
25
float lastX = (float)SCR_WIDTH / 2.0f;
26
float lastY = (float)SCR_HEIGHT / 2.0f;
27
float deltaTime = 0.0f;
28
float lastFrame = 0.0f;
29
bool firstCamera = true;
30

31
unsigned int planeVAO;
32

33
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
34
        glViewport(0, 0, width, height);
35
}
36
void processInput(GLFWwindow* window) {
37
        if(glfwGetKey(window,GLFW_KEY_ESCAPE)==GLFW_PRESS){
38
                glfwSetWindowShouldClose(window, true);
39
        }
40
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
41
                camera.ProcessKeyboard(FORWARD, deltaTime);
42
        }
43
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
44
                camera.ProcessKeyboard(BACKWARD, deltaTime);
45
        }
46
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
47
                camera.ProcessKeyboard(LEFT, deltaTime);
48
        }
49
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
50
                camera.ProcessKeyboard(RIGHT, deltaTime);
51
        }
52
        if (glfwGetKey(window, GLFW_KEY_B) == GLFW_PRESS && !gammaKeyPressed) {
53
                gammaEnabled = !gammaEnabled;
54
                gammaKeyPressed = true;
55
        }
56
        if (glfwGetKey(window, GLFW_KEY_B) != GLFW_PRESS) {
57
                gammaKeyPressed = false;
58
        }
59
}
60
void processMovement(GLFWwindow* window, double xpos, double ypos) {
61
        if (firstCamera) {
62
                lastX = xpos;
63
                lastY = ypos;
64
                firstCamera = false;
65
        }
66
        float xoffset = xpos - lastX;
67
        float yoffset = lastY - ypos;
68
        lastX = xpos;
69
        lastY = ypos;
70
        camera.ProcessMouseMovement(xoffset, yoffset);
71
}
72
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
73
        camera.ProcessScroll(yoffset);
74
}
75
unsigned int loadTexture(const char* path) {
76
        unsigned int texture;
77
        glGenTextures(1, &texture);
78
        glBindTexture(GL_TEXTURE_2D, texture);
79

80
        int width, height, nrChannels;
81
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
82
        if (data) {
83
                GLenum dataFormat;
84
                if (nrChannels == 1) {
85
                        dataFormat = GL_RED;
86
                }
87
                else if (nrChannels == 3) {
88
                        dataFormat = GL_RGB;
89
                }
90
                else if (nrChannels == 4) {
91
                        dataFormat = GL_RGBA;
92
                }
93
                glTexImage2D(GL_TEXTURE_2D, 0, dataFormat, width, height, 0, dataFormat, GL_UNSIGNED_BYTE, data);
94
                glGenerateMipmap(GL_TEXTURE_2D);
95
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
96
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
97
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
98
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
99
        }
100
        else {
101
                cout << "Failed to load texture" << endl;
102
        }
103
        stbi_image_free(data);
104
        return texture;
105
}
106
unsigned int cubeVAO = 0;
107
unsigned int cubeVBO = 0;
108
void renderCube() {
109
        if (cubeVAO == 0) {//还没有创建VAO则创建，创建了就直接绑定
110
                float vertices[] = {
111
                        // back face
112
                        -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
113
                         1.0f,  1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 1.0f, 1.0f, // top-right
114
                         1.0f, -1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 1.0f, 0.0f, // bottom-right
115
                         1.0f,  1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 1.0f, 1.0f, // top-right
116
                        -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 0.0f, // bottom-left
117
                        -1.0f,  1.0f, -1.0f,  0.0f,  0.0f, -1.0f, 0.0f, 1.0f, // top-left
118
                        // front face
119
                        -1.0f, -1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 0.0f, // bottom-left
120
                         1.0f, -1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f, 0.0f, // bottom-right
121
                         1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f, 1.0f, // top-right
122
                         1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f, 1.0f, // top-right
123
                        -1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 1.0f, // top-left
124
                        -1.0f, -1.0f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f, 0.0f, // bottom-left
125
                        // left face
126
                        -1.0f,  1.0f,  1.0f, -1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-right
127
                        -1.0f,  1.0f, -1.0f, -1.0f,  0.0f,  0.0f, 1.0f, 1.0f, // top-left
128
                        -1.0f, -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-left
129
                        -1.0f, -1.0f, -1.0f, -1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-left
130
                        -1.0f, -1.0f,  1.0f, -1.0f,  0.0f,  0.0f, 0.0f, 0.0f, // bottom-right
131
                        -1.0f,  1.0f,  1.0f, -1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-right
132
                        // right face
133
                         1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-left
134
                         1.0f, -1.0f, -1.0f,  1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-right
135
                         1.0f,  1.0f, -1.0f,  1.0f,  0.0f,  0.0f, 1.0f, 1.0f, // top-right
136
                         1.0f, -1.0f, -1.0f,  1.0f,  0.0f,  0.0f, 0.0f, 1.0f, // bottom-right
137
                         1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f, 1.0f, 0.0f, // top-left
138
                         1.0f, -1.0f,  1.0f,  1.0f,  0.0f,  0.0f, 0.0f, 0.0f, // bottom-left
139
                         // bottom face
140
                         -1.0f, -1.0f, -1.0f,  0.0f, -1.0f,  0.0f, 0.0f, 1.0f, // top-right
141
                          1.0f, -1.0f, -1.0f,  0.0f, -1.0f,  0.0f, 1.0f, 1.0f, // top-left
142
                          1.0f, -1.0f,  1.0f,  0.0f, -1.0f,  0.0f, 1.0f, 0.0f, // bottom-left
143
                          1.0f, -1.0f,  1.0f,  0.0f, -1.0f,  0.0f, 1.0f, 0.0f, // bottom-left
144
                         -1.0f, -1.0f,  1.0f,  0.0f, -1.0f,  0.0f, 0.0f, 0.0f, // bottom-right
145
                         -1.0f, -1.0f, -1.0f,  0.0f, -1.0f,  0.0f, 0.0f, 1.0f, // top-right
146
                         // top face
147
                         -1.0f,  1.0f, -1.0f,  0.0f,  1.0f,  0.0f, 0.0f, 1.0f, // top-left
148
                          1.0f,  1.0f , 1.0f,  0.0f,  1.0f,  0.0f, 1.0f, 0.0f, // bottom-right
149
                          1.0f,  1.0f, -1.0f,  0.0f,  1.0f,  0.0f, 1.0f, 1.0f, // top-right
150
                          1.0f,  1.0f,  1.0f,  0.0f,  1.0f,  0.0f, 1.0f, 0.0f, // bottom-right
151
                         -1.0f,  1.0f, -1.0f,  0.0f,  1.0f,  0.0f, 0.0f, 1.0f, // top-left
152
                         -1.0f,  1.0f,  1.0f,  0.0f,  1.0f,  0.0f, 0.0f, 0.0f  // bottom-left
153
                };
154

155
                glGenVertexArrays(1, &cubeVAO);
156
                glBindVertexArray(cubeVAO);
157
                glGenBuffers(1, &cubeVBO);
158
                glBindBuffer(GL_ARRAY_BUFFER,cubeVBO);
159
                glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
160
                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
161
                glEnableVertexAttribArray(0);
162
                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
163
                glEnableVertexAttribArray(1);
164
                glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
165
                glEnableVertexAttribArray(2);
166
                glBindBuffer(GL_ARRAY_BUFFER, 0);
167
                glBindVertexArray(0);
168
        }
169
        glBindVertexArray(cubeVAO);
170
        glDrawArrays(GL_TRIANGLES, 0, 36);
171
        glBindVertexArray(0);
172
}
173
void renderScene(const Shader& shader) {
174
        //floor
175
        glm::mat4 model = glm::mat4(1.0);
176
        shader.setMat4("model", model);
177
        glBindVertexArray(planeVAO);
178
        glDrawArrays(GL_TRIANGLES, 0, 6);
179

180
        //cubes
181
        model = glm::mat4(1.0f);
182
        model = glm::translate(model, glm::vec3(0.0f, 1.5f, 0.0f));
183
        model = glm::scale(model, glm::vec3(0.5f));
184
        shader.setMat4("model", model);
185
        renderCube();
186
        model = glm::mat4(1.0f);
187
        model = glm::translate(model, glm::vec3(2.0f, 0.0f, 1.0f));
188
        model = glm::scale(model, glm::vec3(0.5f));
189
        shader.setMat4("model", model);
190
        renderCube();
191
        model = glm::mat4(1.0f);
192
        model = glm::translate(model, glm::vec3(-1.0f, 0.0f, 2.0f));
193
        model = glm::rotate(model, glm::radians(60.0f), glm::normalize(glm::vec3(1.0f, 0.0f, 1.0f)));//旋转轴必须是单位向量，如果向量长度不为1，旋转矩阵会附带缩放效果，模型会被拉伸
194
        model = glm::scale(model, glm::vec3(0.25f));
195
        shader.setMat4("model", model);
196
        renderCube();
197
}
198

199
int main() {
200
        glfwInit();
201
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
202
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
203
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
204

205
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
206
        if (window == NULL) {
207
                cout << "Failed to initialize GLFW" << endl;
208
                glfwTerminate();
209
                return -1;
210
        }
211
        glfwMakeContextCurrent(window);
212
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
213
        glfwSetScrollCallback(window, processScroll);
214
        glfwSetCursorPosCallback(window, processMovement);
215

216
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
217
                cout << "failed to load glad" << endl;
218
                glfwTerminate();
219
                return -1;
220
        }
221

222
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
223

224
        glEnable(GL_DEPTH_TEST);
225

226
        //地面平面
227
        float planeVertices[] = {
228
                // positions            // normals         // texcoords
229
                 25.0f, -0.5f,  25.0f,  0.0f, 1.0f, 0.0f,  25.0f,  0.0f,
230
                -25.0f, -0.5f,  25.0f,  0.0f, 1.0f, 0.0f,   0.0f,  0.0f,
231
                -25.0f, -0.5f, -25.0f,  0.0f, 1.0f, 0.0f,   0.0f, 25.0f,
232

233
                 25.0f, -0.5f,  25.0f,  0.0f, 1.0f, 0.0f,  25.0f,  0.0f,
234
                -25.0f, -0.5f, -25.0f,  0.0f, 1.0f, 0.0f,   0.0f, 25.0f,
235
                 25.0f, -0.5f, -25.0f,  0.0f, 1.0f, 0.0f,  25.0f, 25.0f
236
        };
237

238
        unsigned int planeVBO;
239
        glGenVertexArrays(1, &planeVAO);
240
        glGenBuffers(1, &planeVBO);
241
        glBindVertexArray(planeVAO);
242
        glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
243
        glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), planeVertices, GL_STATIC_DRAW);
244
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
245
        glEnableVertexAttribArray(0);
246
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
247
        glEnableVertexAttribArray(1);
248
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
249
        glEnableVertexAttribArray(2);
250
        glBindVertexArray(0);
251

252
        const unsigned int SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
253
        unsigned int depthMapFBO;
254
        glGenFramebuffers(1, &depthMapFBO);
255

256
        unsigned int depthMap;
257
        glGenTextures(1, &depthMap);
258
        glBindTexture(GL_TEXTURE_2D, depthMap);
259
        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
260
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
261
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
262
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
263
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
264

265
        glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
266
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap, 0);//最后一个参数是mipmap层级，我们只用纹理第0层即原始分辨率
267
        glDrawBuffer(GL_NONE);
268
        glReadBuffer(GL_NONE);
269
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
270

271
        //第一个Shader画场景，只写深度到深度图
272
        Shader simpleDepthShader("src/Shader/depthVertexShader.txt", "src/Shader/depthFragmentShader.txt");
273
        //第二个Shader画场景，从深度图采样
274
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
275

276
        unsigned int woodTexture = loadTexture("resources/textures/wood.jpg");
277

278
        shader.use();
279
        shader.setInt("depthMap", 0);
280
        shader.setInt("diffuseTexture", 1);
281
        glm::vec3 lightPos(-2.0f, 4.0f, -1.0f);
282
        shader.setVec3("lightPos", lightPos);
283

284
        float nearPlane = 1.0f;
285
        float farPlane = 7.5f;
286

287
        while (!glfwWindowShouldClose(window)) {
288
                float currentFrame = (float)glfwGetTime();
289
                deltaTime = currentFrame - lastFrame;
290
                lastFrame = currentFrame;
291

292
                processInput(window);
293

294
                glClearColor(0.1, 0.1, 0.1, 1.0);
295
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
296

297
                glm::mat4 lightProjection, lightView;
298
                glm::mat4 lightSpaceMatrix;
299
                lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, nearPlane, farPlane);
300
                lightView = glm::lookAt(lightPos, glm::vec3(0.0f), glm::vec3(0.0, 1.0, 0.0));
301
                lightSpaceMatrix = lightProjection * lightView;
302
                simpleDepthShader.use();
303
                simpleDepthShader.setMat4("lightSpaceMatrix", lightSpaceMatrix);
304

305
                glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
306
                glEnable(GL_CULL_FACE);
307
                glCullFace(GL_FRONT);
308
                glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
309
                glClear(GL_DEPTH_BUFFER_BIT);
310
                //renderScene(simpleDepthShader);
311
                glm::mat4 model = glm::mat4(1.0f);
312
                model = glm::translate(model, glm::vec3(0.0f, 1.5f, 0.0f));
313
                model = glm::scale(model, glm::vec3(0.5f));
314
                simpleDepthShader.setMat4("model", model);
315
                renderCube();
316

317
                model = glm::mat4(1.0f);
318
                model = glm::translate(model, glm::vec3(2.0f, 0.0f, 1.0f));
319
                model = glm::scale(model, glm::vec3(0.5f));
320
                simpleDepthShader.setMat4("model", model);
321
                renderCube();
322

323
                model = glm::mat4(1.0f);
324
                model = glm::translate(model, glm::vec3(-1.0f, 0.0f, 2.0f));
325
                model = glm::rotate(model, glm::radians(60.0f), glm::normalize(glm::vec3(1.0f, 0.0f, 1.0f)));
326
                model = glm::scale(model, glm::vec3(0.25f));
327
                simpleDepthShader.setMat4("model", model);
328
                renderCube();
329

330
                glDisable(GL_CULL_FACE);
331
                model = glm::mat4(1.0);
332
                simpleDepthShader.setMat4("model", model);
333
                glBindVertexArray(planeVAO);
334
                glDrawArrays(GL_TRIANGLES, 0, 6);
335
                glBindFramebuffer(GL_FRAMEBUFFER, 0);
336

337
                glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);
338
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
339

340
                shader.use();
341
                glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
342
                shader.setMat4("projection", projection);
343
                glm::mat4 view = camera.GetCameraView();
344
                shader.setMat4("view", view);
345
                shader.setMat4("lightSpaceMatrix", lightSpaceMatrix);
346
                shader.setVec3("viewPos", camera.Position);
347
                glActiveTexture(GL_TEXTURE0);
348
                glBindTexture(GL_TEXTURE_2D, depthMap);
349
                glActiveTexture(GL_TEXTURE1);
350
                glBindTexture(GL_TEXTURE_2D, woodTexture);
351
                renderScene(shader);
352

353
                glfwSwapBuffers(window);
354
                glfwPollEvents();
355
        }
356
        glDeleteVertexArrays(1, &planeVAO);
357
        glDeleteBuffers(1, &planeVBO);
358
        glfwTerminate();
359
        return 0;
360
}

可以看到接近阴影面的物体仍然可能会出现不正确的效果。但一般来说，通过常规的偏移值调整就足以解决阴影偏移的问题了。（而且似乎我设置了面剔除来解决阴影悬浮之前，没有出现阴影悬浮（因为bias较小），但是设置之后，反而出现了阴影悬浮，我也不太清楚为什么）

example5: 渲染光源视锥体之外的区域#

在纹理环绕模式为GL_REPEAT的情况下，光源视锥体之外的片元会采样到shadow map中有效深度，进而产生阴影： BQACAgUAAyEGAASHRsPbAAEWP7xqQQ4GJt6Vq43Pjo_DkqyPBQZtfgACYCMAAq3jCFaSrgyi0VV2ZDwE.png

1
unsigned int depthMap;
2
glGenTextures(1, &depthMap);
3
glBindTexture(GL_TEXTURE_2D, depthMap);
4
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
5
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
6
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
7
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
8
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

我们可以将纹理环绕模式设置为GL_CLAMP_TO_BORDER来使得光源视锥体之外的片元总是处于光亮之中。 BQACAgUAAyEGAASHRsPbAAEWP75qQQ5AqQO-UR3QrAScugyPgD0m1QACYiMAAq3jCFb8wdEiWJkSEDwE.png

1
unsigned int depthMap;
2
glGenTextures(1, &depthMap);
3
glBindTexture(GL_TEXTURE_2D, depthMap);
4
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
5
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
6
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
7
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
8
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
9
float borderColor[] = { 1.0,1.0,1.0,1.0 };
10
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);

可以看到视野中仍然有一部分区域位于阴影中，这部分区域位于光源视锥体的远平面之外。CLAMP_TO_BORDER只能限制XY边界，这部分区域变黑是因为Z坐标超出了远平面，但XY坐标位于[0,1]之内，正常采样，只是采样得到的深度值总是比自身深度值要小，那么这部分区域总是位于阴影中。解决思路是把这部分的shadow分量直接置为0，表示这部分区域永远不会处于阴影中。在游戏开发过程中，不产生阴影的部分通常只会出现在远方，相比于此前让远方漆黑一片的做法，这种处理更合理一些。 BQACAgUAAyEGAASHRsPbAAEWP8hqQQ6LukouDgFHiMR9oaHFJhMYtAACbCMAAq3jCFaPWf_knqNj6jwE.png

1
//fragmentShader
2
float ShadowCalculation(vec4 fragPosLightSpace,vec3 normal,vec3 lightDir){
3
        //裁剪空间转NDC空间：做透视除法
4
        vec3 projCoords=fragPosLightSpace.xyz/fragPosLightSpace.w;
5
        //NDC空间转屏幕空间：归一化
6
        projCoords=projCoords*0.5+0.5;
7
        if(projCoords.z>1.0){
8
                return 0.0;
9
        }
10
        //使用屏幕空间坐标采样深度贴图
11
        float closestDepth=texture(depthMap,projCoords.xy).r;
12
        //获取当前片元的真实深度
13
        float currentDepth=projCoords.z;
14
        //两者进行比较，得到阴影系数
15
        //添加偏移量以解决shadow acne
16
        float bias=max(0.05*(1.0-dot(lightDir,normal)),0.005);
17
        float shadow=currentDepth-bias > closestDepth?1.0:0.0;
18
        //shadow=1.0表示完全位于阴影中，shadow=0表示完全不位于阴影中
19
        return shadow;
20
}

example6: PCF#

通过之前的渲染图片可以发现，阴影边缘的锯齿状较为严重。这是因为shadow map分辨率不够高，多个片元采样到同一个texel，采样到同一个深度，而texel是正方形的，所以渲染出来的阴影也是正方形的，即这一小块正方形内的片元采样到了同一个深度。解决办法就是PCF，即多次采样取平均。这里的平均不是深度平均而是阴影系数的平均，遍历当前片元所在texel的周围八个texel，取他们在shadow map中的深度，与当前片元的真实深度比较，这样得到了九个shadow系数（0表示完全不在阴影中，1表示完全在阴影中），取平均，得到0-1的shadow系数。

1
//fragmentShader
2
float ShadowCalculation(vec4 fragPosLightSpace,vec3 normal,vec3 lightDir){
3
        //裁剪空间转NDC空间：做透视除法
4
        vec3 projCoords=fragPosLightSpace.xyz/fragPosLightSpace.w;
5
        //NDC空间转屏幕空间：归一化
6
        projCoords=projCoords*0.5+0.5;
7
        if(projCoords.z>1.0){
8
                return 0.0;
9
        }
10
        //获取当前片元的真实深度
11
        float currentDepth=projCoords.z;
12
        //获取深度贴图中的深度值并添加bias
13
        float bias=max(0.05*(1.0-dot(lightDir,normal)),0.005);
14
        //PCF
15
        vec2 texelSize=1.0/textureSize(depthMap,0);//返回第0级shadow map的宽高，取倒数得到一个纹素的大小
16
        //遍历当前texel周围3*3个texel
17
        float shadow=0.0;
18
        for(int x=-1;x<=1;x++){
19
                for(int y=-1;y<=1;y++){
20
                        float pcfDepth=texture(depthMap,projCoords.xy+vec2(x,y)*texelSize).r;
21
                        shadow+=currentDepth-bias > pcfDepth?1.0:0.0;//shadow=1.0表示完全位于阴影中，shadow=0表示完全不位于阴影中
22
                }
23
        }
24
        shadow/=9.0;
25
        return shadow;
26
}

从较远的地方看，阴影边缘模糊了一些，锯齿没那么明显了： BQACAgUAAyEGAASHRsPbAAEWP8xqQQ7v-DNXwm56tqz4qhTaTYzs4wACcCMAAq3jCFa9yzOxMzduRTwE.png 从近的地方看，阴影边缘还是有一些不真实： BQACAgUAAyEGAASHRsPbAAEWP81qQQ8M51e3UdZBKrqTvYKH_MRT6gACcSMAAq3jCFYkrF3pn68BpzwE.png

example7: 透视投影的光源的阴影#

把lightProjection改成perspective BQACAgUAAyEGAASHRsPbAAEWP85qQQ842_caOxC5mNg4_4T4IYxx4QACciMAAq3jCFZPWFhu5vfjRTwE.png

1
lightProjection = glm::perspective(glm::radians(90.0f), 1.0f, nearPlane, farPlane);