光照贴图（Lighting Maps）引入原因#

基础材质系统存在局限性：单个物体仅对应一套材质参数（固定材质颜色、光源属性、高光参数），整个物体只能呈现统一的光照视觉效果，无法模拟现实物体局部材质不同、光影效果不同的真实表现。 光照贴图解决方案：通过贴图纹理采样，让物体不同位置的像素/片元读取不同的光照参数，实现同一物体多材质、局部差异化光影效果，大幅提升渲染真实度。

光照贴图与 sampler2D 原理#

光照贴图本质属于纹理资源，存储在sampler2D中，sampler2D 对应显卡纹理单元编号，每个纹理单元绑定一张贴图。
sampler2D 是 GPU 硬件底层资源，无法在着色器中随意实例化，必须由 CPU 通过 uniform 变量传递至 GPU。
贴图属于全局渲染资源，不属于单个顶点、单个片元私有数据，因此 sampler2D 变量必须定义为 uniform 类型。

环境光贴图规则#

在真实渲染中，物体的环境光颜色几乎与漫反射颜色保持一致，因此可以直接移除材质结构体中独立的环境光颜色定义，复用漫反射贴图数据，精简材质参数。若需要单独保留环境光颜色：环境光对物体所有像素的光照强度均匀统一，而贴图是逐像素不一样，所以无法通过贴图采样获取环境光，必须手动单独定义固定颜色。

镜面反射贴图制作原理#

可通过 Photoshop、GIMP 等图像工具，基于漫反射纹理快速制作镜面反射纹理：

裁剪漫反射贴图，去除不需要镜面高光反射的区域；
将图像转为黑白灰度图；
调整亮度、对比度，控制高光强度范围。核心原理：镜面贴图存储的是高光强度数值，而非颜色。镜面高光的最终色彩由光源颜色决定，即使贴图存储彩色信息，也无法得到真实的高光效果，因此统一使用黑白灰度图存储强度。

放射光贴图（自发光贴图）#

放射光贴图用于实现物体自发光效果，可以精准控制物体任意片元的发光区域、发光强度，脱离光源照射限制，让物体自身产生光照颜色。

光照方向校正规则#

光源原始方向：由光源位置指向片元位置。
光照计算所需方向：由片元位置指向光源位置。
光照计算前必须对方向向量取反，否则光照计算结果完全错误。

方向光与点光源区分规则#

向量无位置属性、只有方向，点坐标包含位置属性，可通过齐次坐标 w 分量 快速区分：

w = 0：纯方向向量，代表方向光（无具体光源位置，只有光照方向）。
w = 1：空间位置坐标，代表点光源（有具体世界空间位置）。

聚光灯原理与判定规则#

聚光灯核心参数#

聚光灯由三个核心参数定义：世界空间光源位置、直射方向向量、切光角（光照锥形边界与直射方向的夹角）。

片元光照范围判定#

计算光源指向当前片元的光照方向向量；
将光照方向与聚光灯直射方向做点积运算，得到夹角余弦值；
对比余弦值与切光角余弦值：若数值更大，代表片元处于光照锥形范围外，不接收光照。

手电筒（相机聚光灯）特殊实现#

手电筒是绑定相机的特殊聚光灯：

光源位置 = 相机世界位置；
光照直射方向 = 相机视线朝向；
光照位置与朝向会随相机移动、视角转动实时更新。

聚光灯双层锥体衰减机制#

点光源仅存在距离衰减（距离越远光照越弱）；聚光灯额外拥有锥形范围衰减，通过内外双层锥体实现平滑光影过渡：

内锥体内部：光照强度 = 1.0，无衰减，光照效果最强；
外锥体外部：光照强度 = 0.0，完全无光照；
内外锥体之间：光照强度线性插值过渡，避免光照边界生硬锯齿，实现柔和光影渐变。

example1: 使用漫反射贴图#

