模板缓冲基本原理#

模板缓冲为8位整型缓冲区，每个像素对应一个模板数值。开发者可自定义写入任意模板值，片段渲染时，GPU根据当前片段模板值与缓冲存储模板值的比对规则，选择性保留或丢弃当前片元，实现区域遮罩、轮廓描边、镜面特效等自定义渲染效果。

模板缓冲创建规则#

OpenGL 规范要求窗口必须配套模板缓冲资源。
GLFW 会自动创建模板缓冲，开发者无需手动申请、创建显存资源。
部分其他窗口库不自动创建，需要开发者手动配置并创建模板缓冲。

模板测试流程#

模板测试核心逻辑：先写入模板遮罩，再根据遮罩筛选片段，标准流程如下：

开启模板缓冲写入权限；
渲染遮罩物体，根据规则更新模板缓冲对应像素的模板值；
关闭模板缓冲写入权限，锁定遮罩数据；
渲染其他物体，根据已固定的模板缓冲数值，筛选、丢弃或保留指定片元，实现局部渲染控制。

模板测试执行顺序#

渲染管线顺序：模板测试 → 深度测试，模板测试优先执行。

模板测试常用指令#

1
// 开启模板测试（默认关闭）
2
glEnable(GL_STENCIL_TEST);
3

4
// 清空模板缓冲（帧渲染前搭配颜色、深度缓冲一起清空）
5
glClear(GL_STENCIL_BUFFER_BIT);
6

7
// 开启模板缓冲写入（允许修改模板值）
8
glStencilMask(0xff);
9

10
// 禁用模板缓冲写入（锁定模板值，只读）
11
glStencilMask(0x00);

掩码原理：glStencilMask 基于位运算生效，传入的掩码值会与即将写入缓冲的模板值进行 AND 与运算，控制模板值写入权限。

模板比对函数 glStencilFunc#

函数原型参数#

glStencilFunc(func, ref, mask)

func：比较规则，定义当前片元模板值与参考值的比对逻辑（大于、小于、等于、不等于等）。
ref：参考值，用于和模板缓冲内存储数值做比对的基准数值。
mask：运算掩码，会分别对缓冲模板值和参考值做位与运算，运算结果再执行 func 比对逻辑。

模板更新规则 glStencilOp#

函数原型参数#

glStencilOp(sfail, dpfail, dppass)

sfail：模板测试失败时的更新策略。
dpfail：模板测试通过，但深度测试失败时的更新策略。
dppass：模板测试通过，且深度测试通过时的更新策略。三个参数分别对应三种渲染判定结果下，模板缓冲的更新策略：
sfail：模板测试失败
dpfail：模板测试通过，但深度测试失败
dppass：模板测试通过，且深度测试通过

模板更新可选行为#

GL_KEEP：保留当前模板值，不做修改
GL_ZERO：将当前模板值清零
GL_REPLACE：使用 ref 参考值替换当前模板值
GL_INCR：模板值小于最大值则自增1，达到最大值后不再变化
GL_INCR_WRAP：模板值自增1，超出最大值后归零循环
GL_DECR：模板值大于最小值则自减1，达到最小值后不再变化
GL_DECR_WRAP：模板值自减1，小于0后设为最大值循环
GL_INVERT：对当前模板值按位翻转

example1: 物体轮廓#

实现思路：启用模板写入；设置模板函数以及模板写入规则：模板函数设为GL_ALWAYS（保证物体所覆盖的所有片元都通过模板测试，都能写入模板缓冲），并且渲染时将1写入模板缓冲；渲染物体；禁用模板写入以及深度测试（禁用深度测试的原因是：当一个物体显示轮廓时，表明它是被选中的，那么就不应该有其他的物体遮挡它，包括它周围的轮廓）；将物体放大一些；使用不同的片段着色器，使用轮廓颜色渲染放大后的物体，且当且仅当模板值不等于1的时候才绘制（这样就只用轮廓颜色绘制了放大的部分）；再次启用模板写入和深度测试（还原，避免修改后续的绘制）。流程：初始化全局状态：开启深度测试、设置深度测试函数（GL_LESS）、开启模板测试、设置模板测试函数（初始时模板缓冲中的值都为0，而初始时所有物体都想要绘制，比如不需要描边的平面，所以他们要想通过模板测试，模板测试的条件必须是模板值！=1）、设置模板写入规则（只有当深度测试和模板测试都通过时才写入）；绘制平面，关闭模板写入；绘制物体，first pass中正常绘制（设置模板测试函数，所有片元都通过模板测试）并写入模板（则有物体存在的地方，模板值都变成1），second pass中绘制轮廓，把物体放大一些，关闭模板写入，设置模板测试函数（当且仅当模板值不等于1时绘制，这样绘制的就是放大的部分）并关闭深度测试。 BQACAgUAAyEGAASHRsPbAAEWKzJqP2qVjJZjgHCvctcewI9AEvJW1gACgyQAAk05AVY7PnvealZIaDwE.png

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

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

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

