光栅化与走样（锯齿）成因#

光栅化器以图元的所有顶点为输入，判断图元覆盖的片段。每个像素中心有一个采样点，当采样点位于图元内部，判定该像素被图元覆盖，否则没有覆盖，覆盖的像素将会进入下一阶段也就是片元着色器进行着色。由于屏幕分辨率不够高，图元边缘的像素呈现锯齿状，这就导致了走样（锯齿）问题。

MSAA 多重采样抗锯齿核心原理#

MSAA（多重采样）借鉴了 SSAA（超分辨率采样）的思路，将每个像素的一个中心采样点，转换为以特定图案排列的 4 个子采样点，通过子采样点判断像素的覆盖率。 MSAA 核心特性：每个像素只执行一次片元着色器，与子采样点数量无关。

三角形内部像素：4 个子采样点全部位于三角形内部。片元着色器运行后，输出的颜色会同步存储到全部 4 个子样本中，所有子样本颜色值完全一致。
三角形边缘像素：图元仅覆盖部分子采样点，最终颜色只会写入被覆盖的子样本中。最终屏幕像素颜色，由图元原色与所有子样本的颜色加权融合计算得出，实现边缘平滑、消除锯齿。

MSAA 深度、模板缓冲机制#

MSAA 不仅对颜色做多重采样，每一个子样本都会独立存储专属的深度值与模板值，并独立执行深度测试与模板测试。

子采样点的深度值，由图元顶点深度值插值得到；一个像素存储 4 份 float 深度数据，深度缓冲显存容量扩大 4 倍。
深度测试：逐个对每一个子采样点进行可见性判定。
模板测试：规则与深度测试一致，子样本独立判定。总结：深度缓冲、模板缓冲的显存占用大小，会随单像素子采样点数量成倍增加。

MSAA 离屏渲染前置条件#

如需灵活控制 MSAA、结合后处理效果，必须使用自定义帧缓冲（离屏渲染）。自定义帧缓冲包含纹理附件、渲染缓冲附件两类，用途不局限于 MSAA，还可实现泛光（Bloom）、模糊、调色、镜面反射等屏幕后处理效果。

MSAA 的两种实现方式与优缺点#

窗口自带 MSAA（非离屏）#

通过 glfwWindowHint 配置采样数，配合 glEnable(GL_MULTISAMPLE) 开启，场景直接渲染到屏幕默认帧缓冲。缺点：无法获取抗锯齿后的画面纹理用于后处理，属于全局强制抗锯齿，不支持局部开启/关闭 MSAA，灵活性极差。

离屏多重采样 FBO（主流方案）#

给自定义 FBO 绑定多重采样纹理附件或多重采样 RBO 渲染缓冲附件。核心逻辑：FBO 仅为挂载容器，本身不具备多重采样能力；多重采样效果依靠 API 中的 samples 参数，开辟多份显存、独立存储所有子样本数据实现。标准渲染流程：

将场景先渲染至多重采样离屏 FBO；
调用 glBlitFramebuffer，将多采样缓冲数据解析合并为普通单采样图像；
拷贝至普通自定义帧缓冲（用于后处理）或窗口默认帧缓冲（直接输出屏幕）。

MSAA 后处理二次锯齿问题与补偿方案#

当多重采样帧缓冲通过 glBlitFramebuffer 整合为单采样帧缓冲后，屏幕纹理会还原为单采样普通纹理。此时再执行边缘检测等后处理算法，会重新出现锯齿（像素非黑即白，无过渡边缘）。 补偿方案：对输出纹理进行模糊滤波，或自定义后处理抗锯齿算法修复边缘锯齿。

多重采样纹理的着色器采样规则#

多重采样纹理不能使用常规 texture() 函数采样，必须满足对应格式与语法规范：

纹理着色器类型需声明为 sampler2DMS（而非常规 sampler2D）；
使用 texelFetch 函数定点采样，可单独读取每一个子样本数据。采样语法示例：

1
// 读取当前纹理坐标下第4个子样本的颜色值
2
texelFetch(screenTextureMS, TexCoords, 3);

该方式可直接、独立访问所有子样本颜色数据，支持开发者自定义抗锯齿混合逻辑，手动控制子样本颜色融合规则，实现自定义 AA 算法。

example1: 使用MSAA抗锯齿#