贴图的加载和使用与纹理类似：图片内容都存在纹理单元里，并使用一个sampler2D的变量指向这个纹理单元。sampler2D类型的变量都需要定义为uniform全局变量，并在C++代码中传递。都使用texture函数采样得到像素值。 BQACAgUAAyEGAASHRsPbAAEWKm5qP1jJGdts88fEvF8VGgAB8LA3GKEAAnEjAAJNOQFWcBE0f8vgciA8BA.png

1
//vertexShader
2
//新增了纹理坐标的顶点着色器
3
#version 330 core
4
layout (location = 0) in vec3 aPos;
5
layout (location = 1) in vec3 aNormal;
6
layout (location = 2) in vec2 aTexcoords;
7

8
out vec3 worldPos;
9
out vec3 normal;
10
out vec2 Texcoords;
11

12
uniform mat4 model;
13
uniform mat4 view;
14
uniform mat4 project;
15
void main(){
16
        gl_Position=project*view*model*vec4(aPos,1.0);
17
        worldPos=vec3(model*vec4(aPos,1.0));
18
        normal = mat3(transpose(inverse(model)))*aNormal;
19
        Texcoords=aTexcoords;
20
}

1
//fragmentShader
2
//材质结构体中的diffuse改为sampler2D类型，删除单独定义的环境光颜色
3
//漫反射颜色和环境光颜色都从漫反射贴图中采样
4
#version 330 core
5
struct Material{
6
        sampler2D diffuse;
7
        vec3 specular;
8
        float shininess;
9
};
10
struct Light{
11
        vec3 lightPos;
12
        vec3 ambient;
13
        vec3 diffuse;
14
        vec3 specular;
15
};
16
in vec3 worldPos;
17
in vec3 normal;
18
in vec2 Texcoords;
19
uniform Material material;
20
uniform Light light;
21
uniform vec3 viewPos;
22
out vec4 FragColor;
23
void main(){
24
        vec3 ambient = light.ambient*texture(material.diffuse,Texcoords).rgb;
25

26
        vec3 worldNormal=normalize(normal);
27
        vec3 worldLightDir=normalize(light.lightPos-worldPos);
28
        float diff=max(dot(worldNormal,worldLightDir),0.0);
29
        vec3 diffuse=diff*texture(material.diffuse,Texcoords).rgb*light.diffuse;
30

31
        vec3 worldViewDir=normalize(viewPos-worldPos);
32
        vec3 reflectDir=reflect(-worldLightDir,worldNormal);
33
        float spec=pow(max(dot(worldViewDir,reflectDir),0.0),material.shininess);
34
        vec3 specular=spec*material.specular*light.specular;
35

36
        FragColor = vec4(ambient+diffuse+specular,1.0);
37
}

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4
#include <stb_image.h>
5
#include<iostream>
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

13
using namespace std;
14

15
const unsigned int SCR_WIDTH = 800;
16
const unsigned int SCR_HEIGHT = 600;
17

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

24
glm::vec3 lightPos(1.2f, 1.0f, 2.0f);
25

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

70
    int width, height, nrChannels;
71
    stbi_set_flip_vertically_on_load(true);
72
    unsigned char* data = stbi_load("resources/lighting_maps/container2.png", &width, &height, &nrChannels, 0);
73
    if (data) {
74
        GLenum format;
75
        if (nrChannels == 1) {
76
            format = GL_RED;
77
        }
78
        else if (nrChannels == 3) {
79
            format = GL_RGB;
80
        }
81
        else if (nrChannels == 4) {
82
            format = GL_RGBA;
83
        }
84
        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
85
        glGenerateMipmap(GL_TEXTURE_2D);
86
    }
87
    else {
88
        cout << "Failed to load texture" << endl;
89
    }
90
    stbi_image_free(data);
91
    return texture;
92
}
93

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

100
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
101
        if (window == NULL) {
102
                cout << "Failed to create window" << endl;
103
                glfwTerminate();
104
                return -1;
105
        }
106
        glfwMakeContextCurrent(window);
107
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
108
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
109
    glfwSetCursorPosCallback(window, mouseMove_callback);
110
    glfwSetScrollCallback(window, mouse_scroll_callback);
111

112
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
113
                cout << "Failed to load GLAD" << endl;
114
                glfwTerminate();
115
                return -1;