14
#include <iostream>
15

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

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

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

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

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

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

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

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

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

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

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

115
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
116

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

123
        stbi_set_flip_vertically_on_load(true);
124

125
        glEnable(GL_DEPTH_TEST);
126
        glDepthFunc(GL_LESS);
127
        glEnable(GL_STENCIL_TEST);
128
        glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
129
        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);//定义模板写入的规则
130

131
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
132
        Shader shaderSingleColor("src/Shader/vertexShader.txt", "src/Shader/shaderSingleColor.txt");
133
        float cubeVertices[] = {
134
                -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
135
                 0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
136
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
137
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
138
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
139
                -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
140

141
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
142
                 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
143
                 0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
144
                 0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
145
                -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
146
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
147

148
                -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
149
                -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
150
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
151
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
152
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
153
                -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
154

155
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
156
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
157
                 0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
158
                 0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
159
                 0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
160
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
161

162
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
163
                 0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
164
                 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
165
                 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
166
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
167
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
168

169
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
170
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
171
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
172
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
173
                -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
174
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
175
        };
176

177
        float planeVertices[] = {
178
                5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
179
                -5.0f, -0.5f,  5.0f,  0.0f, 0.0f,
180
                -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
181

182
                 5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
183
                -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
184
                 5.0f, -0.5f, -5.0f,  2.0f, 2.0f
185
        };
186

187
        unsigned int cubeVAO, cubeVBO;
188
        glGenVertexArrays(1, &cubeVAO);
189
        glGenBuffers(1, &cubeVBO);
190

191
        glBindVertexArray(cubeVAO);
192
        glBindBuffer(GL_ARRAY_BUFFER,cubeVBO);
193
        glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), cubeVertices, GL_STATIC_DRAW);
194

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

198
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
199
        glEnableVertexAttribArray(1);
200

201
        glBindVertexArray(0);
202

203
        unsigned int planeVAO, planeVBO;
204
        glGenVertexArrays(1, &planeVAO);
205
        glGenBuffers(1, &planeVBO);
206

207
        glBindVertexArray(planeVAO);
208
        glBindBuffer(GL_ARRAY_BUFFER,planeVBO);
209
        glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), planeVertices, GL_STATIC_DRAW);
210

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

214
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
215
        glEnableVertexAttribArray(1);
216

217
        glBindVertexArray(0);
218

219
        unsigned int cubeTexture = loadTexture("resources/textures/marble.jpg");
220
        unsigned int floorTexture = loadTexture("resources/textures/metal.jpg");
221

222
        shader.use();
223
        shader.setInt("texture1", 0);
224
        shader.setInt("texture2", 1);
225

226
        while (!glfwWindowShouldClose(window)) {
227
                float currentFrame = (float)glfwGetTime();
228
                deltaTime = currentFrame - lastFrame;
229
                lastFrame = currentFrame;
230

231
                processInput(window);
232

233
                glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
234
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
235

236
                shader.use();
237
                //绘制平面
238
                glStencilMask(0x00);//平面不需要轮廓，所以关闭模板测试
239

240
                glBindVertexArray(planeVAO);
241
                glActiveTexture(GL_TEXTURE1);
242
                glBindTexture(GL_TEXTURE_2D, floorTexture);
243
                shader.setInt("useFloorTex", 1);
244
                shader.setMatrix("model", glm::mat4(1.0f));
245
                glDrawArrays(GL_TRIANGLES, 0, 6);
246
                glBindVertexArray(0);
247

248
                //绘制箱子
249
                //1st. render pass,draw object as normal,writing to the stencil buffer
250
                glStencilFunc(GL_ALWAYS, 1, 0xFF);
251
                glStencilMask(0xFF);
252

253
                glm::mat4 model = glm::mat4(1.0f);
254
                glm::mat4 view = camera.GetCameraView();
255
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
256
                shader.setMatrix("view", view);
257
                shader.setMatrix("project", project);
258

259
                glBindVertexArray(cubeVAO);
260
                glActiveTexture(GL_TEXTURE0);
261
                glBindTexture(GL_TEXTURE_2D, cubeTexture);
262
                shader.setInt("useFloorTex", 0);
263
                model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
264
                shader.setMatrix("model", model);
265
                glDrawArrays(GL_TRIANGLES, 0, 36);
266

267
                model = glm::mat4(1.0f);
268
                model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
269
                shader.setMatrix("model", model);
270
                glDrawArrays(GL_TRIANGLES, 0, 36);
271

272
                //绘制轮廓线（即放大后的箱子，且通过模板测试）
273
                //2nd. render pass:now draw slightly scaled versions of the objects
274
                //disable stencil writing and depth test
275
                shaderSingleColor.use();
276
                glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
277
                glStencilMask(0x00);
278
                glDisable(GL_DEPTH_TEST);
279

280
                model = glm::mat4(1.0f);
281
                model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
282
                model = glm::scale(model, glm::vec3(1.1f));
283
                shaderSingleColor.setMatrix("model", model);
284
                shaderSingleColor.setMatrix("view", view);
285
                shaderSingleColor.setMatrix("project", project);
286
                glDrawArrays(GL_TRIANGLES, 0, 36);
287

288
                model = glm::mat4(1.0f);
289
                model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
290
                model = glm::scale(model, glm::vec3(1.1f));
291
                shaderSingleColor.setMatrix("model", model);
292
                glDrawArrays(GL_TRIANGLES, 0, 36);
293

294
                //绘制完毕，还原状态
295
                glStencilMask(0xFF);
296
                glStencilFunc(GL_ALWAYS, 0, 0xFF);
297
                glEnable(GL_DEPTH_TEST);
298

299
                glBindVertexArray(0);
300

301
                glfwSwapBuffers(window);
302
                glfwPollEvents();
303
        }
