example1: 将三种光源的光照计算分别封装成函数，然后合并使用到一个场景中#

在片元着色器中定义三个函数，分别计算平行光、点光源和聚光灯的光照，然后在main函数中调用合并到最后输出光照中。计算的逻辑和上一章实现的一样，就不再说明。特别的是，由于场景中有多个点光源，所以在片元着色器中定义了一个点光源结构体数组，每个元素都是一个点光源结构体。对于光照计算函数来说，它计算的是一个点光源的光照。而每个点光源的光照都需要叠加到最终的输出光照中，所以需要遍历数组。此外，在main.cpp主程序中，平行光和聚光灯不用绘制（实体），只需要传uniform属性；点光源需要绘制（实体），且要传uniform属性。对于点光源实体的绘制，定义了一个位置数组，作为每个光源的model矩阵的平移分量，循环绘制每一个点光源（实体）；对于点光源uniform属性的传递，因为要按uniform属性名传递，所以不能直接使用循环，而是需要拼接属性名，再传入；或者就直接一个个传入。在编写过程中也出现了不少bug：1.片元着色器中的void main写成了int main；2.片元着色器中定义了结构体，但是没有声明结构体的uniform变量3.片元着色器中的in属性名和顶点着色器的out属性名不一致4.直接在字符串里写拼接uniform变量名 BQACAgUAAyEGAASHRsPbAAEWKphqP1y86RkNk9YQwdOQd5_WFRt9agACpSMAAk05AVaJPFZ8LTFTFTwE.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 <cstdio>
7
#include <glm/glm.hpp>
8
#include <glm/gtc/matrix_transform.hpp>
9
#include <glm/gtc/type_ptr.hpp>
10

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

14
using namespace std;
15

16
const unsigned int SCR_WIDTH = 800;
17
const unsigned int SCR_HEIGHT = 600;
18
#define NR_POINT_LIGHTS 4
19

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

26
glm::vec3 lightPos(1.2f, 1.0f, 2.0f);
27

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

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

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

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

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

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

130
        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,
131
         0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 0.0f,
132
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
133
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
134
        -0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 1.0f,
135
        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,
136

137
        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
138
        -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 1.0f,
139
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
140
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
141
        -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 0.0f,
142
        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
143

144
         0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
145
         0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f,
146
         0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
147
         0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
148
         0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  0.0f, 0.0f,
149
         0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
150

151
        -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f, 1.0f,
152
         0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  1.0f, 1.0f,
153
         0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f, 0.0f,
154
         0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f, 0.0f,
155
        -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  0.0f, 0.0f,
156
        -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f, 1.0f,
157

158
        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f, 1.0f,
159
         0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  1.0f, 1.0f,
160
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f, 0.0f,
161
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f, 0.0f,
162
        -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  0.0f, 0.0f,
163
        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f, 1.0f
164
    };
165

166
    glm::vec3 cubePositions[] = {
167
        glm::vec3(0.0f,  0.0f,  0.0f),
168
        glm::vec3(2.0f,  5.0f, -15.0f),
169
        glm::vec3(-1.5f, -2.2f, -2.5f),
170
        glm::vec3(-3.8f, -2.0f, -12.3f),
171
        glm::vec3(2.4f, -0.4f, -3.5f),
172
        glm::vec3(-1.7f,  3.0f, -7.5f),
173
        glm::vec3(1.3f, -2.0f, -2.5f),
174
        glm::vec3(1.5f,  2.0f, -2.5f),
175
        glm::vec3(1.5f,  0.2f, -1.5f),
176
        glm::vec3(-1.3f,  1.0f, -1.5f)
177
    };
178

179
    glm::vec3 pointLightPositions[] = {
180
        glm::vec3(0.7f,  0.2f,  2.0f),
181
        glm::vec3(2.3f, -3.3f, -4.0f),
182
        glm::vec3(-4.0f,  2.0f, -12.0f),
183
        glm::vec3(0.0f,  0.0f, -3.0f)
184
    };
185

186
    glEnable(GL_DEPTH_TEST);
187

188
    unsigned int VBO, VAO;
189
    //处理被照物体的顶点属性
190
    glGenVertexArrays(1, &VAO);
191
    glGenBuffers(1, &VBO);
