立方体贴图采样原理#

立方体贴图不依赖常规二维 UV 纹理坐标，依靠三维方向向量完成采样。当天空盒立方体中心处于坐标原点时，立方体每个顶点的坐标，本身就是一条从原点指向立方体表面的方向射线。因此在采样立方体贴图时，可直接使用顶点位置坐标替代纹理坐标，无需额外定义UV坐标。

立方体贴图存储特性#

立方体贴图由6张不同方向的二维纹理（立方体六个面）组合打包而成。
整套立方体贴图只对应一个纹理对象、一个纹理ID，统一管理。
采样过程由 OpenGL 硬件自动完成：根据传入的三维方向向量，自动判断该射线命中立方体的哪一个面，并对应采集该面的纹理像素颜色。

天空盒渲染与深度修正#

先绘天空盒的缺陷#

常规思路：先渲染天空盒立方体，同时关闭深度写入，让天空盒不占用深度缓冲，后续场景物体可正常写入深度、覆盖天空盒画面。该方案存在性能问题：天空盒最先渲染，所有像素的深度测试全部通过，全屏像素都会执行渲染计算，但天空盒绝大部分区域最终会被场景物体覆盖，产生大量无效渲染开销。

先绘场景物体的缺陷#

优化思路：先渲染所有场景物体，最后渲染天空盒，规避无效渲染。但天空盒始终贴近相机，深度值极小，正常深度测试几乎全部通过**，会覆盖已经渲染完成的场景物体**，画面错乱。

最终解决方案：篡改裁剪空间深度#

核心思路：强制让天空盒的深度值为屏幕深度最大值（1.0），让其永远被场景物体遮挡。深度值推导逻辑：

深度缓冲最终存储的是 NDC 空间归一化后的深度值，范围 [0,1]；
想要深度值 = 1.0，需要满足 NDC.z = 1；
NDC 坐标由裁剪空间坐标透视除法得到，NDC.z = clip.z / clip.w；
因此令 clip.z = clip.w，即可保证 NDC.z = 1。具体实现：在天空盒顶点着色器中，手动篡改输出的裁剪空间坐标：gl_Position.z = gl_Position.w，让天空盒所有片元深度值为最大值。

深度测试函数适配修改#

OpenGL 默认深度测试函数为 GL_LESS（深度更小则通过）。天空盒深度值恒为 1.0，若使用默认函数会永远无法通过测试，导致天空盒不显示。因此需要将深度测试函数改为 GL_LEQUAL（深度小于等于当前值则通过），保证空白区域的天空盒可以正常渲染。

其他注意事项#

渲染天空盒时，需要抹除视图矩阵的平移分量，仅保留旋转分量。效果：无论相机如何平移移动，天空盒在相机空间中的相对位置和尺寸始终保持不变，不会随相机远近发生缩放、位移，只会跟随相机旋转改变视角，完美模拟无限远的天空效果。
与普通2D纹理不同，立方体贴图不需要垂直翻转UV，可直接使用原始贴图资源采样，无需处理Y轴翻转适配。

example1: 天空盒#

给一个立方体应用上立方体纹理，那么这个立方体就可以作为包裹整个场景的天空盒。而要给模型应用纹理，需要定义模型的纹理坐标。但对于立方体纹理而言，它接收一个三维方向向量作为采样向量。如果这个立方体原点位于中心，那么顶点的位置坐标就等价于原点到顶点的方向向量，就可以用来采样立方体纹理。 首先是天空盒的加载，与正常的纹理加载相同，只是一张天空盒纹理包含六小张纹理，所以需要加载六次、传递六次数据。并且纹理目标也有所不同，每一小张对应一个纹理目标。 然后是天空盒纹理的使用。将天空盒纹理渲染到一个立方体上，并且这个渲染在整个渲染流程中最先，关闭深度写入，保证后续绘制的物体一定能遮挡住立方体。为避免相机移动时，天空盒立方体也移动，则不让视图矩阵的平移分量作用于立方体。 BQACAgUAAyEGAASHRsPbAAEWLFNqP3wTSm8YZoD2aJlLeolHOYBxdQACziUAAk05AVYz2hOqQhjAWzwE.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

16
using namespace std;
17

18
const unsigned int SCR_WIDTH = 800;
19
const unsigned int SCR_HEIGHT = 400;
20

21
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
22
float lastX = (float)SCR_WIDTH / 2.0f;
23
float lastY = (float)SCR_HEIGHT / 2.0f;
24
float deltaTime = 0.0f;
25
float lastFrame = 0.0f;
26
bool firstCamera = true;
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)==GLFW_PRESS){
33
                glfwSetWindowShouldClose(window, true);
34
        }
35
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
36
                camera.ProcessKeyboard(FORWARD, deltaTime);
37
        }
38
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
39
                camera.ProcessKeyboard(BACKWARD, deltaTime);
40
        }
41
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
42
                camera.ProcessKeyboard(LEFT, deltaTime);
43
        }
44
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
45
                camera.ProcessKeyboard(RIGHT, deltaTime);
46
        }
47
}
48
void processMovement(GLFWwindow* window, double xpos, double ypos) {
49
        if (firstCamera) {
50
                lastX = xpos;
51
                lastY = ypos;
52
                firstCamera = false;
53
        }
54
        float xoffset = xpos - lastX;
55
        float yoffset = lastY - ypos;
56
        lastX = xpos;
57
        lastY = ypos;
58
        camera.ProcessMouseMovement(xoffset, yoffset);
59
}
60
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
61
        camera.ProcessScroll(yoffset);