116
        }
117
        glEnable(GL_DEPTH_TEST);
118

119
    float vertices[] = {
120
        // positions          // normals           // texture coords
121
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 0.0f,
122
         0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 0.0f,
123
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 1.0f,
124
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 1.0f,
125
        -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 1.0f,
126
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 0.0f,
127

128
        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,
129
         0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 0.0f,
130
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
131
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
132
        -0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 1.0f,
133
        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,
134

135
        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
136
        -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 1.0f,
137
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
138
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
139
        -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 0.0f,
140
        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
141

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

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

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

164
    unsigned int VBO, VAO;
165
    //处理被照物体的顶点属性
166
    glGenVertexArrays(1, &VAO);
167
    glGenBuffers(1, &VBO);
168
    glBindVertexArray(VAO);
169
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
170
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
171
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
172
    glEnableVertexAttribArray(0);
173
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
174
    glEnableVertexAttribArray(1);
175
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
176
    glEnableVertexAttribArray(2);
177
    glBindVertexArray(0);
178

179
    //处理灯的顶点属性
180
    unsigned int lightVAO;
181
    glGenVertexArrays(1, &lightVAO);
182
    glBindVertexArray(lightVAO);
183
    //二者共用一份VBO，不需要再创建，只需绑定
184
    glBindBuffer(GL_ARRAY_BUFFER, VBO);//告诉lightVAO从哪里读取顶点数据
185
    //也不需要传递顶点数据，因为灯和被照物体共用一份顶点数据，已经在处理物体时传递过了
186
    //设置读取规则
187
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float),(void*)0);
188
    glEnableVertexAttribArray(0);
189
    glBindVertexArray(0);
190

191
    unsigned int texture = loadTexture("resources/lighting_maps/container.png");
192

193
    //物体的着色器
194
        Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
195
    //光源的着色器
196
    //如果共用一个片元着色器，修改物体颜色将会修改光源颜色，这并不是我们想要的
197
    Shader lightShader("src/Shader/vertexShader.txt", "src/Shader/lightFragmentShader.txt");
198

199
        ourShader.use();
200
        //设置物体运行时不需要改变的uniform变量值
201
    ourShader.setInt("material.diffuse", 0);
202
    ourShader.setVec3("material.specular", glm::vec3(0.5));
203
    ourShader.setFloat("material.shininess", 64.0f);
204

205
    ourShader.setVec3("light.ambient", glm::vec3(0.2f));
206
    ourShader.setVec3("light.diffuse", glm::vec3(0.5f));
207
    ourShader.setVec3("light.specular", glm::vec3(1.0f));
208

209
        while (!glfwWindowShouldClose(window)) {
210
        float currentFrame = static_cast<float>(glfwGetTime());
211
        deltaTime = currentFrame - lastFrame;
212
        lastFrame = currentFrame;
213
                processInput(window);
214
                glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
215
                glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
216

217
        //绘制物体
218
        ourShader.use();
219
        glBindVertexArray(VAO);
220

221
        glm::mat4 model;
222
        ourShader.setMatrix("model", model);
223
        glm::mat4 view;
224
        view = camera.GetCameraView();
225
        ourShader.setMatrix("view", view);
226
        glm::mat4 project;
227
        project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
228
        ourShader.setMatrix("project", project);
229

230
        //传递物体运行时需要更新的uniform变量
231
        ourShader.setVec3("viewPos", camera.Position);
232
        ourShader.setVec3("light.lightPos", lightPos);
233

234
        //绘制贴图
235
        glActiveTexture(GL_TEXTURE0);
236
        glBindTexture(GL_TEXTURE_2D, texture);//设置绘制当前物体所需的纹理
237

238
        glDrawArrays(GL_TRIANGLES, 0, 36);
239

240
        //绘制灯
241
        lightShader.use();
242
        glBindVertexArray(lightVAO);
243
        model = glm::mat4();
244
        model = glm::translate(model, lightPos);//把光源变换到新的位置。看样子我好像在旋转光源，但实际上是计算光源新的位置，然后把光源平移到这个圆形轨道上
245
        model = glm::scale(model, glm::vec3(0.2f));
246
        lightShader.setMatrix("model", model);
247
        lightShader.setMatrix("view", view);
248
        lightShader.setMatrix("project", project);
249
        glDrawArrays(GL_TRIANGLES, 0, 36);
250

251
        glfwSwapBuffers(window);
252
        glfwPollEvents();
253
        }