192
    glBindVertexArray(VAO);
193
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
194
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
195
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
196
    glEnableVertexAttribArray(0);
197
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
198
    glEnableVertexAttribArray(1);
199
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
200
    glEnableVertexAttribArray(2);
201
    glBindVertexArray(0);
202

203
    //处理灯的顶点属性
204
    unsigned int lightVAO;
205
    glGenVertexArrays(1, &lightVAO);
206
    glBindVertexArray(lightVAO);
207
    //二者共用一份VBO，不需要再创建，只需绑定
208
    glBindBuffer(GL_ARRAY_BUFFER, VBO);//告诉lightVAO从哪里读取顶点数据
209
    //也不需要传递顶点数据，因为灯和被照物体共用一份顶点数据，已经在处理物体时传递过了
210
    //设置读取规则
211
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float),(void*)0);
212
    glEnableVertexAttribArray(0);
213
    glBindVertexArray(0);
214

215
    unsigned int diffuseMap = loadTexture("resources/lighting_maps/container2.png");
216
    unsigned int specularMap = loadTexture("resources/lighting_maps/container2_specular.png");
217

218
    //物体的着色器
219
        Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
220
    //光源的着色器
221
    //如果共用一个片元着色器，修改物体颜色将会修改光源颜色，这并不是我们想要的
222
    Shader lightShader("src/Shader/vertexShader.txt", "src/Shader/lightFragmentShader.txt");
223

224
        ourShader.use();
225
        //设置物体运行时不需要改变的uniform变量值
226
    ourShader.setInt("material.diffuse", 0);
227
    ourShader.setInt("material.specular", 1);
228
    ourShader.setFloat("material.shininess", 32.0f);
229

230
    //设置平行光光照属性
231
    ourShader.setVec3("dirLight.direction", glm::vec3(-0.2f,-1.0f,-0.3f));
232
    ourShader.setVec3("dirLight.ambient", glm::vec3(0.05f));
233
    ourShader.setVec3("dirLight.diffuse", glm::vec3(0.4f));
234
    ourShader.setVec3("dirLight.specular", glm::vec3(0.5f));
235
    //设置点光源光照属性
236
    /*for (int i = 0; i < NR_POINT_LIGHTS; i++) {
237
        ourShader.setVec3("pointLights[i].position", pointLightPositions[i]);
238
        ourShader.setFloat("pointLights[i].constant", 1.0f);
239
        ourShader.setFloat("pointLights[i].linear", 0.09f);
240
        ourShader.setFloat("pointLights[i].quadratic", 0.032f);
241
        ourShader.setVec3("pointLights[i].ambient", glm::vec3(0.05f));
242
        ourShader.setVec3("pointLights[i].diffuse", glm::vec3(0.8f));
243
        ourShader.setVec3("pointLights[i].specular", glm::vec3(1.0f));
244
    }*///上面这种写法是错误的，C++不会把循环变量i填入字符串中，而是会把整个带i的字符串当作一个整体
245
    //所以要么一个个设置，要么使用sprintf拼接字符串
246
    char uniformName[128];
247
    for (int i = 0; i < NR_POINT_LIGHTS; i++) {
248
        sprintf_s(uniformName, "pointLights[%d].position", i);//这里是为了设置灯光结构体中变量的值，渲染循环中使用是为了设置绘制灯光立方体的model矩阵，二者缺一不可
249
        ourShader.setVec3(uniformName, pointLightPositions[i]);
250

251
        sprintf_s(uniformName, "pointLights[%d].constant", i);
252
        ourShader.setFloat(uniformName, 1.0f);
253

254
        sprintf_s(uniformName, "pointLights[%d].linear", i);
255
        ourShader.setFloat(uniformName, 0.09f);
256

257
        sprintf_s(uniformName, "pointLights[%d].quadratic", i);
258
        ourShader.setFloat(uniformName, 0.032f);
259

260
        sprintf_s(uniformName, "pointLights[%d].ambient", i);
261
        ourShader.setVec3(uniformName, glm::vec3(0.05f));
262

263
        sprintf_s(uniformName, "pointLights[%d].diffuse", i);
264
        ourShader.setVec3(uniformName, glm::vec3(0.8f));
265

266
        sprintf_s(uniformName, "pointLights[%d].specular", i);
267
        ourShader.setVec3(uniformName, glm::vec3(1.0f));
268
    }