62
}
63
unsigned int loadTexture(const char* path) {
64
        unsigned int texture;
65
        glGenTextures(1, &texture);
66
        glBindTexture(GL_TEXTURE_2D, texture);
67

68
        int width, height, nrChannels;
69
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
70
        if (data) {
71
                GLenum format;
72
                if (nrChannels == 1) {
73
                        format = GL_RED;
74
                }
75
                else if (nrChannels == 3) {
76
                        format = GL_RGB;
77
                }
78
                else if (nrChannels == 4) {
79
                        format = GL_RGBA;
80
                }
81
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
82
                glGenerateMipmap(GL_TEXTURE_2D);
83
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
84
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
85
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
86
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
87
        }
88
        else {
89
                cout << "Failed to load texture" << endl;
90
        }
91
        stbi_image_free(data);
92
        return texture;
93
}
94
unsigned int loadCubemap(vector<string> faces) {
95
        unsigned int texture;
96
        glGenTextures(1, &texture);
97
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
98

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

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

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

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

141
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
142

143
        stbi_set_flip_vertically_on_load(true);
144

145
        glEnable(GL_DEPTH_TEST);
146

147
        float cubeVertices[] = {
148
                // positions          // texture Coords
149
                -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
150
                 0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
151
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
152
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
153
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
154
                -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
155

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

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

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

177
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
178
                 0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
179
                 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
180
                 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
181
                -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
182
                -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
183

184
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
185
                 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
186
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
187
                 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
188
                -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
189
                -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
190
        };
191

192
        float planeVertices[] = {
193
                5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
194
                -5.0f, -0.5f,  5.0f,  0.0f, 0.0f,
195
                -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
196

197
                 5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
198
                -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
199
                 5.0f, -0.5f, -5.0f,  2.0f, 2.0f
200
        };
201

202
        vector<string> faces{
203
                "resources/textures/skybox/right.jpg",
204
                "resources/textures/skybox/left.jpg",
205
                "resources/textures/skybox/top.jpg",
206
                "resources/textures/skybox/bottom.jpg",
207
                "resources/textures/skybox/back.jpg",
208
                "resources/textures/skybox/front.jpg",
209
        };
210

211
        //天空盒立方体的定义，中心在世界坐标原点，顶点是世界空间下，那么顶点位置坐标等价于原点到顶点向量，即世界空间下的一个方向向量
212
        float skyboxVertices[] = {
213
                -0.5f,  0.5f, -0.5f,
214
                -0.5f, -0.5f, -0.5f,
215
                 0.5f, -0.5f, -0.5f,
216
                 0.5f, -0.5f, -0.5f,
217
                 0.5f,  0.5f, -0.5f,
218
                -0.5f,  0.5f, -0.5f,
219

220
                -0.5f, -0.5f,  0.5f,
221
                -0.5f, -0.5f, -0.5f,
222
                -0.5f,  0.5f, -0.5f,
223
                -0.5f,  0.5f, -0.5f,
224
                -0.5f,  0.5f,  0.5f,
225
                -0.5f, -0.5f,  0.5f,
226

227
                 0.5f, -0.5f, -0.5f,
228
                 0.5f, -0.5f,  0.5f,
229
                 0.5f,  0.5f,  0.5f,
230
                 0.5f,  0.5f,  0.5f,
231
                 0.5f,  0.5f, -0.5f,
232
                 0.5f, -0.5f, -0.5f,
233

234
                -0.5f, -0.5f,  0.5f,
235
                -0.5f,  0.5f,  0.5f,
236
                 0.5f,  0.5f,  0.5f,
237
                 0.5f,  0.5f,  0.5f,
238
                 0.5f, -0.5f,  0.5f,
239
                -0.5f, -0.5f,  0.5f,
240

241
                -0.5f,  0.5f, -0.5f,
242
                 0.5f,  0.5f, -0.5f,
243
                 0.5f,  0.5f,  0.5f,
244
                 0.5f,  0.5f,  0.5f,
245
                -0.5f,  0.5f,  0.5f,
246
                -0.5f,  0.5f, -0.5f,
247

248
                -0.5f, -0.5f, -0.5f,
249
                -0.5f, -0.5f,  0.5f,
250
                 0.5f, -0.5f, -0.5f,
251
                 0.5f, -0.5f, -0.5f,
252
                -0.5f, -0.5f,  0.5f,
253
                 0.5f, -0.5f,  0.5f
254
        };
255

256
        unsigned int cubeVAO, cubeVBO;
257
        glGenVertexArrays(1, &cubeVAO);
258
        glGenBuffers(1, &cubeVBO);
259
        glBindVertexArray(cubeVAO);
260
        glBindBuffer(GL_ARRAY_BUFFER,cubeVBO);
261
        glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), cubeVertices, GL_STATIC_DRAW);
262
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
263
        glEnableVertexAttribArray(0);
264
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3*sizeof(float)));
265
        glEnableVertexAttribArray(1);
266
        glBindVertexArray(0);
267

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

280
        unsigned int skyboxVAO, skyboxVBO;
281
        glGenVertexArrays(1, &skyboxVAO);
282
        glGenBuffers(1, &skyboxVBO);
283
        glBindVertexArray(skyboxVAO);
284
        glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);
285
        glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), skyboxVertices, GL_STATIC_DRAW);
286
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
287
        glEnableVertexAttribArray(0);
288
        glBindVertexArray(0);
289

290
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
291
        Shader skyboxShader("src/Shader/skyboxVertexShader.txt", "src/Shader/skyboxFragmentShader.txt");
292

293
        unsigned int texture1 = loadTexture("resources/textures/container.jpg");
294
        unsigned int texture2 = loadTexture("resources/textures/metal.jpg");
295
        unsigned int texture3 = loadCubemap(faces);
296

297
        shader.use();
298
        shader.setInt("texture1", 0);
299
        shader.setInt("texture2", 1);
300

301
        skyboxShader.use();
302
        skyboxShader.setInt("skybox", 0);
303

304
        while (!glfwWindowShouldClose(window)) {
305
                float currentFrame = (float)glfwGetTime();
306
                deltaTime = currentFrame - lastFrame;
307
                lastFrame = currentFrame;
308

309
                processInput(window);
310

311
                glClearColor(0.1, 0.1, 0.1, 1.0);
312
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
313

314
                skyboxShader.use();
315
                glDepthMask(GL_FALSE);
316
                glm::mat4 model = glm::mat4(1.0f);
317
                glm::mat4 view;
318
                view = glm::mat4(glm::mat3(camera.GetCameraView()));
319
                skyboxShader.setMatrix("view", view);
320
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
321
                skyboxShader.setMatrix("project", project);
322
                glBindVertexArray(skyboxVAO);
323
                glActiveTexture(GL_TEXTURE0);
324
                glBindTexture(GL_TEXTURE_CUBE_MAP, texture3);
325
                glDrawArrays(GL_TRIANGLES, 0, 36);
326
                glBindVertexArray(0);
327
                glDepthMask(GL_TRUE);
328

329
                shader.use();
330
                glBindVertexArray(cubeVAO);
331
                glActiveTexture(GL_TEXTURE0);
332
                glBindTexture(GL_TEXTURE_2D, texture1);
333
                shader.setInt("useTex", 1);
334
                model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
335
                shader.setMatrix("model", model);
336
                view = camera.GetCameraView();
337
                shader.setMatrix("view", view);
338
                shader.setMatrix("project", project);
339
                glDrawArrays(GL_TRIANGLES, 0, 36);
340

341
                model = glm::mat4(1.0f);
342
                model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
343
                shader.setMatrix("model", model);
344
                glDrawArrays(GL_TRIANGLES, 0, 36);
345
                glBindVertexArray(0);
346

347
                glBindVertexArray(planeVAO);
348
                glActiveTexture(GL_TEXTURE1);
349
                glBindTexture(GL_TEXTURE_2D, texture2);
350
                shader.setInt("useTex", 2);
351
                model = glm::mat4(1.0);
352
                shader.setMatrix("model", model);
353
                glDrawArrays(GL_TRIANGLES, 0, 6);
354
                glBindVertexArray(0);
355

356
                glfwSwapBuffers(window);
357
                glfwPollEvents();
358
        }