304
        glDeleteVertexArrays(1, &cubeVAO);
305
        glDeleteVertexArrays(1, &planeVAO);
306
        glDeleteBuffers(1, &cubeVBO);
307
        glDeleteBuffers(1, &planeVBO);
308

309
        glfwTerminate();
310
        return 0;
311
}

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

6
out vec2 TexCoords;
7

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

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

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

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

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

对之前的背包模型进行描边（即把物体轮廓与自定义模型类结合起来） 思路：拆解物体轮廓的实现，对一个待添加轮廓的模型来说，无非是两次绘制，第一次使用正常着色器绘制正常大小的模型，第二次使用轮廓着色器绘制放大一些的模型。而自定义模型类已经提供了Draw函数，允许指定绘制用的着色器来绘制一个模型。所以上述两次绘制的操作就可以通过直接调用这个函数，并传入不同的着色器实现。那么我们要做的（或者说比较麻烦的）是如何做好这两次绘制之间状态设置的工作。首先是全局状态设置；然后是第一次绘制前状态的设置（设置stencil buffer写入规则、开启stencil buffer的写入）；第一次绘制完，需要修改模型model矩阵，将其放大一丢丢，然后进行状态设置（关闭stencil buffer的写入，设置stencil test的规则、关闭深度测试）；最后是第二次绘制完，需要恢复状态（开启深度测试、重置stencil buffer写入规则、开启stencil buffer的写入）。 BQACAgUAAyEGAASHRsPbAAEWKzxqP2sOfiRUx0jEVy0kzNUw9ZxNPAACkCQAAk05AVbetsoxhh2ggjwE.png

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

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

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

14
#include <iostream>
15

16
const unsigned int SCR_WIDTH = 800;
17
const unsigned int SCR_HEIGHT = 400;
18
#define NR_POINT_LIGHTS 2
19

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

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

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

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

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

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

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

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

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

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

116
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
117

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

124
        stbi_set_flip_vertically_on_load(true);
125

126
        glEnable(GL_DEPTH_TEST);
127
        glDepthFunc(GL_LESS);
128
        glEnable(GL_STENCIL_TEST);
129
        glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
130
        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
131

132
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
133
        Shader shaderSingleColor("src/Shader/vertexShader.txt", "src/Shader/shaderSingleColor.txt");
134
        Shader lightShader("src/Shader/vertexShader.txt", "src/Shader/lightFragmentShader.txt");
135

136
        Model myModel("resources/objects/backpack/backpack.obj");
137

138
        //光源立方体的顶点信息
139
        float vertices[] = {
140
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,
141
                 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  0.0f,
142
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
143
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f,  1.0f,
144
                -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  1.0f,
145
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f,  0.0f,
146

147
                -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,
148
                 0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  0.0f,
149
                 0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
150
                 0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
151
                -0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  1.0f,
152
                -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,
153

154
                -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
155
                -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  1.0f,
156
                -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
157
                -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
158
                -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  0.0f,  0.0f,
159
                -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
160

161
                 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
162
                 0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  1.0f,
163
                 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
164
                 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
165
                 0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  0.0f,  0.0f,
166
                 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,
167

168
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  1.0f,
169
                 0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  1.0f,
170
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  0.0f,
171
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f,  0.0f,
172
                -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  0.0f,
173
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f,  1.0f,
174

175
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,
176
                 0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  1.0f,
177
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
178
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,
179
                -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  0.0f,
180
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f
181
        };
182

183
        //光源立方体的位置信息