269
    //设置聚光灯光照属性
270
    ourShader.setFloat("spotLight.cutOff", glm::cos(glm::radians(12.5f)));
271
    ourShader.setFloat("spotLight.outerCutOff", glm::cos(glm::radians(15.0f)));
272
    ourShader.setFloat("spotLight.constant", 1.0f);
273
    ourShader.setFloat("spotLight.linear", 0.09f);
274
    ourShader.setFloat("spotLight.quadratic", 0.032f);
275
    ourShader.setVec3("spotLight.ambient", glm::vec3(0.0f));
276
    ourShader.setVec3("spotLight.diffuse", glm::vec3(1.0f));
277
    ourShader.setVec3("spotLight.specular", glm::vec3(1.0f));
278

279
        while (!glfwWindowShouldClose(window)) {
280
        float currentFrame = static_cast<float>(glfwGetTime());
281
        deltaTime = currentFrame - lastFrame;
282
        lastFrame = currentFrame;
283
                processInput(window);
284
                glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
285
                glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
286

287
        //绘制物体
288
        ourShader.use();
289
        glBindVertexArray(VAO);
290
        glm::mat4 model;
291
        ourShader.setMatrix("model", model);
292
        glm::mat4 view;
293
        view = camera.GetCameraView();
294
        ourShader.setMatrix("view", view);
295
        glm::mat4 project;
296
        project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
297
        ourShader.setMatrix("project", project);
298

299
        //传递物体运行时需要更新的uniform变量
300
        ourShader.setVec3("viewPos", camera.Position);
301
        //传递运行时需要更新的灯光变量
302
        ourShader.setVec3("spotLight.position", camera.Position);
303
        ourShader.setVec3("spotLight.direction", camera.Front);
304

305
        //绘制贴图
306
        glActiveTexture(GL_TEXTURE0);
307
        glBindTexture(GL_TEXTURE_2D, diffuseMap);
308
        glActiveTexture(GL_TEXTURE1);
309
        glBindTexture(GL_TEXTURE_2D, specularMap);
310

311
        for (unsigned int i = 0; i < 10; i++) {
312
            model = glm::mat4(1.0);
313
            model = glm::translate(model, cubePositions[i]);
314
            float angle = 20.0f * i;
315
            model = glm::rotate(model, glm::radians(angle), glm::vec3(1.0f, 0.3f, 0.5f));
316
            ourShader.setMatrix("model", model);
317
            glDrawArrays(GL_TRIANGLES, 0, 36);
318
        }
319

320
        //绘制点光源
321
        lightShader.use();
322
        glBindVertexArray(lightVAO);
323
        for (int i = 0; i < NR_POINT_LIGHTS; i++) {
324
            glm::mat4 model;
325
            model = glm::translate(model, pointLightPositions[i]);
326
            model = glm::scale(model, glm::vec3(0.2f));
327
            lightShader.setMatrix("model", model);
328
            lightShader.setMatrix("view", view);
329
            lightShader.setMatrix("project", project);
330
            glDrawArrays(GL_TRIANGLES, 0, 36);
331
        }
332
        glfwSwapBuffers(window);
333
        glfwPollEvents();
334
        }
335
    glDeleteVertexArrays(1, &VAO);
336
    glDeleteVertexArrays(1, &lightVAO);
337
    glDeleteBuffers(1, &VBO);
338
    glfwTerminate();
339
    return 0;
340
}

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

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