359
        glDeleteVertexArrays(1, &cubeVAO);
360
        glDeleteVertexArrays(1, &planeVAO);
361
        glDeleteBuffers(1, &cubeVBO);
362
        glDeleteBuffers(1, &planeVBO);
363

364
        glfwTerminate();
365
        return 0;
366
}

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

5
out vec3 TexCoords;
6

7
uniform mat4 view;
8
uniform mat4 project;
9

10
void main(){
11
        TexCoords=aPos;
12
        gl_Position=project*view*vec4(aPos,1.0);
13
}

1
//skyboxFragmentShader
2
#version 330 core
3
in vec3 TexCoords;//使用方向向量采样，是vec3而非vec2
4

5
out vec4 FragColor;
6

7
uniform samplerCube skybox;
8

9
void main(){
10
        FragColor=texture(skybox,TexCoords);
11
}

example2: 环境映射#

立方体贴图不仅可以用于天空盒，还可以用于环境映射，包括反射和折射。对于反射而言，主要是修改渲染立方体物体的顶点着色器和片元着色器。在片元着色器中，传入立方体贴图，计算反射向量（根据视线方向和法线方向），使用反射向量采样立方体贴图作为输出颜色。 BQACAgUAAyEGAASHRsPbAAEWLFRqP3yNrkpmzcgPgtdkSWyPSdi_ogAC0SUAAk05AVbytVUZBLInQDwE.png

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

6
out vec3 Normal;
7
out vec3 FragPos;
8

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

13
void main(){
14
        gl_Position=project*view*model*vec4(aPos,1.0);
15
        FragPos=mat3(model)*aPos;
16
        Normal=mat3(transpose(inverse(model)))*aNormal;
17
}

1
//fragmentShader
2
#version 330 core
3
in vec3 Normal;
4
in vec3 FragPos;
5

6
out vec4 FragColor;
7

8
uniform samplerCube skybox;
9
uniform vec3 viewPos;
10

11
void main(){
12
        vec3 worldViewDir=normalize(FragPos-viewPos);
13
        vec3 worldNormal=normalize(Normal);
14
        vec3 reflectDir=reflect(worldViewDir,worldNormal);
15
        FragColor=vec4(texture(skybox,reflectDir).rgb,1.0);
16
}

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

16
using namespace std;
17

18
const unsigned int SCR_WIDTH = 800;
19
const unsigned int SCR_HEIGHT = 400;
20

21
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
22
float lastX = (float)SCR_WIDTH / 2.0f;
23
float lastY = (float)SCR_HEIGHT / 2.0f;
24
float deltaTime = 0.0f;
25
float lastFrame = 0.0f;
26
bool firstCamera = true;
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)==GLFW_PRESS){
33
                glfwSetWindowShouldClose(window, true);
34
        }
35
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
36
                camera.ProcessKeyboard(FORWARD, deltaTime);
37
        }
38
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
39
                camera.ProcessKeyboard(BACKWARD, deltaTime);
40
        }
41
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
42
                camera.ProcessKeyboard(LEFT, deltaTime);
43
        }
44
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
45
                camera.ProcessKeyboard(RIGHT, deltaTime);
46
        }
47
}
48
void processMovement(GLFWwindow* window, double xpos, double ypos) {
49
        if (firstCamera) {
50
                lastX = xpos;
51
                lastY = ypos;
52
                firstCamera = false;
53
        }
54
        float xoffset = xpos - lastX;
55
        float yoffset = lastY - ypos;
56
        lastX = xpos;
57
        lastY = ypos;
58
        camera.ProcessMouseMovement(xoffset, yoffset);
59
}
60
void processScroll(GLFWwindow* window, double xoffset, double yoffset) {
61
        camera.ProcessScroll(yoffset);
62
}
63
unsigned int loadTexture(const char* path) {
64
        unsigned int texture;
65
        glGenTextures(1, &texture);
66
        glBindTexture(GL_TEXTURE_2D, texture);
67

68
        int width, height, nrChannels;
69
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
70
        if (data) {
71
                GLenum format;
72
                if (nrChannels == 1) {
73
                        format = GL_RED;
74
                }
75
                else if (nrChannels == 3) {
76
                        format = GL_RGB;
77
                }
78
                else if (nrChannels == 4) {
79
                        format = GL_RGBA;
80
                }
81
                glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
82
                glGenerateMipmap(GL_TEXTURE_2D);
83
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
84
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
85
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
86
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
87
        }
88
        else {
89
                cout << "Failed to load texture" << endl;
90
        }
91
        stbi_image_free(data);
92
        return texture;
93
}
94
unsigned int loadCubemap(vector<string> faces) {
95
        unsigned int texture;
96
        glGenTextures(1, &texture);
97
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
98

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

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

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

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

141
        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
142

143
        stbi_set_flip_vertically_on_load(true);
144

145
        glEnable(GL_DEPTH_TEST);
146
        glDepthFunc(GL_LEQUAL);
147

148
        float vertices[] = {
149
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
150
                 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
151
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
152
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
153
                -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
154
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
155

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

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

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

177
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
178
                 0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
179
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
180
                 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
181
                -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
182
                -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
183

184
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
185
                 0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
186
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
187
                 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
188
                -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
189
                -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f
190
        };
191

192
        vector<string> faces{
193
                "resources/textures/skybox/right.jpg",
194
                "resources/textures/skybox/left.jpg",
195
                "resources/textures/skybox/top.jpg",
196
                "resources/textures/skybox/bottom.jpg",
197
                "resources/textures/skybox/back.jpg",
198
                "resources/textures/skybox/front.jpg",
199
        };
200

201
        //天空盒立方体的定义，中心在世界坐标原点，顶点是世界空间下，那么顶点位置坐标等价于原点到顶点向量，即世界空间下的一个方向向量
202
        float skyboxVertices[] = {
203
                -0.5f,  0.5f, -0.5f,
204
                -0.5f, -0.5f, -0.5f,
205
                 0.5f, -0.5f, -0.5f,
206
                 0.5f, -0.5f, -0.5f,
207
                 0.5f,  0.5f, -0.5f,
208
                -0.5f,  0.5f, -0.5f,
209

210
                -0.5f, -0.5f,  0.5f,
211
                -0.5f, -0.5f, -0.5f,
212
                -0.5f,  0.5f, -0.5f,
213
                -0.5f,  0.5f, -0.5f,
214
                -0.5f,  0.5f,  0.5f,
215
                -0.5f, -0.5f,  0.5f,
216

217
                 0.5f, -0.5f, -0.5f,
218
                 0.5f, -0.5f,  0.5f,
219
                 0.5f,  0.5f,  0.5f,
220
                 0.5f,  0.5f,  0.5f,
221
                 0.5f,  0.5f, -0.5f,
222
                 0.5f, -0.5f, -0.5f,
223

224
                -0.5f, -0.5f,  0.5f,
225
                -0.5f,  0.5f,  0.5f,
226
                 0.5f,  0.5f,  0.5f,
227
                 0.5f,  0.5f,  0.5f,
228
                 0.5f, -0.5f,  0.5f,
229
                -0.5f, -0.5f,  0.5f,
230

231
                -0.5f,  0.5f, -0.5f,
232
                 0.5f,  0.5f, -0.5f,
233
                 0.5f,  0.5f,  0.5f,
234
                 0.5f,  0.5f,  0.5f,
235
                -0.5f,  0.5f,  0.5f,
236
                -0.5f,  0.5f, -0.5f,
237

238
                -0.5f, -0.5f, -0.5f,
239
                -0.5f, -0.5f,  0.5f,
240
                 0.5f, -0.5f, -0.5f,
241
                 0.5f, -0.5f, -0.5f,
242
                -0.5f, -0.5f,  0.5f,
243
                 0.5f, -0.5f,  0.5f
244
        };
245

246
        unsigned int cubeVAO, cubeVBO;
247
        glGenVertexArrays(1, &cubeVAO);
248
        glGenBuffers(1, &cubeVBO);
249
        glBindVertexArray(cubeVAO);
250
        glBindBuffer(GL_ARRAY_BUFFER,cubeVBO);
251
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
252
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
253
        glEnableVertexAttribArray(0);
254
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3*sizeof(float)));
255
        glEnableVertexAttribArray(1);