关键在于：1.窗口创建前申请多重采样帧缓冲。普通窗口1个像素=1个颜色采样、1个深度采样；创建多重采样帧缓冲后，1个像素=N个颜色采样、N个深度采样。2.启用光栅化多重采样管线开关。开启之后，光栅器会在每个像素内生成N个子采样点

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

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

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

69
        int width, height, nrChannels;
70
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
71
        if (data) {
72
                GLenum format;
73
                if (nrChannels == 1) {
74
                        format = GL_RED;
75
                }
76
                else if (nrChannels == 3) {
77
                        format = GL_RGB;
78
                }
79
                else if (nrChannels == 4) {
80
                        format = GL_RGBA;
81
                }
82
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
83
                glGenerateMipmap(GL_TEXTURE_2D);
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 texture" << endl;
91
        }
92
        stbi_image_free(data);
93
        return texture;
94
}
95
unsigned int loadCubemap(vector<string> faces) {
96
        unsigned int texture;
97
        glGenTextures(1, &texture);
98
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
99

100
        int width, height, nrChannels;
101
        for (int i = 0; i < faces.size(); i++) {
102
                unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
103
                if(data) {
104
                        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
105
                }
106
                else {
107
                        cout << "failed to load cubemap" << endl;
108
                }
109
                stbi_image_free(data);
110
        }
111
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
112
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
113
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
114
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
115
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
116

117
        return texture;
118
}
119
int main() {
120
        glfwInit();
121
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
122
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
123
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
124
        glfwWindowHint(GLFW_SAMPLES, 4);//glfwWindowHint预创建配置项，告诉显卡驱动需要多重采样，把各个缓冲按4倍扩容
125

126
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
127
        if (window == NULL) {
128
                cout << "Failed to initialize GLFW" << endl;
129
                glfwTerminate();
130
                return -1;
131
        }
132
        glfwMakeContextCurrent(window);
133
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
134
        glfwSetScrollCallback(window, processScroll);
135
        glfwSetCursorPosCallback(window, processMovement);
136

137
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
138
                cout << "failed to load glad" << endl;
139
                glfwTerminate();
140
                return -1;
141
        }
142

143
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
144

145
        //stbi_set_flip_vertically_on_load(true);
146

147
        glEnable(GL_DEPTH_TEST);
148
        glEnable(GL_MULTISAMPLE);//开启光栅管线的多重采样计算逻辑
149

150
        float vertices[] = {
151
                // positions
152
                -0.5f, -0.5f, -0.5f,
153
                 0.5f, -0.5f, -0.5f,
154
                 0.5f,  0.5f, -0.5f,
155
                 0.5f,  0.5f, -0.5f,
156
                -0.5f,  0.5f, -0.5f,
157
                -0.5f, -0.5f, -0.5f,
158

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

166
                -0.5f,  0.5f,  0.5f,
167
                -0.5f,  0.5f, -0.5f,
168
                -0.5f, -0.5f, -0.5f,
169
                -0.5f, -0.5f, -0.5f,
170
                -0.5f, -0.5f,  0.5f,
171
                -0.5f,  0.5f,  0.5f,
172

173
                 0.5f,  0.5f,  0.5f,
174
                 0.5f,  0.5f, -0.5f,
175
                 0.5f, -0.5f, -0.5f,
176
                 0.5f, -0.5f, -0.5f,
177
                 0.5f, -0.5f,  0.5f,
178
                 0.5f,  0.5f,  0.5f,
179

180
                -0.5f, -0.5f, -0.5f,
181
                 0.5f, -0.5f, -0.5f,
182
                 0.5f, -0.5f,  0.5f,
183
                 0.5f, -0.5f,  0.5f,
184
                -0.5f, -0.5f,  0.5f,
185
                -0.5f, -0.5f, -0.5f,
186

187
                -0.5f,  0.5f, -0.5f,
188
                 0.5f,  0.5f, -0.5f,
189
                 0.5f,  0.5f,  0.5f,
190
                 0.5f,  0.5f,  0.5f,
191
                -0.5f,  0.5f,  0.5f,
192
                -0.5f,  0.5f, -0.5f
193
        };
194

195
        unsigned int cubeVAO, cubeVBO;
196
        glGenVertexArrays(1, &cubeVAO);
197
        glGenBuffers(1, &cubeVBO);
198
        glBindVertexArray(cubeVAO);
199
        glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
200
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
201
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
202
        glEnableVertexAttribArray(0);
203
        glBindVertexArray(0);
204

205
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
206