1
//fragmentShader
2
#version 330 core
3
in vec3 Normal;
4
in vec2 Texcoords;
5
in vec3 worldPos;
6
out vec4 FragColor;
7
struct Material{
8
        sampler2D diffuse;
9
        sampler2D specular;
10
        float shininess;
11
};
12
struct DirLight{
13
        vec3 direction;
14

15
        vec3 ambient;
16
        vec3 diffuse;
17
        vec3 specular;
18
};
19
struct PointLight{
20
        vec3 position;
21

22
        float constant;
23
        float linear;
24
        float quadratic;
25

26
        vec3 ambient;
27
        vec3 diffuse;
28
        vec3 specular;
29
};
30
struct SpotLight{
31
        vec3 position;
32
        vec3 direction;
33
        float cutOff;
34
        float outerCutOff;
35

36
        float constant;
37
        float linear;
38
        float quadratic;
39

40
        vec3 ambient;
41
        vec3 diffuse;
42
        vec3 specular;
43
};
44
uniform Material material;
45
uniform DirLight dirLight;
46
#define NR_POINT_LIGHTS 4
47
uniform PointLight pointLights[NR_POINT_LIGHTS];//定义了结构体数组，每个元素都是一个结构体
48
uniform SpotLight spotLight;
49
uniform vec3 viewPos;
50
vec3 CalcDirLight(DirLight light,vec3 worldNormal,vec3 worldViewDir){
51
        vec3 worldLightDir=normalize(-light.direction);
52
        float diff=max(dot(worldNormal,worldLightDir),0.0f);
53

54
        vec4 texColor=texture(material.diffuse,Texcoords);
55
        vec3 ambient=light.ambient*texColor.rgb;
56
        vec3 diffuse=light.diffuse*diff*texColor.rgb;
57
        vec3 reflectDir=reflect(-worldLightDir,worldNormal);
58
        float spec=pow(max(dot(worldViewDir,reflectDir),0.0f),material.shininess);
59
        vec3 specular=light.specular*spec*texture(material.specular,Texcoords).rgb;
60

61
        return (ambient+diffuse+specular);
62
}
63
vec3 CalcPointLight(PointLight light,vec3 worldNormal,vec3 worldViewDir){
64
        vec3 worldLightDir=normalize(light.position-worldPos);
65
        vec4 texColor=texture(material.diffuse,Texcoords);
66

67
        float diff=max(dot(worldNormal,worldLightDir),0.0f);
68
        vec3 ambient=light.ambient*texColor.rgb;
69
        vec3 diffuse=light.diffuse*diff*texColor.rgb;
70
        vec3 reflectDir=reflect(-worldLightDir,worldNormal);
71
        float spec=pow(max(dot(worldViewDir,reflectDir),0.0f),material.shininess);
72
        vec3 specular=light.specular*spec*texture(material.specular,Texcoords).rgb;
73

74
        float distance=length(light.position-worldPos);
75
        float atten=(1.0) / (light.constant+light.linear*distance+light.quadratic*distance*distance);
76

77
        return (ambient+diffuse+specular)*atten;
78
}
79
vec3 CalcSpotLight(SpotLight light,vec3 worldNormal,vec3 worldViewDir){
80
        vec3 worldLightDir=normalize(light.position-worldPos);
81
        vec4 texColor=texture(material.diffuse,Texcoords);
82
        vec4 specularColor=texture(material.specular,Texcoords);
83

84
        float theta=dot(worldLightDir,normalize(-light.direction));//不需要max(,0),而且时取light.direction的反
85
        float intensity=clamp((theta-light.outerCutOff)/(light.cutOff-light.outerCutOff),0.0,1.0);
86

87
        vec3 ambient=light.ambient*texColor.rgb;
88
        float diff=max(dot(worldLightDir,worldNormal),0.0f);
89
        vec3 diffuse=light.diffuse*diff*texColor.rgb;
90
        vec3 reflectDir=reflect(-worldLightDir,worldNormal);
91
        float spec=pow(max(dot(worldViewDir,reflectDir),0.0f),material.shininess);
92
        vec3 specular=light.specular*spec*specularColor.rgb;
93

94
        float distance=length(light.position-worldPos);
95
        float atten=(1.0)/(light.constant+light.linear*distance+light.quadratic*distance*distance);
96

97
        return (ambient+(diffuse+specular)*intensity)*atten;
98
}
99
void main(){
100
        vec3 worldNormal=normalize(Normal);
101
        vec3 worldViewDir=normalize(viewPos-worldPos);
102

103
        vec3 result=CalcDirLight(dirLight,worldNormal,worldViewDir);
104
        for(int i=0;i<NR_POINT_LIGHTS;i++){
105
                result+=CalcPointLight(pointLights[i],worldNormal,worldViewDir);
106
        }
107
        result+=CalcSpotLight(spotLight,worldNormal,worldViewDir);
108
        FragColor=vec4(result,1.0);
109
}