254
    glDeleteVertexArrays(1, &VAO);
255
    glDeleteVertexArrays(1, &lightVAO);
256
    glDeleteBuffers(1, &VBO);
257
    glfwTerminate();
258
    return 0;
259
}

example2: 使用镜面反射贴图#

根据上面运行的结果，发现整个箱子的高光都比较强，但是实际上，箱子中间的木头部分的高光应该非常弱，金属边框的高光应该比较强。那么我们又遇到了使用漫反射贴图之前的问题，我们希望物体不同地方的高光强度不一样。所以我们引进了镜面反射贴图，他的加载和使用的逻辑和漫反射贴图一致，在片元着色器计算镜面反射光照中，从镜面反射贴图采样得到镜面反射强度，然后计算镜面反射。 BQACAgUAAyEGAASHRsPbAAEWKn1qP1kjiirtewvlDp4dJPVX4TDQSAACgSMAAk05AVZ56zOX7YiLtjwE.png

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4
#include <stb_image.h>
5
#include<iostream>
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

13
using namespace std;
14

15
const unsigned int SCR_WIDTH = 800;
16
const unsigned int SCR_HEIGHT = 600;
17

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

24
glm::vec3 lightPos(1.2f, 1.0f, 2.0f);
25

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

70
    int width, height, nrChannels;
71
    stbi_set_flip_vertically_on_load(true);
72
    unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
73
    if (data) {
74
        GLenum format;
75
        if (nrChannels == 1) {
76
            format = GL_RED;
77
        }
78
        else if (nrChannels == 3) {
79
            format = GL_RGB;
80
        }
81
        else if (nrChannels == 4) {
82
            format = GL_RGBA;
83
        }
84
        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
85
        glGenerateMipmap(GL_TEXTURE_2D);
86
    }
87
    else {
88
        cout << "Failed to load texture" << endl;
89
    }
90
    stbi_image_free(data);
91
    return texture;
92
}
93

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

100
        GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
101
        if (window == NULL) {
102
                cout << "Failed to create window" << endl;
103
                glfwTerminate();
104
                return -1;
105
        }
106
        glfwMakeContextCurrent(window);
107
        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
108
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
109
    glfwSetCursorPosCallback(window, mouseMove_callback);
110
    glfwSetScrollCallback(window, mouse_scroll_callback);
111

112
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
113
                cout << "Failed to load GLAD" << endl;
114
                glfwTerminate();
115
                return -1;
116
        }
117
        glEnable(GL_DEPTH_TEST);
118

119
    float vertices[] = {
120
        // positions          // normals           // texture coords
121
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 0.0f,
122
         0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 0.0f,
123
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 1.0f,
124
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 1.0f,
125
        -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 1.0f,
126
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 0.0f,
127

128
        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,
129
         0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 0.0f,
130
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
131
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
132
        -0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 1.0f,
133
        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,
134

135
        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
136
        -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 1.0f,
137
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
138
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
139
        -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 0.0f,
140
        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
141

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

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

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

164
    unsigned int VBO, VAO;
165
    //处理被照物体的顶点属性
166
    glGenVertexArrays(1, &VAO);
167
    glGenBuffers(1, &VBO);
168
    glBindVertexArray(VAO);
169
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
170
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
171
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
172
    glEnableVertexAttribArray(0);
173
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
174
    glEnableVertexAttribArray(1);
175
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
176
    glEnableVertexAttribArray(2);
177
    glBindVertexArray(0);
178

179
    //处理灯的顶点属性
180
    unsigned int lightVAO;
181
    glGenVertexArrays(1, &lightVAO);
182
    glBindVertexArray(lightVAO);
183
    //二者共用一份VBO，不需要再创建，只需绑定
184
    glBindBuffer(GL_ARRAY_BUFFER, VBO);//告诉lightVAO从哪里读取顶点数据
185
    //也不需要传递顶点数据，因为灯和被照物体共用一份顶点数据，已经在处理物体时传递过了
186
    //设置读取规则
187
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float),(void*)0);
188
    glEnableVertexAttribArray(0);