184
        glm::vec3 pointLightPositions[] = {
185
                glm::vec3(-2.0f,0.2f,0.5f),
186
                glm::vec3(3.0f,0.2f,-0.5f)
187
        };
188

189
        unsigned int lightVAO, lightVBO;
190
        glGenVertexArrays(1, &lightVAO);
191
        glGenBuffers(1, &lightVBO);
192

193
        glBindVertexArray(lightVAO);
194
        glBindBuffer(GL_ARRAY_BUFFER, lightVBO);
195

196
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
197
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
198
        glEnableVertexAttribArray(0);
199

200
        glBindVertexArray(0);
201

202
        shader.use();
203
        shader.setFloat("material.shininess", 32.0f);
204

205
        shader.setVec3("dirLight.direction", glm::vec3(-0.2f, -1.0f, -0.3f));
206
        shader.setVec3("dirLight.ambient", glm::vec3(0.05f, 0.05f, 0.05f));
207
        shader.setVec3("dirLight.diffuse", glm::vec3(0.4f, 0.4f, 0.4f));
208
        shader.setVec3("dirLight.specular", glm::vec3(0.5f, 0.5f, 0.5f));
209

210
        shader.setVec3("pointLights[0].position", pointLightPositions[0]);
211
        shader.setVec3("pointLights[0].ambient", glm::vec3(0.5f));
212
        shader.setVec3("pointLights[0].diffuse", glm::vec3(0.8f));
213
        shader.setVec3("pointLights[0].specular", glm::vec3(1.0f));
214
        shader.setFloat("pointLights[0].constant", 1.0f);
215
        shader.setFloat("pointLights[0].linear", 0.09f);
216
        shader.setFloat("pointLights[0].quadratic", 0.32f);
217

218
        shader.setVec3("pointLights[1].position", pointLightPositions[1]);
219
        shader.setVec3("pointLights[1].ambient", glm::vec3(0.5f));
220
        shader.setVec3("pointLights[1].diffuse", glm::vec3(0.8f));
221
        shader.setVec3("pointLights[1].specular", glm::vec3(1.0f));
222
        shader.setFloat("pointLights[1].constant", 1.0f);
223
        shader.setFloat("pointLights[1].linear", 0.09f);
224
        shader.setFloat("pointLights[1].quadratic", 0.32f);
225

226
        while (!glfwWindowShouldClose(window)) {
227
                float currentFrame = (float)glfwGetTime();
228
                deltaTime = currentFrame - lastFrame;
229
                lastFrame = currentFrame;
230

231
                processInput(window);
232

233
                glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
234
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
235

236
                //绘制物体
237
                //first pass
238
                glStencilFunc(GL_ALWAYS, 1, 0xFF);
239
                glStencilMask(0xFF);
240

241
                shader.use();
242
                glm::mat4 model;
243
                model = glm::translate(model, glm::vec3(0.0f));
244
                model = glm::scale(model, glm::vec3(1.0f));
245
                shader.setMatrix("model", model);
246
                glm::mat4 view = camera.GetCameraView();
247
                shader.setMatrix("view", view);
248
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
249
                shader.setMatrix("project", project);
250
                shader.setVec3("viewPos", camera.Position);
251
                myModel.Draw(shader);
252

253
                //second pass
254
                glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
255
                glStencilMask(0x00);
256
                glDisable(GL_DEPTH_TEST);
257

258
                shaderSingleColor.use();
259
                model = glm::mat4(1.0f);
260
                model = glm::translate(model, glm::vec3(0.0f));
261
                model = glm::scale(model, glm::vec3(1.1f));
262
                shaderSingleColor.setMatrix("model", model);
263
                shaderSingleColor.setMatrix("view", view);
264
                shaderSingleColor.setMatrix("project", project);
265
                myModel.Draw(shaderSingleColor);
266

267
                glStencilMask(0xFF);
268
                glStencilFunc(GL_ALWAYS, 0, 0xFF);
269
                glEnable(GL_DEPTH_TEST);
270

271
                //绘制光源立方体
272
                /*lightShader.use();
273
                glBindVertexArray(lightVAO);
274
                for (int i = 0; i < NR_POINT_LIGHTS; i++) {
275
                        model = glm::mat4(1.0f);
276
                        model = glm::translate(model, pointLightPositions[i]);
277
                        model = glm::scale(model, glm::vec3(0.5f));
278
                        lightShader.setMatrix("model", model);
279

280
                        lightShader.setMatrix("view", view);
281
                        lightShader.setMatrix("project", project);
282

283
                        glDrawArrays(GL_TRIANGLES, 0, 36);
284
                }
285
                glBindVertexArray(0);*/
286

287
                glfwSwapBuffers(window);
288
                glfwPollEvents();
289
        }
290

291

292
        glfwTerminate();
293
        return 0;
294
}