207
        while (!glfwWindowShouldClose(window)) {
208
                float currentFrame = (float)glfwGetTime();
209
                deltaTime = currentFrame - lastFrame;
210
                lastFrame = currentFrame;
211

212
                processInput(window);
213

214
                glClearColor(0.1, 0.1, 0.1, 1.0);
215
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
216

217
                shader.use();
218
                glm::mat4 model=glm::mat4(1.0f);
219
                glm::mat4 view = camera.GetCameraView();
220
                glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 1.0f, 100.0f);
221
                shader.setMat4("model", model);
222
                shader.setMat4("view", view);
223
                shader.setMat4("projection", projection);
224
                glBindVertexArray(cubeVAO);
225
                glDrawArrays(GL_TRIANGLES, 0, 36);
226
                glBindVertexArray(0);
227

228
                glfwSwapBuffers(window);
229
                glfwPollEvents();
230
        }
231

232
        glfwTerminate();
233
        return 0;
234
}

BQACAgUAAyEGAASHRsPbAAEWLf1qP4-R611P1pbK8fiZD-hF2h8KQAACsicAAk05AVZZwqrVl5QQJTwE.png

example2: 使用自定义帧缓冲实现MSAA#

这样的实现允许我们做离屏渲染。并且能够在已经抗锯齿的画面上做屏幕后处理。 首先定义了一个帧缓冲，为其附加上承载颜色缓冲的纹理附件和承载深度、模板缓冲的渲染缓冲附件。为这两个附件分别开启多重采样，这是通过调用特定API、改变纹理目标类型实现的。 其次定义了另一个中间帧缓冲，为其附加上承载颜色缓冲的纹理附件。将第一个多重帧缓冲的内容传递到这个中间帧缓冲中（已经是单重帧缓冲了），渲染的画面也就到了中间帧缓冲的纹理附件上。 最后渲染全屏四边形，从中间帧缓冲的纹理附件上的纹理采样。注意渲染全屏四边形的顶点着色器不需要变换矩阵，因为给的四边形的坐标已经是屏幕空间了。

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

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

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

69
        int width, height, nrChannels;
70
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
71
        if (data) {
72
                GLenum format;
73
                if (nrChannels == 1) {
74
                        format = GL_RED;
75
                }
76
                else if (nrChannels == 3) {
77
                        format = GL_RGB;
78
                }
79
                else if (nrChannels == 4) {
80
                        format = GL_RGBA;
81
                }
82
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
83
                glGenerateMipmap(GL_TEXTURE_2D);
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 texture" << endl;
91
        }
92
        stbi_image_free(data);
93
        return texture;
94
}
95
unsigned int loadCubemap(vector<string> faces) {
96
        unsigned int texture;
97
        glGenTextures(1, &texture);
98
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
99

100
        int width, height, nrChannels;
101
        for (int i = 0; i < faces.size(); i++) {
102
                unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
103
                if(data) {
104
                        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
105
                }
106
                else {
107
                        cout << "failed to load cubemap" << endl;
108
                }
109
                stbi_image_free(data);
110
        }
111
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
112
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
113
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
114
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
115
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
116

117
        return texture;
118
}
119
int main() {
120
        glfwInit();
121
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
122
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
123
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
124

125
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
126
        if (window == NULL) {
127
                cout << "Failed to initialize GLFW" << endl;
128
                glfwTerminate();
129
                return -1;
130
        }
131
        glfwMakeContextCurrent(window);
132
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
133
        glfwSetScrollCallback(window, processScroll);
134
        glfwSetCursorPosCallback(window, processMovement);
135

136
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
137
                cout << "failed to load glad" << endl;
138
                glfwTerminate();
139
                return -1;
140
        }
141

142
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
143

144
        //stbi_set_flip_vertically_on_load(true);
145

146
        glEnable(GL_DEPTH_TEST);
147