256
        glBindVertexArray(0);
257

258
        unsigned int skyboxVAO, skyboxVBO;
259
        glGenVertexArrays(1, &skyboxVAO);
260
        glGenBuffers(1, &skyboxVBO);
261
        glBindVertexArray(skyboxVAO);
262
        glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);
263
        glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), skyboxVertices, GL_STATIC_DRAW);
264
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
265
        glEnableVertexAttribArray(0);
266
        glBindVertexArray(0);
267

268
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
269
        Shader skyboxShader("src/Shader/skyboxVertexShader.txt", "src/Shader/skyboxFragmentShader.txt");
270

271
        unsigned int texture3 = loadCubemap(faces);
272

273
        shader.use();
274
        shader.setInt("skybox", 0);
275

276
        skyboxShader.use();
277
        skyboxShader.setInt("skybox", 0);
278

279
        while (!glfwWindowShouldClose(window)) {
280
                float currentFrame = (float)glfwGetTime();
281
                deltaTime = currentFrame - lastFrame;
282
                lastFrame = currentFrame;
283

284
                processInput(window);
285

286
                glClearColor(0.1, 0.1, 0.1, 1.0);
287
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
288

289
                skyboxShader.use();
290
                glDepthMask(GL_FALSE);
291
                glm::mat4 model = glm::mat4(1.0f);
292
                glm::mat4 view;
293
                view = glm::mat4(glm::mat3(camera.GetCameraView()));
294
                skyboxShader.setMatrix("view", view);
295
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
296
                skyboxShader.setMatrix("project", project);
297
                glBindVertexArray(skyboxVAO);
298
                glActiveTexture(GL_TEXTURE0);
299
                glBindTexture(GL_TEXTURE_CUBE_MAP, texture3);
300
                glDrawArrays(GL_TRIANGLES, 0, 36);
301
                glBindVertexArray(0);
302
                glDepthMask(GL_TRUE);
303

304
                shader.use();
305
                shader.setVec3("viewPos", camera.Position);
306
                glBindVertexArray(cubeVAO);
307
                glActiveTexture(GL_TEXTURE0);
308
                glBindTexture(GL_TEXTURE_CUBE_MAP, texture3);
309
                model = glm::translate(model, glm::vec3(-1.0f, 0.0f, -1.0f));
310
                shader.setMatrix("model", model);
311
                view = camera.GetCameraView();
312
                shader.setMatrix("view", view);
313
                shader.setMatrix("project", project);
314
                glDrawArrays(GL_TRIANGLES, 0, 36);
315

316
                model = glm::mat4(1.0f);
317
                model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
318
                shader.setMatrix("model", model);
319
                glDrawArrays(GL_TRIANGLES, 0, 36);
320
                glBindVertexArray(0);
321

322
                glfwSwapBuffers(window);
323
                glfwPollEvents();
324
        }
325
        glDeleteVertexArrays(1, &cubeVAO);
326
        glDeleteBuffers(1, &cubeVBO);
327

328
        glfwTerminate();
329
        return 0;
330
}

在之前的背包模型上实现反射效果： BQACAgUAAyEGAASHRsPbAAEWLFdqP3zHpYo9Uwd9Q3LB755UfT3yPQAC1SUAAk05AVYT89AEPm79wzwE.png 当反射应用到一整个物体上（像是箱子）时，这个物体看起来就像是钢或者铬这样的高反射性材质。对于折射而言，主要在于计算折射方向的不同。使用refract函数，传入视线方向、法线方向以及两个介质的折射率。把反射和折射一起应用到物体上，通过视角相关的fresnel控制混合比例。 BQACAgUAAyEGAASHRsPbAAEWLF1qP30a17lchcvthUjDdbeCDutKvQAC3CUAAk05AVb1xTUnPPabqjwE.png

1
//fragmentShader
2
#version 330 core
3
in vec3 Normal;
4
in vec3 FragPos;
5
in vec2 TexCoords;
6

7
out vec4 FragColor;
8