homework1#

你能通过调节光照属性变量，（大概地）重现最后一张图片上不同的氛围吗？思路：通过修改清屏颜色(glClearColor)、光照属性变量（各个光源的ambient、diffuse和specular），实现不同风格的场景。如沙漠： BQACAgUAAyEGAASHRsPbAAEWKpxqP11dUsfMjzWILSwsHjfIIe1o4QACqSMAAk05AVY7dIrmGF7iCDwE.png

1
//设置了点光源的光照颜色，既用于实现点光源的ambient/diffuse和specular，也用于在场景中绘制点光源（立方体实体）时的颜色
2
glm::vec3 pointLightColors[] = {
3
    glm::vec3(1.0f,0.6f,0.0f),
4
    glm::vec3(1.0f,0.0f,0.0f),
5
    glm::vec3(1.0f,1.0f,0.0f),
6
    glm::vec3(0.2f,0.2f,1.0f)
7
};
8
//设置平行光的光照颜色
9
ourShader.setVec3("dirLight.ambient", glm::vec3(0.3f,0.24f,0.14f));
10
ourShader.setVec3("dirLight.diffuse", glm::vec3(0.7f,0.42f,0.26f));
11
ourShader.setVec3("dirLight.specular", glm::vec3(0.5f));
12
//设置点光源的光照颜色（重点是设置ambient/diffuse和specular）
13
char uniformName[128];
14
for (int i = 0; i < NR_POINT_LIGHTS; i++) {
15
    sprintf_s(uniformName, "pointLights[%d].position", i);//这里是为了设置灯光结构体中变量的值，渲染循环中使用是为了设置绘制灯光立方体的model矩阵，二者缺一不可
16
    ourShader.setVec3(uniformName, pointLightPositions[i]);
17

18
    sprintf_s(uniformName, "pointLights[%d].constant", i);
19
    ourShader.setFloat(uniformName, 1.0f);
20

21
    sprintf_s(uniformName, "pointLights[%d].linear", i);
22
    ourShader.setFloat(uniformName, 0.09f);
23

24
    sprintf_s(uniformName, "pointLights[%d].quadratic", i);
25
    ourShader.setFloat(uniformName, 0.032f);
26

27
    sprintf_s(uniformName, "pointLights[%d].ambient", i);
28
    ourShader.setVec3(uniformName, glm::vec3(pointLightColors[i].x*0.1,pointLightColors[i].y*0.1,pointLightColors[i].z*0.1));
29

30
    sprintf_s(uniformName, "pointLights[%d].diffuse", i);
31
    ourShader.setVec3(uniformName, glm::vec3(pointLightColors[i].x,pointLightColors[i].y,pointLightColors[i].z));
32

33
    sprintf_s(uniformName, "pointLights[%d].specular", i);
34
    ourShader.setVec3(uniformName, glm::vec3(pointLightColors[i].x, pointLightColors[i].y, pointLightColors[i].z));
35
}
36
//设置聚光灯的光照属性
37
ourShader.setVec3("spotLight.ambient", glm::vec3(0.0f));
38
ourShader.setVec3("spotLight.diffuse", glm::vec3(0.8f, 0.8f, 0.0f));
39
ourShader.setVec3("spotLight.specular", glm::vec3(0.8f,0.8f,0.0f));
40
//清屏颜色
41
glClearColor(0.75f, 0.52f, 0.3f, 1.0f);

为了使得场景中的点光源实体也带上我们设置的pointLightColors的颜色，那么需要在lightShader的片元着色器中增加lightColor属性，并在cpp中绘制光源立方体时传递。

1
//lightFragmentShader
2
#version 330 core
3
out vec4 FragColor;
4
uniform vec3 lightColor;
5
void main(){
6
        FragColor=vec4(lightColor,1.0);
7
}