189
    glBindVertexArray(0);
190

191
    unsigned int diffuseMap = loadTexture("resources/lighting_maps/container2.png");
192
    unsigned int specularMap = loadTexture("resources/lighting_maps/container2_specular.png");
193

194
    //物体的着色器
195
        Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
196
    //光源的着色器
197
    //如果共用一个片元着色器，修改物体颜色将会修改光源颜色，这并不是我们想要的
198
    Shader lightShader("src/Shader/vertexShader.txt", "src/Shader/lightFragmentShader.txt");
199

200
        ourShader.use();
201
        //设置物体运行时不需要改变的uniform变量值
202
    ourShader.setInt("material.diffuse", 0);
203
    ourShader.setInt("material.specular", 1);
204
    ourShader.setFloat("material.shininess", 64.0f);
205

206
    ourShader.setVec3("light.ambient", glm::vec3(0.2f));
207
    ourShader.setVec3("light.diffuse", glm::vec3(0.5f));
208
    ourShader.setVec3("light.specular", glm::vec3(1.0f));
209

210
        while (!glfwWindowShouldClose(window)) {
211
        float currentFrame = static_cast<float>(glfwGetTime());
212
        deltaTime = currentFrame - lastFrame;
213
        lastFrame = currentFrame;
214
                processInput(window);
215
                glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
216
                glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
217

218
        //绘制物体
219
        ourShader.use();
220
        glBindVertexArray(VAO);
221

222
        glm::mat4 model;
223
        ourShader.setMatrix("model", model);
224
        glm::mat4 view;
225
        view = camera.GetCameraView();
226
        ourShader.setMatrix("view", view);
227
        glm::mat4 project;
228
        project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
229
        ourShader.setMatrix("project", project);
230

231
        //传递物体运行时需要更新的uniform变量
232
        ourShader.setVec3("viewPos", camera.Position);
233
        ourShader.setVec3("light.lightPos", lightPos);
234

235
        //绘制贴图
236
        glActiveTexture(GL_TEXTURE0);
237
        glBindTexture(GL_TEXTURE_2D, diffuseMap);//设置绘制当前物体所需的纹理
238
        glActiveTexture(GL_TEXTURE1);
239
        glBindTexture(GL_TEXTURE_2D, specularMap);
240

241
        glDrawArrays(GL_TRIANGLES, 0, 36);
242

243
        //绘制灯
244
        lightShader.use();
245
        glBindVertexArray(lightVAO);
246
        model = glm::mat4();
247
        model = glm::translate(model, lightPos);//把光源变换到新的位置。看样子我好像在旋转光源，但实际上是计算光源新的位置，然后把光源平移到这个圆形轨道上
248
        model = glm::scale(model, glm::vec3(0.2f));
249
        lightShader.setMatrix("model", model);
250
        lightShader.setMatrix("view", view);
251
        lightShader.setMatrix("project", project);
252
        glDrawArrays(GL_TRIANGLES, 0, 36);
253

254
        glfwSwapBuffers(window);
255
        glfwPollEvents();
256
        }
257
    glDeleteVertexArrays(1, &VAO);
258
    glDeleteVertexArrays(1, &lightVAO);
259
    glDeleteBuffers(1, &VBO);
260
    glfwTerminate();
261
    return 0;
262
}