9
struct Material{
10
        sampler2D texture_diffuse1;
11
        sampler2D texture_specular1;
12
        sampler2D texture_normal1;
13
        sampler2D texture_height1;
14
        sampler2D texture_reflection1;
15
};
16
uniform Material material;
17
uniform samplerCube skybox;
18
uniform vec3 viewPos;
19

20
void main(){
21
        vec3 worldViewDir=normalize(FragPos-viewPos);
22
        vec3 worldNormal=normalize(Normal);
23
        vec3 refractDir=refract(worldViewDir,worldNormal,1.00/1.52);
24
        vec3 reflectDir=reflect(worldViewDir,worldNormal);
25
        vec3 refractColor=texture(skybox,refractDir).rgb;
26
        vec3 reflectColor=texture(skybox,reflectDir).rgb;
27
        float fresnel=pow(1.0-max(dot(worldViewDir,worldNormal),0.0),2.0);
28
        vec3 finalColor=mix(refractColor,reflectColor,fresnel);
29
        FragColor=vec4(finalColor,1.0);
30
}

example3: 动态环境贴图#

定义立方体环境贴图FBO并绑定，从六个视角渲染场景（不包含要应用动态环境贴图的模型，避免自反射），渲染结果存入FBO的六个颜色附件（采用纹理形式）。切换回屏幕帧缓冲，正常渲染场景（包含要应用动态环境贴图的模型），且对于要应用动态环境贴图的模型来说，从FBO的颜色纹理（即六张颜色附件纹理构成的立方体纹理）中采样。此外，立方体贴图每个面都是正方形，而整个窗口不是正方形，所以在把当前场景渲染到立方体贴图的六个面时，必须使用glViewport改变窗口大小，渲染完之后再次使用glViewport改回来。

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
        glDepthFunc(GL_LEQUAL);
148

149
        float vertices[] = {
150
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
151
                 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
152
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
153
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
154
                -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
155
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
156

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

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

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

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

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

193
        vector<string> faces{
194
                "resources/textures/skybox/right.jpg",
195
                "resources/textures/skybox/left.jpg",
196
                "resources/textures/skybox/top.jpg",
197
                "resources/textures/skybox/bottom.jpg",
198
                "resources/textures/skybox/back.jpg",
199
                "resources/textures/skybox/front.jpg",
200
        };
201

202
        //天空盒立方体的定义，中心在世界坐标原点，顶点是世界空间下，那么顶点位置坐标等价于原点到顶点向量，即世界空间下的一个方向向量
203
        float skyboxVertices[] = {
204
                -0.5f,  0.5f, -0.5f,
205
                -0.5f, -0.5f, -0.5f,
206
                 0.5f, -0.5f, -0.5f,
207
                 0.5f, -0.5f, -0.5f,
208
                 0.5f,  0.5f, -0.5f,
209
                -0.5f,  0.5f, -0.5f,
210

211
                -0.5f, -0.5f,  0.5f,
212
                -0.5f, -0.5f, -0.5f,
213
                -0.5f,  0.5f, -0.5f,
214
                -0.5f,  0.5f, -0.5f,
215
                -0.5f,  0.5f,  0.5f,
216
                -0.5f, -0.5f,  0.5f,
217

218
                 0.5f, -0.5f, -0.5f,
219
                 0.5f, -0.5f,  0.5f,
220
                 0.5f,  0.5f,  0.5f,
221
                 0.5f,  0.5f,  0.5f,
222
                 0.5f,  0.5f, -0.5f,
223
                 0.5f, -0.5f, -0.5f,
224

225
                -0.5f, -0.5f,  0.5f,
226
                -0.5f,  0.5f,  0.5f,
227
                 0.5f,  0.5f,  0.5f,
228
                 0.5f,  0.5f,  0.5f,
229
                 0.5f, -0.5f,  0.5f,
230
                -0.5f, -0.5f,  0.5f,
231

232
                -0.5f,  0.5f, -0.5f,
233
                 0.5f,  0.5f, -0.5f,
234
                 0.5f,  0.5f,  0.5f,
235
                 0.5f,  0.5f,  0.5f,
236
                -0.5f,  0.5f,  0.5f,
237
                -0.5f,  0.5f, -0.5f,
238

239
                -0.5f, -0.5f, -0.5f,
240
                -0.5f, -0.5f,  0.5f,
241
                 0.5f, -0.5f, -0.5f,
242
                 0.5f, -0.5f, -0.5f,
243
                -0.5f, -0.5f,  0.5f,
244
                 0.5f, -0.5f,  0.5f
245
        };
246

247
        vector<glm::mat4> cubeViews = {
248
                glm::lookAt(glm::vec3(0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f,-1.0f, 0.0f)), // +X
249
                glm::lookAt(glm::vec3(0.0f), glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(0.0f,-1.0f, 0.0f)), // -X
250
                glm::lookAt(glm::vec3(0.0f), glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 0.0f,-1.0f)), // +Y
251
                glm::lookAt(glm::vec3(0.0f), glm::vec3(0.0f,-1.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f)), // -Y
252
                glm::lookAt(glm::vec3(0.0f), glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(0.0f,-1.0f, 0.0f)), // +Z
253
                glm::lookAt(glm::vec3(0.0f), glm::vec3(0.0f, 0.0f,-1.0f), glm::vec3(0.0f,-1.0f, 0.0f))  // -Z
254
        };
255

256
        unsigned int cubeVAO, cubeVBO;
257
        glGenVertexArrays(1, &cubeVAO);
258
        glGenBuffers(1, &cubeVBO);
259
        glBindVertexArray(cubeVAO);
260
        glBindBuffer(GL_ARRAY_BUFFER,cubeVBO);
261
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
262
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
263
        glEnableVertexAttribArray(0);
264
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3*sizeof(float)));
265
        glEnableVertexAttribArray(1);
266
        glBindVertexArray(0);
267

268
        unsigned int skyboxVAO, skyboxVBO;
269
        glGenVertexArrays(1, &skyboxVAO);
270
        glGenBuffers(1, &skyboxVBO);
271
        glBindVertexArray(skyboxVAO);
272
        glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);
273
        glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), skyboxVertices, GL_STATIC_DRAW);
274
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
275
        glEnableVertexAttribArray(0);
276
        glBindVertexArray(0);
277

278
        unsigned int envFBO;
279
        glGenFramebuffers(1, &envFBO);
280
        glBindFramebuffer(GL_FRAMEBUFFER, envFBO);
281

282
        unsigned int envTex;
283
        glGenTextures(1, &envTex);
284
        glBindTexture(GL_TEXTURE_CUBE_MAP, envTex);