1
//绘制点光源
2
lightShader.use();
3
glBindVertexArray(lightVAO);
4
for (int i = 0; i < NR_POINT_LIGHTS; i++) {
5
    glm::mat4 model;
6
    model = glm::translate(model, pointLightPositions[i]);
7
    model = glm::scale(model, glm::vec3(0.2f));
8
    lightShader.setMatrix("model", model);
9
    lightShader.setMatrix("view", view);
10
    lightShader.setMatrix("project", project);
11
    lightShader.setVec3("lightColor", glm::vec3(pointLightColors[i].x, pointLightColors[i].y, pointLightColors[i].z));
12
    glDrawArrays(GL_TRIANGLES, 0, 36);
13
}

如工厂： BQACAgUAAyEGAASHRsPbAAEWKp5qP12awT43YgtQ6_LSXKlJzv2X_AACqyMAAk05AVaI7qiXkff3TDwE.png

1
//所有光源颜色的设置都是比较暗且偏蓝色
2
//点光源颜色
3
glm::vec3 pointLightColors[] = {
4
    glm::vec3(0.2f,0.2f,0.6f),
5
    glm::vec3(0.3f,0.3f,0.7f),
6
    glm::vec3(0.0f,0.0f,0.3f),
7
    glm::vec3(0.4f,0.4f,0.4f)
8
};
9
//平行光
10
ourShader.setVec3("dirLight.ambient", glm::vec3(0.05f,0.05f,0.1f));
11
ourShader.setVec3("dirLight.diffuse", glm::vec3(0.2f,0.2f,0.7f));
12
ourShader.setVec3("dirLight.specular", glm::vec3(0.7f));
13
//点光源ambient/diffuse/specular的设置代码同沙漠
14
//聚光灯
15
ourShader.setVec3("spotLight.ambient", glm::vec3(0.0f));
16
ourShader.setVec3("spotLight.diffuse", glm::vec3(1.0f));
17
ourShader.setVec3("spotLight.specular", glm::vec3(1.0f));
18
//清屏颜色
19
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
20
//绘制点光源的代码以及顶点着色器的代码同沙漠

如恐怖： BQACAgUAAyEGAASHRsPbAAEWKp9qP13MBL-udTz8kMAcYAifPp_VoAACrSMAAk05AVb1-6XCxLkUKzwE.png

1
//整体色调较黑暗，且几乎没有环境光
2
//点光源颜色
3
glm::vec3 pointLightColors[] = {
4
    glm::vec3(0.1f,0.1f,0.1f),
5
    glm::vec3(0.1f,0.1f,0.1f),
6
    glm::vec3(0.1f,0.1f,0.1f),
7
    glm::vec3(0.3f,0.1f,0.1f)
8
};
9
//平行光
10
ourShader.setVec3("dirLight.ambient", glm::vec3(0.0f));
11
ourShader.setVec3("dirLight.diffuse", glm::vec3(0.05f));
12
ourShader.setVec3("dirLight.specular", glm::vec3(0.2f));
13
//点光源，调整了衰减效果，使得光照传播距离更短了
14
char uniformName[128];
15
for (int i = 0; i < NR_POINT_LIGHTS; i++) {
16
    sprintf_s(uniformName, "pointLights[%d].position", i);//这里是为了设置灯光结构体中变量的值，渲染循环中使用是为了设置绘制灯光立方体的model矩阵，二者缺一不可
17
    ourShader.setVec3(uniformName, pointLightPositions[i]);
18

19
    sprintf_s(uniformName, "pointLights[%d].constant", i);
20
    ourShader.setFloat(uniformName, 1.0f);
21

22
    sprintf_s(uniformName, "pointLights[%d].linear", i);
23
    ourShader.setFloat(uniformName, 0.14f);
24

25
    sprintf_s(uniformName, "pointLights[%d].quadratic", i);
26
    ourShader.setFloat(uniformName, 0.07f);
27

28
    sprintf_s(uniformName, "pointLights[%d].ambient", i);
29
    ourShader.setVec3(uniformName, glm::vec3(pointLightColors[i].x*0.1,pointLightColors[i].y*0.1,pointLightColors[i].z*0.1));
30

31
    sprintf_s(uniformName, "pointLights[%d].diffuse", i);
32
    ourShader.setVec3(uniformName, glm::vec3(pointLightColors[i].x,pointLightColors[i].y,pointLightColors[i].z));
33

34
    sprintf_s(uniformName, "pointLights[%d].specular", i);
35
    ourShader.setVec3(uniformName, glm::vec3(pointLightColors[i].x, pointLightColors[i].y, pointLightColors[i].z));
36
}
37
//聚光灯，调整了灯光的边缘衰减以及三个分量的颜色
38
ourShader.setFloat("spotLight.cutOff", glm::cos(glm::radians(10.0f)));
39
ourShader.setFloat("spotLight.outerCutOff", glm::cos(glm::radians(15.0f)));
40
ourShader.setFloat("spotLight.constant", 1.0f);
41
ourShader.setFloat("spotLight.linear", 0.09f);
42
ourShader.setFloat("spotLight.quadratic", 0.032f);
43
ourShader.setVec3("spotLight.ambient", glm::vec3(0.0f));
44
ourShader.setVec3("spotLight.diffuse", glm::vec3(1.0f));
45
ourShader.setVec3("spotLight.specular", glm::vec3(1.0f));
46
//绘制点光源实体的代码和顶点着色器的代码与之前的案例一致
47
//清屏颜色
48
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