1
//fragmentShader
2
#version 330 core
3
struct Material{
4
        sampler2D diffuse;
5
        sampler2D specular;
6
        float shininess;
7
};
8
struct Light{
9
        vec3 lightPos;
10
        vec3 ambient;
11
        vec3 diffuse;
12
        vec3 specular;
13
};
14
in vec3 worldPos;
15
in vec3 normal;
16
in vec2 Texcoords;
17
uniform Material material;
18
uniform Light light;
19
uniform vec3 viewPos;
20
out vec4 FragColor;
21
void main(){
22
        vec3 ambient = light.ambient*texture(material.diffuse,Texcoords).rgb;
23

24
        vec3 worldNormal=normalize(normal);
25
        vec3 worldLightDir=normalize(light.lightPos-worldPos);
26
        float diff=max(dot(worldNormal,worldLightDir),0.0);
27
        vec3 diffuse=diff*texture(material.diffuse,Texcoords).rgb*light.diffuse;
28

29
        vec3 worldViewDir=normalize(viewPos-worldPos);
30
        vec3 reflectDir=reflect(-worldLightDir,worldNormal);
31
        float spec=pow(max(dot(worldViewDir,reflectDir),0.0),material.shininess);
32
        vec3 specular=spec*texture(material.specular,Texcoords).rgb*light.specular;
33

34
        FragColor = vec4(ambient+diffuse+specular,1.0);
35
}

homework1#

调整光源的环境光、漫反射和镜面光向量，看看它们如何影响箱子的视觉输出。测试：增大或减小环境光，整个箱子各个地方都均匀的增大/减小亮度；增大或减小漫反射，亮度增加/减小没有环境光明显，且明暗对比比改变环境光更为明显；增大或减小镜面光，高光的亮度和范围都增大/减小。

homework2#

尝试在片段着色器中反转镜面光贴图的颜色值，让木头显示镜面高光而钢制边缘不反光（由于钢制边缘中有一些裂缝，边缘仍会显示一些镜面高光，虽然强度会小很多）。思路：在片元着色器中对采样结果的颜色值进行1-反转（texture输出的颜色值在[0-1]之间，反转则是1-） BQACAgUAAyEGAASHRsPbAAEWKoBqP1l7afbTkxzR9NQVftZvRgKdVgAChiMAAk05AVa_HIb0oDlK1jwE.png

1
//fragmentShader
2
vec3 specular=spec*(vec3(1.0)-texture(material.specular,Texcoords).rgb)*light.specular;

箱子中部很亮，金属边框几乎没有高光。

homework3#

使用漫反射贴图创建一个彩色而不是黑白的镜面光贴图，看看结果看起来并不是那么真实了。如果你不会生成的话，可以使用这张彩色的镜面光贴图。思路：直接替换镜面反射贴图。 BQACAgUAAyEGAASHRsPbAAEWKoFqP1mwNN0dV71ixqCM3eR2EuzGMwAChyMAAk05AVZp8Z-r9lu9XzwE.png

homework4#

添加一个叫做放射光贴图(Emission Map)的东西，它是一个储存了每个片段的发光值(Emission Value)的贴图。发光值是一个包含（假设）光源的物体发光(Emit)时可能显现的颜色，这样的话物体就能够忽略光照条件进行发光(Glow)。游戏中某个物体在发光的时候，你通常看到的就是放射光贴图（比如机器人的眼，或是箱子上的灯带）。将这个纹理（作者为 creativesam）作为放射光贴图添加到箱子上，产生这些字母都在发光的效果. 思路：新增自发光贴图的加载、使用逻辑，然后在片元着色器中，新增自发光分量，从自发光贴图中采样。 BQACAgUAAyEGAASHRsPbAAEWKoJqP1oGT0KhL9EhMJ9y7zUG2R4ycAACiyMAAk05AVbjflOPiN-7AAE8BA.png

1
unsigned int diffuseMap = loadTexture("resources/lighting_maps/container2.png");
2
unsigned int specularMap = loadTexture("resources/lighting_maps/container2_specular.png");
3
unsigned int emissiveMap = loadTexture("resources/lighting_maps/matrix.jpg");
4

5
//物体的着色器
6
Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
7
//光源的着色器
8
//如果共用一个片元着色器，修改物体颜色将会修改光源颜色，这并不是我们想要的
9
Shader lightShader("src/Shader/vertexShader.txt", "src/Shader/lightFragmentShader.txt");
10