285
        for (int i = 0; i < 6; i++) {
286
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, 512, 512, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
287
        }
288
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
289
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
290
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
291
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
292
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
293

294
        unsigned int envRBO;
295
        glGenRenderbuffers(1, &envRBO);
296
        glBindRenderbuffer(GL_RENDERBUFFER, envRBO);
297
        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 512, 512);
298
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, envRBO);
299

300
        if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
301
                cout << "ERROR::ENV FBO INCOMPLETE!" << endl;
302
        }
303
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
304
        glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
305
        glBindRenderbuffer(GL_RENDERBUFFER, 0);
306

307
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
308
        Shader skyboxShader("src/Shader/skyboxVertexShader.txt", "src/Shader/skyboxFragmentShader.txt");
309

310
        Model myModel("resources/objects/backpack/backpack.obj");
311

312
        unsigned int texture3 = loadCubemap(faces);
313

314
        shader.use();
315
        shader.setInt("skybox", 4);
316

317
        skyboxShader.use();
318
        skyboxShader.setInt("skybox", 0);
319

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

325
                processInput(window);
326

327
                glBindFramebuffer(GL_FRAMEBUFFER, envFBO);
328
                glViewport(0, 0, 512, 512);
329
                glm::vec3 reflectCenter = glm::vec3(0.0f);
330
                glm::mat4 envProj = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f,100.0f);
331
                for (int i = 0; i < 6; i++) {
332
                        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, envTex, 0);
333
                        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
334
                        shader.use();
335
                        shader.setMatrix("project", envProj);
336
                        glm::mat4 view = cubeViews[i];
337
                        shader.setMatrix("view", view);
338
                        shader.setVec3("viewPos", reflectCenter);
339

340
                        glDepthMask(GL_FALSE);
341
                        glm::mat4 skyView = glm::mat4(glm::mat3(view));
342
                        skyboxShader.use();
343
                        skyboxShader.setMatrix("view", skyView);
344
                        skyboxShader.setMatrix("project", envProj);
345
                        glBindVertexArray(skyboxVAO);
346
                        glActiveTexture(GL_TEXTURE0);
347
                        glBindTexture(GL_TEXTURE_CUBE_MAP, texture3);
348
                        glDrawArrays(GL_TRIANGLES, 0, 36);
349
                        glBindVertexArray(0);
350
                        glDepthMask(GL_TRUE);
351

352
                        //渲染其他物体，跳过要做反射的物体
353
                        shader.use();
354
                        glm::mat4 cubeModel = glm::mat4(1.0f);
355
                        cubeModel = glm::translate(cubeModel, glm::vec3(0.0f, 0.0f, 2.4f));
356
                        cubeModel = glm::scale(cubeModel, glm::vec3(1.0f));
357
                        shader.setMatrix("model", cubeModel);
358
                        shader.setInt("useReflection", 0);
359
                        glBindVertexArray(cubeVAO);
360
                        glDrawArrays(GL_TRIANGLES, 0, 36);
361
                        glBindVertexArray(0);
362
                }
363
                glBindFramebuffer(GL_FRAMEBUFFER, 0);
364
                glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);
365

366
                glClearColor(0.1, 0.1, 0.1, 1.0);
367
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
368

369
                skyboxShader.use();
370
                glDepthMask(GL_FALSE);
371
                glm::mat4 model = glm::mat4(1.0f);
372
                glm::mat4 view;
373
                view = glm::mat4(glm::mat3(camera.GetCameraView()));
374
                skyboxShader.setMatrix("view", view);
375
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
376
                skyboxShader.setMatrix("project", project);
377
                glBindVertexArray(skyboxVAO);
378
                glActiveTexture(GL_TEXTURE0);
379
                glBindTexture(GL_TEXTURE_CUBE_MAP, texture3);
380
                glDrawArrays(GL_TRIANGLES, 0, 36);
381
                glBindVertexArray(0);
382
                glDepthMask(GL_TRUE);
383

384
                shader.use();
385
                shader.setVec3("viewPos", camera.Position);
386
                glActiveTexture(GL_TEXTURE4);
387
                glBindTexture(GL_TEXTURE_CUBE_MAP, envTex);
388

389
                //绘制不带反射的立方体
390
                glm::mat4 cubeModel = glm::mat4(1.0f);
391
                cubeModel = glm::translate(cubeModel, glm::vec3(0.0f, 0.0f, 2.4f));
392
                cubeModel = glm::scale(cubeModel, glm::vec3(0.5f));
393
                shader.setMatrix("model", cubeModel);
394
                view = camera.GetCameraView();
395
                shader.setMatrix("view", view);
396
                shader.setMatrix("project", project);
397
                shader.setInt("useReflection", 0);
398
                glBindVertexArray(cubeVAO);
399
                glDrawArrays(GL_TRIANGLES, 0, 36);
400
                glBindVertexArray(0);
401

402
                //绘制带反射的模型
403
                model = glm::translate(model, glm::vec3(0.0f));
404
                model = glm::scale(model, glm::vec3(1.0f));
405
                shader.setMatrix("model", model);
406
                view = camera.GetCameraView();
407
                shader.setMatrix("view", view);
408
                shader.setMatrix("project", project);
409
                shader.setInt("useReflection", 1);
410
                myModel.Draw(shader);
411

412
                glfwSwapBuffers(window);
413
                glfwPollEvents();
414
        }
415
        glDeleteVertexArrays(1, &cubeVAO);
416
        glDeleteBuffers(1, &cubeVBO);
417
        glDeleteFramebuffers(1, &envFBO);
418
        glDeleteRenderbuffers(1, &envRBO);
419

420
        glfwTerminate();
421
        return 0;
422
}

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 vec3 Normal;
8
out vec3 FragPos;
9
out vec2 TexCoords;
10

11
uniform mat4 model;
12
uniform mat4 view;
13
uniform mat4 project;
14

15
void main(){
16
        gl_Position=project*view*model*vec4(aPos,1.0);
17
        FragPos=mat3(model)*aPos;
18
        Normal=mat3(transpose(inverse(model)))*aNormal;
19
        TexCoords=aTexCoords;
20
}

1
//fragmentShader
2
#version 330 core
3
in vec3 Normal;
4
in vec3 FragPos;
5
in vec2 TexCoords;
6

7
out vec4 FragColor;
8

9
struct Material{
10
        sampler2D texture_diffuse1;
11
        sampler2D texture_specular1;
12
        sampler2D texture_normal1;
13
        sampler2D texture_height1;
14
        sampler2D texture_reflection1;
15
};
16
uniform Material material;
17
uniform samplerCube skybox;
18
uniform vec3 viewPos;
19