148
        float vertices[] = {
149
                // positions
150
                -0.5f, -0.5f, -0.5f,
151
                 0.5f, -0.5f, -0.5f,
152
                 0.5f,  0.5f, -0.5f,
153
                 0.5f,  0.5f, -0.5f,
154
                -0.5f,  0.5f, -0.5f,
155
                -0.5f, -0.5f, -0.5f,
156

157
                -0.5f, -0.5f,  0.5f,
158
                 0.5f, -0.5f,  0.5f,
159
                 0.5f,  0.5f,  0.5f,
160
                 0.5f,  0.5f,  0.5f,
161
                -0.5f,  0.5f,  0.5f,
162
                -0.5f, -0.5f,  0.5f,
163

164
                -0.5f,  0.5f,  0.5f,
165
                -0.5f,  0.5f, -0.5f,
166
                -0.5f, -0.5f, -0.5f,
167
                -0.5f, -0.5f, -0.5f,
168
                -0.5f, -0.5f,  0.5f,
169
                -0.5f,  0.5f,  0.5f,
170

171
                 0.5f,  0.5f,  0.5f,
172
                 0.5f,  0.5f, -0.5f,
173
                 0.5f, -0.5f, -0.5f,
174
                 0.5f, -0.5f, -0.5f,
175
                 0.5f, -0.5f,  0.5f,
176
                 0.5f,  0.5f,  0.5f,
177

178
                -0.5f, -0.5f, -0.5f,
179
                 0.5f, -0.5f, -0.5f,
180
                 0.5f, -0.5f,  0.5f,
181
                 0.5f, -0.5f,  0.5f,
182
                -0.5f, -0.5f,  0.5f,
183
                -0.5f, -0.5f, -0.5f,
184

185
                -0.5f,  0.5f, -0.5f,
186
                 0.5f,  0.5f, -0.5f,
187
                 0.5f,  0.5f,  0.5f,
188
                 0.5f,  0.5f,  0.5f,
189
                -0.5f,  0.5f,  0.5f,
190
                -0.5f,  0.5f, -0.5f
191
        };
192

193
        float quadVertices[] = {   // vertex attributes for a quad that fills the entire screen in Normalized Device Coordinates.
194
                // positions   // texCoords
195
                -1.0f,  1.0f,  0.0f, 1.0f,
196
                -1.0f, -1.0f,  0.0f, 0.0f,
197
                 1.0f, -1.0f,  1.0f, 0.0f,
198

199
                -1.0f,  1.0f,  0.0f, 1.0f,
200
                 1.0f, -1.0f,  1.0f, 0.0f,
201
                 1.0f,  1.0f,  1.0f, 1.0f
202
        };
203

204
        unsigned int cubeVAO, cubeVBO;
205
        glGenVertexArrays(1, &cubeVAO);
206
        glGenBuffers(1, &cubeVBO);
207
        glBindVertexArray(cubeVAO);
208
        glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
209
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
210
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
211
        glEnableVertexAttribArray(0);
212
        glBindVertexArray(0);
213

214
        unsigned int quadVAO, quadVBO;
215
        glGenVertexArrays(1, &quadVAO);
216
        glGenBuffers(1, &quadVBO);
217
        glBindVertexArray(quadVAO);
218
        glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
219
        glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW);
220
        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0);
221
        glEnableVertexAttribArray(0);
222
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)(2 * sizeof(float)));
223
        glEnableVertexAttribArray(1);
224
        glBindVertexArray(0);
225

226
        //创建自定义帧缓冲
227
        unsigned int framebuffer;
228
        glGenFramebuffers(1, &framebuffer);
229
        glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
230
        //创建纹理附件
231
        unsigned int textureColorBufferMultiSampled;
232
        glGenTextures(1, &textureColorBufferMultiSampled);
233
        glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textureColorBufferMultiSampled);
234
        glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGB, SCR_WIDTH, SCR_HEIGHT, GL_TRUE);//改方法名，改纹理目标
235
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, textureColorBufferMultiSampled, 0);
236
        //创建RBO附件
237
        unsigned int rbo;
238
        glGenRenderbuffers(1, &rbo);
239
        glBindRenderbuffer(GL_RENDERBUFFER, rbo);
240
        glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_DEPTH24_STENCIL8, SCR_WIDTH, SCR_HEIGHT);//改方法名
241
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo);
242
        if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
243
                cout << "ERROR::FRAMEBUFFER::Framebuffer is not complete!" << endl;
244
        }
245
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
246

247
        //创建另一帧缓冲
248
        unsigned int screenFramebuffer;
249
        glGenFramebuffers(1, &screenFramebuffer);
250
        glBindFramebuffer(GL_FRAMEBUFFER, screenFramebuffer);
251
        //创建纹理附件
252
        unsigned int screenTexture;
253
        glGenTextures(1, &screenTexture);
254
        glBindTexture(GL_TEXTURE_2D, screenTexture);