11
ourShader.use();
12
//设置物体运行时不需要改变的uniform变量值
13
ourShader.setInt("material.diffuse", 0);
14
ourShader.setInt("material.specular", 1);
15
ourShader.setFloat("material.shininess", 64.0f);
16
ourShader.setInt("material.emissive", 2);
17

18
ourShader.setVec3("light.ambient", glm::vec3(0.2f));
19
ourShader.setVec3("light.diffuse", glm::vec3(0.5f));
20
ourShader.setVec3("light.specular", glm::vec3(1.0f));
21

22
while (!glfwWindowShouldClose(window)) {
23
    float currentFrame = static_cast<float>(glfwGetTime());
24
    deltaTime = currentFrame - lastFrame;
25
    lastFrame = currentFrame;
26
        processInput(window);
27
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
28
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
29

30
    //绘制物体
31
    ourShader.use();
32
    glBindVertexArray(VAO);
33

34
    glm::mat4 model;
35
    ourShader.setMatrix("model", model);
36
    glm::mat4 view;
37
    view = camera.GetCameraView();
38
    ourShader.setMatrix("view", view);
39
    glm::mat4 project;
40
    project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
41
    ourShader.setMatrix("project", project);
42

43
    //传递物体运行时需要更新的uniform变量
44
    ourShader.setVec3("viewPos", camera.Position);
45
    ourShader.setVec3("light.lightPos", lightPos);
46

47
    //绘制贴图
48
    glActiveTexture(GL_TEXTURE0);
49
    glBindTexture(GL_TEXTURE_2D, diffuseMap);//设置绘制当前物体所需的纹理
50
    glActiveTexture(GL_TEXTURE1);
51
    glBindTexture(GL_TEXTURE_2D, specularMap);
52
    glActiveTexture(GL_TEXTURE2);
53
    glBindTexture(GL_TEXTURE_2D, emissiveMap);
54

55
    glDrawArrays(GL_TRIANGLES, 0, 36);
56

57
    //绘制灯
58
    lightShader.use();
59
    glBindVertexArray(lightVAO);
60
    model = glm::mat4();
61
    model = glm::translate(model, lightPos);//把光源变换到新的位置。看样子我好像在旋转光源，但实际上是计算光源新的位置，然后把光源平移到这个圆形轨道上
62
    model = glm::scale(model, glm::vec3(0.2f));
63
    lightShader.setMatrix("model", model);
64
    lightShader.setMatrix("view", view);
65
    lightShader.setMatrix("project", project);
66
    glDrawArrays(GL_TRIANGLES, 0, 36);
67

68
    glfwSwapBuffers(window);
69
    glfwPollEvents();
70
}

1
//fragmentShader
2
#version 330 core
3
struct Material{
4
        sampler2D diffuse;
5
        sampler2D specular;
6
        sampler2D emissive;
7
        float shininess;
8
};
9
struct Light{
10
        vec3 lightPos;
11
        vec3 ambient;
12
        vec3 diffuse;
13
        vec3 specular;
14
};
15
in vec3 worldPos;
16
in vec3 normal;
17
in vec2 Texcoords;
18
uniform Material material;
19
uniform Light light;
20
uniform vec3 viewPos;
21
out vec4 FragColor;
22
void main(){
23
        vec3 ambient = light.ambient*texture(material.diffuse,Texcoords).rgb;
24

25
        vec3 worldNormal=normalize(normal);
26
        vec3 worldLightDir=normalize(light.lightPos-worldPos);
27
        float diff=max(dot(worldNormal,worldLightDir),0.0);
28
        vec3 diffuse=diff*texture(material.diffuse,Texcoords).rgb*light.diffuse;
29

30
        vec3 worldViewDir=normalize(viewPos-worldPos);
31
        vec3 reflectDir=reflect(-worldLightDir,worldNormal);
32
        float spec=pow(max(dot(worldViewDir,reflectDir),0.0),material.shininess);
33
        vec3 specular=spec*texture(material.specular,Texcoords).rgb*light.specular;
34

35
        vec3 emissive=texture(material.emissive,Texcoords).rgb;
36
        FragColor = vec4(ambient+diffuse+specular+emissive,1.0);
37
}