20
uniform int useReflection;
21

22
void main(){
23
        if(useReflection == 0)
24
        {
25
                FragColor = vec4(texture(material.texture_diffuse1,TexCoords).rgb, 1.0);
26
                return;
27
        }
28
        vec3 worldViewDir=normalize(FragPos-viewPos);
29
        vec3 worldNormal=normalize(Normal);
30
        vec3 refractDir=refract(worldViewDir,worldNormal,1.00/1.52);
31
        vec3 reflectDir=reflect(worldViewDir,worldNormal);
32
        vec3 refractColor=texture(skybox,refractDir).rgb;
33
        vec3 reflectColor=texture(skybox,reflectDir).rgb;
34
        float fresnel=pow(1.0-max(dot(worldViewDir,worldNormal),0.0),2.0);
35
        vec3 finalColor=mix(refractColor,reflectColor,fresnel);
36
        FragColor=vec4(finalColor,1.0);
37
}

homework#

尝试在我们之前在模型加载小节中创建的模型加载器中引入反射贴图。你可以在这里找到升级后有反射贴图的背包模型。仍有几点要注意的： Assimp在大多数格式中都不太喜欢反射贴图，所以我们需要欺骗一下它，将反射贴图储存为漫反射贴图。你可以在加载材质的时候将反射贴图的纹理类型设置为aiTextureType_AMBIENT。我偷懒直接使用镜面光纹理图像来创建了反射贴图，所以反射贴图在模型的某些地方不能准确地映射:)。由于模型加载器本身就已经在着色器中占用了3个纹理单元了，你需要将天空盒绑定到第4个纹理单元上，因为我们要从同一个着色器中对天空盒采样。思路：首先修改Model.h，增加反射贴图的处理逻辑：查找类型为aiTextureType_AMBIENT的贴图，作为反射贴图

1
//处理材质
2
if (mesh->mMaterialIndex >= 0) {
3
        //materialIndex时网格的材质编号，据此索引到材质列表中的某个具体材质
4
        //materialIndex>=0表示该网格有材质，否则该网格没有材质，无需处理
5
        aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
6
        vector<Texture> diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse");
7
        textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
8

9
        vector<Texture> specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular");
10
        textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
11

12
        vector<Texture> normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal");
13
        textures.insert(textures.end(), normalMaps.begin(), normalMaps.end());
14

15
        vector<Texture> heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height");
16
        textures.insert(textures.end(), heightMaps.begin(), heightMaps.end());
17

18
        vector<Texture> reflectionMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_reflection");
19
        textures.insert(textures.end(), reflectionMaps.begin(), reflectionMaps.end());
20
}

然后修改Mesh.h，增加反射贴图的处理逻辑：数量、拼接uniformName

1
void Draw(Shader& shader) {
2
        unsigned int diffuseNr = 1;//漫反射贴图的编号
3
        unsigned int specularNr = 1;//镜面反射贴图的编号
4
        unsigned int normalNr = 1;//法线贴图的编号
5
        unsigned int heightNr = 1;//高度图的编号
6
        unsigned int reflectionNr = 1;//反射贴图的编号
7

8
        //完成纹理数据的设置和绑定
9
        for (unsigned int i = 0; i < textures.size(); i++) {//遍历所有贴图，可能包含漫反射贴图，镜面反射贴图或是其他贴图，需要根据type判断
10
                //激活当前贴图对应的纹理单元
11
                glActiveTexture(GL_TEXTURE0 + i);
12

13
                string number;
14
                string name = textures[i].type;
15
                if (name == "texture_diffuse") {
16
                        number = to_string(diffuseNr++);
17
                }
18
                else if (name == "texture_specular") {
19
                        number = to_string(specularNr++);
20
                }
21
                else if (name == "texture_normal") {
22
                        number = to_string(normalNr++);
23
                }
24
                else if (name == "texture_height") {
25
                        number = to_string(heightNr++);
26
                }
27
                else if (name == "texture_reflection") {
28
                        number = to_string(reflectionNr++);
29
                }
30

31
                string uniformName = "material." + name + number;
32
                //获取Shader中这个uniform变量的位置
33
                int textureLoc = glGetUniformLocation(shader.ID, uniformName.c_str());
34
                //告诉Shader这个sampler2D指向第几个纹理单元
35
                glUniform1i(textureLoc, i);
36
                //当前纹理单元绑定第几号纹理
37
                glBindTexture(GL_TEXTURE_2D, textures[i].id);
38
        }
39
        //绘制网格
40
        glBindVertexArray(VAO);
41
        //告诉GPU从EBO缓冲中哪里开始取索引，取多少个，每个索引的数据类型是什么，取了之后怎么画
42
        glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(indices.size()), GL_UNSIGNED_INT, 0);
43
        glBindVertexArray(0);//解绑，不一定必要（因为绘制物体前都会先绑定这个物体的VAO，但最好加上）
44

45
        glActiveTexture(GL_TEXTURE0);//跟上边解绑一样，使所有数据结构回到初始时的状态
46
}

然后修改片元着色器，增加反射贴图的定义，并在main函数中采样反射贴图、混合漫反射输出

1
//fragmentShader
2
#version 330 core
3
in vec3 Normal;
4
in vec3 FragPos;
5
in vec2 TexCoords;
6

7
out vec4 FragColor;
8

9
struct Material{
10
        sampler2D texture_diffuse1;
11
        sampler2D texture_specular1;
12
        sampler2D texture_normal1;
13
        sampler2D texture_height1;
14
        sampler2D texture_reflection1;
15
};
16
uniform Material material;
17
uniform samplerCube skybox;
18
uniform vec3 viewPos;
19

20
void main(){
21
        vec3 worldViewDir=normalize(FragPos-viewPos);
22
        vec3 worldNormal=normalize(Normal);
23
        vec3 reflectDir=reflect(worldViewDir,worldNormal);
24
        vec3 reflectColor=texture(material.texture_reflection1,TexCoords).rgb;
25
        reflectColor*=texture(skybox,reflectDir).rgb;
26

27
        vec3 diffuseColor=texture(material.texture_diffuse1,TexCoords).rgb;
28

29
        vec3 finalColor=mix(diffuseColor,reflectColor,1.0);
30
        FragColor=vec4(finalColor,1.0);
31
}

最后是main.cpp，传递立方体纹理，以及在渲染循环中调用模型的绘制函数。

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
        glDepthFunc(GL_LEQUAL);