255
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
256
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
257
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
258
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, screenTexture, 0);
259

260
        if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
261
                cout << "ERROR::FRAMEBUFFER::Screen framebuffer is not complete!" << endl;
262
        }
263
        glBindTexture(GL_TEXTURE_2D, 0);
264
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
265

266
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
267
        Shader screenShader("src/Shader/screenVertexShader.txt", "src/Shader/screenFragmentShader.txt");
268

269
        screenShader.setInt("screenTexture", 0);
270

271
        while (!glfwWindowShouldClose(window)) {
272
                float currentFrame = (float)glfwGetTime();
273
                deltaTime = currentFrame - lastFrame;
274
                lastFrame = currentFrame;
275

276
                processInput(window);
277

278
                glClearColor(0.1, 0.1, 0.1, 1.0);
279
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
280

281
                //first pass:把图像渲染到多重采样帧缓冲
282
                glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
283
                glClearColor(0.1f, 0.1f, 0.1f, 1.0f);//为什么需要设置这个
284
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//为什么需要清空缓冲？
285
                glEnable(GL_DEPTH_TEST);
286

287
                shader.use();
288
                glm::mat4 model=glm::mat4(1.0f);
289
                glm::mat4 view = camera.GetCameraView();
290
                glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 1.0f, 100.0f);
291
                shader.setMat4("model", model);
292
                shader.setMat4("view", view);
293
                shader.setMat4("projection", projection);
294
                glBindVertexArray(cubeVAO);
295
                glDrawArrays(GL_TRIANGLES, 0, 36);
296
                glBindVertexArray(0);
297

298
                //second pass: 把多重采样帧缓冲上的画面整合到自定义帧缓冲中
299
                glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
300
                glBindFramebuffer(GL_DRAW_FRAMEBUFFER, screenFramebuffer);
301
                glBlitFramebuffer(0, 0, SCR_WIDTH, SCR_HEIGHT, 0, 0, SCR_WIDTH, SCR_HEIGHT, GL_COLOR_BUFFER_BIT, GL_NEAREST);
302
                //各个参数分别是源缓冲的画面矩形，目标缓冲的画面矩形；要拷贝哪些参数；缩放时的过滤模式
303

304
                //third pass: 使用自定义帧缓冲中的纹理渲染渲染全屏四边形
305
                glBindFramebuffer(GL_FRAMEBUFFER, 0);
306
                glClearColor(1.0f, 1.0f, 1.0f, 1.0f);//为什么需要清屏，且改变了清屏颜色
307
                glClear(GL_COLOR_BUFFER_BIT);//为什么这里不清楚深度缓冲？
308
                glDisable(GL_DEPTH_TEST);
309

310
                screenShader.use();
311
                glActiveTexture(GL_TEXTURE0);
312
                glBindTexture(GL_TEXTURE_2D, screenTexture);
313
                glBindVertexArray(quadVAO);
314
                glDrawArrays(GL_TRIANGLES, 0, 6);
315
                glBindVertexArray(0);
316

317
                glfwSwapBuffers(window);
318
                glfwPollEvents();
319
        }
320

321
        glfwTerminate();
322
        return 0;
323
}

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

5
uniform mat4 model;
6
uniform mat4 view;
7
uniform mat4 projection;
8

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

1
//fragmentShader
2
#version 330 core
3
out vec4 FragColor;
4
void main(){
5
        FragColor=vec4(0.0,1.0,0.0,1.0);
6
}

1
//screenVertexShader
2
#version 330 core
3

4
layout (location = 0) in vec2 aPos;
5
layout (location = 1) in vec2 aTexCoords;
6

7
out vec2 TexCoords;
8

9
void main(){
10
        gl_Position=vec4(aPos,0.0,1.0);
11
        TexCoords=aTexCoords;
12
}

1
//screenFragmentShader
2
#version 330 core
3
in vec2 TexCoords;
4
out vec4 FragColor;
5
uniform sampler2D screenTexture;
6

7
void main(){
8
        vec3 col = texture(screenTexture, TexCoords).rgb;
9
    float grayscale = 0.2126 * col.r + 0.7152 * col.g + 0.0722 * col.b;
10
    FragColor = vec4(vec3(grayscale), 1.0);
11
}

BQACAgUAAyEGAASHRsPbAAEWLglqP5AaY8RhTt9Hoi6-hGH0LkY8VgACvCcAAk05AVYwpnLjl416AjwE.png