如生物实验室： BQACAgUAAyEGAASHRsPbAAEWKqBqP137raTr3rH0QjqU_X4U2ChO4gACriMAAk05AVZbiKg_xHpyYTwE.png

1
glm::vec3 pointLightColors[] = {
2
    glm::vec3(0.4f,0.7f,0.1f),
3
    glm::vec3(0.4f,0.7f,0.1f),
4
    glm::vec3(0.4f,0.7f,0.1f),
5
    glm::vec3(0.4f,0.7f,0.1f)
6
};
7
ourShader.setVec3("dirLight.ambient", glm::vec3(0.5f));
8
ourShader.setVec3("dirLight.diffuse", glm::vec3(1.0f));
9
ourShader.setVec3("dirLight.specular", glm::vec3(1.0f));
10
//点光源光照，修改了衰减系数，使得光源能够到达更远的地方
11
char uniformName[128];
12
for (int i = 0; i < NR_POINT_LIGHTS; i++) {
13
    sprintf_s(uniformName, "pointLights[%d].position", i);//这里是为了设置灯光结构体中变量的值，渲染循环中使用是为了设置绘制灯光立方体的model矩阵，二者缺一不可
14
    ourShader.setVec3(uniformName, pointLightPositions[i]);
15

16
    sprintf_s(uniformName, "pointLights[%d].constant", i);
17
    ourShader.setFloat(uniformName, 1.0f);
18

19
    sprintf_s(uniformName, "pointLights[%d].linear", i);
20
    ourShader.setFloat(uniformName, 0.07f);
21

22
    sprintf_s(uniformName, "pointLights[%d].quadratic", i);
23
    ourShader.setFloat(uniformName, 0.017f);
24

25
    sprintf_s(uniformName, "pointLights[%d].ambient", i);
26
    ourShader.setVec3(uniformName, glm::vec3(pointLightColors[i].x*0.1,pointLightColors[i].y*0.1,pointLightColors[i].z*0.1));
27

28
    sprintf_s(uniformName, "pointLights[%d].diffuse", i);
29
    ourShader.setVec3(uniformName, glm::vec3(pointLightColors[i].x,pointLightColors[i].y,pointLightColors[i].z));
30

31
    sprintf_s(uniformName, "pointLights[%d].specular", i);
32
    ourShader.setVec3(uniformName, glm::vec3(pointLightColors[i].x, pointLightColors[i].y, pointLightColors[i].z));
33
}
34
//修改了控制边缘衰减的内切光角和外切光角，过渡区域更短
35
ourShader.setFloat("spotLight.cutOff", glm::cos(glm::radians(7.0f)));
36
ourShader.setFloat("spotLight.outerCutOff", glm::cos(glm::radians(10.0f)));
37
ourShader.setFloat("spotLight.constant", 1.0f);
38
ourShader.setFloat("spotLight.linear", 0.07f);
39
ourShader.setFloat("spotLight.quadratic", 0.017f);
40
ourShader.setVec3("spotLight.ambient", glm::vec3(0.0f));
41
ourShader.setVec3("spotLight.diffuse", glm::vec3(0.0f,1.0f,0.0f));
42
ourShader.setVec3("spotLight.specular", glm::vec3(0.0f, 1.0f, 0.0f));