148

149
        float vertices[] = {
150
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
151
                 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
152
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
153
                 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
154
                -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
155
                -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
156

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

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

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

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

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

193
        vector<string> faces{
194
                "resources/textures/skybox/right.jpg",
195
                "resources/textures/skybox/left.jpg",
196
                "resources/textures/skybox/top.jpg",
197
                "resources/textures/skybox/bottom.jpg",
198
                "resources/textures/skybox/back.jpg",
199
                "resources/textures/skybox/front.jpg",
200
        };
201

202
        //天空盒立方体的定义，中心在世界坐标原点，顶点是世界空间下，那么顶点位置坐标等价于原点到顶点向量，即世界空间下的一个方向向量
203
        float skyboxVertices[] = {
204
                -0.5f,  0.5f, -0.5f,
205
                -0.5f, -0.5f, -0.5f,
206
                 0.5f, -0.5f, -0.5f,
207
                 0.5f, -0.5f, -0.5f,
208
                 0.5f,  0.5f, -0.5f,
209
                -0.5f,  0.5f, -0.5f,
210

211
                -0.5f, -0.5f,  0.5f,
212
                -0.5f, -0.5f, -0.5f,
213
                -0.5f,  0.5f, -0.5f,
214
                -0.5f,  0.5f, -0.5f,
215
                -0.5f,  0.5f,  0.5f,
216
                -0.5f, -0.5f,  0.5f,
217

218
                 0.5f, -0.5f, -0.5f,
219
                 0.5f, -0.5f,  0.5f,
220
                 0.5f,  0.5f,  0.5f,
221
                 0.5f,  0.5f,  0.5f,
222
                 0.5f,  0.5f, -0.5f,
223
                 0.5f, -0.5f, -0.5f,
224

225
                -0.5f, -0.5f,  0.5f,
226
                -0.5f,  0.5f,  0.5f,
227
                 0.5f,  0.5f,  0.5f,
228
                 0.5f,  0.5f,  0.5f,
229
                 0.5f, -0.5f,  0.5f,
230
                -0.5f, -0.5f,  0.5f,
231

232
                -0.5f,  0.5f, -0.5f,
233
                 0.5f,  0.5f, -0.5f,
234
                 0.5f,  0.5f,  0.5f,
235
                 0.5f,  0.5f,  0.5f,
236
                -0.5f,  0.5f,  0.5f,
237
                -0.5f,  0.5f, -0.5f,
238

239
                -0.5f, -0.5f, -0.5f,
240
                -0.5f, -0.5f,  0.5f,
241
                 0.5f, -0.5f, -0.5f,
242
                 0.5f, -0.5f, -0.5f,
243
                -0.5f, -0.5f,  0.5f,
244
                 0.5f, -0.5f,  0.5f
245
        };
246

247
        unsigned int cubeVAO, cubeVBO;
248
        glGenVertexArrays(1, &cubeVAO);
249
        glGenBuffers(1, &cubeVBO);
250
        glBindVertexArray(cubeVAO);
251
        glBindBuffer(GL_ARRAY_BUFFER,cubeVBO);
252
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
253
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
254
        glEnableVertexAttribArray(0);
255
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3*sizeof(float)));
256
        glEnableVertexAttribArray(1);
257
        glBindVertexArray(0);
258

259
        unsigned int skyboxVAO, skyboxVBO;
260
        glGenVertexArrays(1, &skyboxVAO);
261
        glGenBuffers(1, &skyboxVBO);
262
        glBindVertexArray(skyboxVAO);
263
        glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);
264
        glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), skyboxVertices, GL_STATIC_DRAW);
265
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
266
        glEnableVertexAttribArray(0);
267
        glBindVertexArray(0);
268

269
        Shader shader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
270
        Shader skyboxShader("src/Shader/skyboxVertexShader.txt", "src/Shader/skyboxFragmentShader.txt");
271

272
        Model myModel("resources/objects/nanosuit_reflection/nanosuit.obj");
273

274
        unsigned int texture3 = loadCubemap(faces);
275

276
        shader.use();
277
        shader.setInt("skybox", 4);
278

279
        skyboxShader.use();
280
        skyboxShader.setInt("skybox", 0);
281

282
        while (!glfwWindowShouldClose(window)) {
283
                float currentFrame = (float)glfwGetTime();
284
                deltaTime = currentFrame - lastFrame;
285
                lastFrame = currentFrame;
286

287
                processInput(window);
288

289
                glClearColor(0.1, 0.1, 0.1, 1.0);
290
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
291

292
                skyboxShader.use();
293
                glDepthMask(GL_FALSE);
294
                glm::mat4 model = glm::mat4(1.0f);
295
                glm::mat4 view;
296
                view = glm::mat4(glm::mat3(camera.GetCameraView()));
297
                skyboxShader.setMatrix("view", view);
298
                glm::mat4 project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
299
                skyboxShader.setMatrix("project", project);
300
                glBindVertexArray(skyboxVAO);
301
                glActiveTexture(GL_TEXTURE0);
302
                glBindTexture(GL_TEXTURE_CUBE_MAP, texture3);
303
                glDrawArrays(GL_TRIANGLES, 0, 36);
304
                glBindVertexArray(0);
305
                glDepthMask(GL_TRUE);
306

307
                shader.use();
308
                shader.setVec3("viewPos", camera.Position);
309
                //glBindVertexArray(cubeVAO);
310
                glActiveTexture(GL_TEXTURE4);
311
                glBindTexture(GL_TEXTURE_CUBE_MAP, texture3);
312
                model = glm::translate(model, glm::vec3(-1.0f, -1.0f, -1.0f));
313
                model = glm::scale(model, glm::vec3(0.1f));
314
                shader.setMatrix("model", model);
315
                view = camera.GetCameraView();
316
                shader.setMatrix("view", view);
317
                shader.setMatrix("project", project);
318
                //glDrawArrays(GL_TRIANGLES, 0, 36);
319
                myModel.Draw(shader);
320

321
                //model = glm::mat4(1.0f);
322
                //model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
323
                //shader.setMatrix("model", model);
324
                //glDrawArrays(GL_TRIANGLES, 0, 36);
325
                //glBindVertexArray(0);
326

327
                glfwSwapBuffers(window);
328
                glfwPollEvents();
329
        }
330
        glDeleteVertexArrays(1, &cubeVAO);
331
        glDeleteBuffers(1, &cubeVBO);
332

333
        glfwTerminate();
334
        return 0;
335
}