相机空间#

构建相机坐标系，需要求解向右、向上、朝向三个标准正交轴，所有向量最终必须进行归一化处理，保证后续计算精度。

核心参数#

相机位置：相机在世界空间中的三维坐标点
相机朝向（Direction）：相机视线的负方向，由相机位置 - 观察目标位置计算得到
初始向上方向：世界空间默认上向量，固定为 (0, 1, 0)

轴向量计算顺序#

向右向量（Right）：由初始向上向量叉乘相机朝向向量得到，结果归一化
真实向上向量（Up）：由已求出的向右向量叉乘相机朝向向量得到，结果归一化，修正初始上向量的倾斜误差
朝向向量（Direction）：计算完成后统一归一化，作为相机-z视线方向

LookAt 视图矩阵（View矩阵）原理#

LookAt矩阵的核心作用：将世界空间坐标变换为相机空间坐标，由平移矩阵和旋转矩阵组合而成。

矩阵变换步骤#

平移矩阵：将整个场景反向平移，把相机位置平移至世界空间原点
旋转矩阵：将相机的 Right、Up、Direction 三个轴，对齐到世界空间的 X、Y、Z 标准轴变换完成后：相机位于坐标原点、视线朝向 -Z 方向，所有物体坐标转换为相机空间坐标，因此 LookAt 矩阵可直接作为 OpenGL 的 View 矩阵参与 MVP 变换。

GLM快速构建View矩阵#

GLM 封装了 glm::lookAt 函数，自动计算并组合平移、旋转矩阵，无需手动推导。

1
// 参数：相机位置、观察目标位置、世界向上向量
2
glm::lookAt(cameraPos, targetPos, glm::vec3(0.0f, 1.0f, 0.0f));

DeltaTime帧时间适配#

问题根源#

输入监听、移动更新函数为每帧执行：高帧率设备每秒钟执行更多次移动逻辑，物体移动距离更长、速度更快；低帧率设备速度更慢，导致不同硬件下相机移动速度不统一。

解决方案：DeltaTime#

定义 deltaTime：上一帧渲染所耗费的时间。

计算方式：deltaTime = 当前帧时间 - 上一帧时间
更新逻辑：每帧计算完成后，将「上一帧时间」更新为当前帧时间，用于下一帧计算
速度适配：用 移动速度 * deltaTime 计算本帧移动距离，帧率越高 deltaTime 越小、单帧移动距离越短，帧率越低 deltaTime 越大、单帧移动距离越长，保证所有硬件每秒移动距离完全一致。

相机欧拉角旋转#

欧拉角基础#

三维物体旋转由三个欧拉角组成：偏航角(Yaw)、俯仰角(Pitch)、翻滚角(Roll)。相机视角控制仅使用偏航角、俯仰角，忽略翻滚角。

偏航角(Yaw)：水平左右旋转，控制相机左右朝向
俯仰角(Pitch)：竖直上下旋转，控制相机上下朝向

鼠标视角更新逻辑#

记录鼠标上一帧坐标与当前帧坐标，计算水平、竖直偏移量
水平偏移量叠加至偏航角，竖直偏移量叠加至俯仰角
通过更新后的 Yaw、Pitch 欧拉角，重新计算相机视线朝向向量，完成视角旋转

GLM 矩阵索引规则#

GLM 矩阵遵循：先列索引，后行索引。示例：

1
glm::mat4 trans;
2
// trans[列索引][行索引]
3
trans[3][0]; // 访问：第4列、第1行元素（第一行第四列）

example1: 让相机在场景中旋转#

使相机在XOZ平面内绕着Y轴旋转，旋转轨迹是一个圆。所以需要不断地更改相机的x坐标和z坐标，并且借助三角函数使它的运动是一个圆。使用相机的新位置构建lookAt矩阵，将其作为view矩阵并作用于物体的顶点，将物体从世界空间变换到相机空间。

代码中radius控制相机绕圈的大小。现在camX=sin,camZ=cos，从上往下看，相机是顺时针旋转，则物体是逆时针旋转。现在相机位置是(camX,0.0,camZ)，和看向的目标(0.0,0.0,0.0)处于同一位置，是正视物体，如果改成(camX,2.0,camZ)，则相机是俯视物体。向上方向确定画面是否歪斜。

1
while (!glfwWindowShouldClose(window)) {
2
  processInput(window);
3

4
  glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
5
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
6

7
  glActiveTexture(GL_TEXTURE0);
8
  glBindTexture(GL_TEXTURE_2D, texture1);
9
  glActiveTexture(GL_TEXTURE1);
10
  glBindTexture(GL_TEXTURE_2D, texture2);
11

12
  ourShader.use();
13
  glBindVertexArray(VAO);
14
  glm::mat4 view;
15
  float radius = 5.0f;
16
  float camX = static_cast<float>(sin(glfwGetTime()) * radius);
17
  float camZ = static_cast<float>(cos(glfwGetTime()) * radius);
18
  view = glm::lookAt(glm::vec3(camX, 0.0, camZ), glm::vec3(0.0, 0.0, 0.0), glm::vec3(0.0, 1.0, 0.0));
19
  unsigned int viewLoc = glGetUniformLocation(ourShader.ID, "view");
20
  glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
21

22
  for (unsigned int i = 0; i < 10; i++) {
23
    glm::mat4 model;
24
    model = glm::translate(model, cubePositions[i]);
25
    float angle = 20.0f * i;
26
    unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
27
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
28
    glDrawArrays(GL_TRIANGLES, 0, 36);
29
  }
30
  glfwSwapBuffers(window);
31
  glfwPollEvents();
32
}

example2: 自由移动相机#

使用wasd按键控制相机的移动。实则是监听按键事件，转化为相机坐标，根据新的坐标构建新的lookAt矩阵。因此把构建lookAt矩阵的三个参数：相机位置、目标位置和向上方向抽离成变量，同时，为了保证相机始终看向正前方的某个位置，目标位置不是固定的，而是由当前相机位置加上一个向前方向的向量得到。

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4
#include <stb_image.h>
5
#include <glm/glm.hpp>
6
#include <glm/gtc/matrix_transform.hpp>
7
#include <glm/gtc/type_ptr.hpp>
8
#include <myShader.h>
9

10
#include <iostream>
11

12
const unsigned int SCR_WIDTH = 800;
13
const unsigned int SCR_HEIGHT = 600;
14

15
glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
16
glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);//相机永远看向-z
17
glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
18

19
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
20
  glViewport(0, 0, width, height);
21
}
22
void processInput(GLFWwindow* window) {
23
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
24
    glfwSetWindowShouldClose(window, true);
25
  }
26
  float cameraSpeed = 0.01f;//每次移动的幅度
27
  if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
28
    cameraPos += cameraSpeed * cameraFront;//ws控制的是相机靠近或远离，而非相机向上或向下，要实现后者得是cameraUp
29
  }
30
  if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
31
    cameraPos -= cameraSpeed * cameraFront;
32
  }
33
  if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
34
    cameraPos -= glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
35
  }
36
  if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
37
    cameraPos += glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
38
  }
39
}
40

41
int main() {
42
  glfwInit();
43
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
44
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
45
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
46

47
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
48
  if (window == NULL) {
49
    cout << "Failed to create window" << endl;
50
    glfwTerminate();
51
    return -1;
52
  }
53
  glfwMakeContextCurrent(window);
54
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
55

56
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
57
    cout << "Failed to load GLAD" << endl;
58
    glfwTerminate();
59
    return -1;
60
  }
61

62
  //开启深度测试
63
  glEnable(GL_DEPTH_TEST);
64

65
  Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
66

67
  float vertices[] = {
68
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
69
     0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
70
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
71
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
72
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
73
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
74

75
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
76
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
77
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
78
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
79
    -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
80
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
81

82
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
83
    -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
84
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
85
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
86
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
87
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
88

89
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
90
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
91
     0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
92
     0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
93
     0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
94
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
95

96
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
97
     0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
98
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
99
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
100
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
101
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
102

103
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
104
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
105
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
106
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
107
    -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
108
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
109
  };
110

111
  glm::vec3 cubePositions[] = {
112
    glm::vec3(0.0f,  0.0f,  0.0f),
113
    glm::vec3(2.0f,  5.0f, -15.0f),
114
    glm::vec3(-1.5f, -2.2f, -2.5f),
115
    glm::vec3(-3.8f, -2.0f, -12.3f),
116
    glm::vec3(2.4f, -0.4f, -3.5f),
117
    glm::vec3(-1.7f,  3.0f, -7.5f),
118
    glm::vec3(1.3f, -2.0f, -2.5f),
119
    glm::vec3(1.5f,  2.0f, -2.5f),
120
    glm::vec3(1.5f,  0.2f, -1.5f),
121
    glm::vec3(-1.3f,  1.0f, -1.5f)
122
  };
123

124
  unsigned int VBO, VAO;
125
  glGenVertexArrays(1, &VAO);
126
  glGenBuffers(1, &VBO);
127

128
  glBindVertexArray(VAO);
129
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
130
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
131

132
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
133
  glEnableVertexAttribArray(0);
134
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
135
  glEnableVertexAttribArray(1);
136

137
  glBindVertexArray(0);
138

139
  unsigned int texture1, texture2;
140
  glGenTextures(1, &texture1);
141
  glBindTexture(GL_TEXTURE_2D, texture1);
142
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
143
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
144
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
145
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
146

147
  int width, height, nrChannels;
148
  stbi_set_flip_vertically_on_load(true);
149
  unsigned char* data = stbi_load("resources/textures/container.jpg", &width, &height, &nrChannels, 0);
150
  if (data) {
151
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
152
    glGenerateMipmap(GL_TEXTURE_2D);
153
  }
154
  else {
155
    cout << "Failed to load image" << endl;
156
  }
157
  stbi_image_free(data);
158

159
  glGenTextures(1, &texture2);
160
  glBindTexture(GL_TEXTURE_2D, texture2);
161
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
162
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
163
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
164
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
165
  data = stbi_load("resources/textures/awesomeface.png", &width, &height, &nrChannels, 0);
166
  if (data) {
167
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
168
    glGenerateMipmap(GL_TEXTURE_2D);
169
  }
170
  else {
171
    cout << "Failed to load image" << endl;
172
  }
173
  stbi_image_free(data);
174

175
  ourShader.use();
176
  ourShader.setInt("texture1", 0);
177
  ourShader.setInt("texture2", 1);
178

179
  glm::mat4 project;//投影矩阵很少变化，在循环外设置
180
  project = glm::perspective(glm::radians(45.0f), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
181
  unsigned int projectLoc = glGetUniformLocation(ourShader.ID, "project");
182
  glUniformMatrix4fv(projectLoc, 1, GL_FALSE, glm::value_ptr(project));
183

184
  while (!glfwWindowShouldClose(window)) {
185
    processInput(window);
186

187
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
188
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
189

190
    glActiveTexture(GL_TEXTURE0);
191
    glBindTexture(GL_TEXTURE_2D, texture1);
192
    glActiveTexture(GL_TEXTURE1);
193
    glBindTexture(GL_TEXTURE_2D, texture2);
194

195
    ourShader.use();
196
    glBindVertexArray(VAO);
197
    glm::mat4 view;
198
    view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
199
    unsigned int viewLoc = glGetUniformLocation(ourShader.ID, "view");
200
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
201

202
    for (unsigned int i = 0; i < 10; i++) {
203
      glm::mat4 model;
204
      model = glm::translate(model, cubePositions[i]);
205
      float angle = 20.0f * i;
206
      unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
207
      glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
208
      glDrawArrays(GL_TRIANGLES, 0, 36);
209
    }
210
    glfwSwapBuffers(window);
211
    glfwPollEvents();
212
  }
213
  glDeleteVertexArrays(1, &VAO);
214
  glDeleteBuffers(1, &VBO);
215

216
  glfwTerminate();
217
  return 0;
218
}

example3: 引入deltaTime均衡不同帧率的系统#

如果camerSpeed是固定的，那么帧率高的系统调用processInput的次数多，移动多，速度快。而引入deltaTime，是系统渲染一帧所花的时间，当deltaTime大，移动速度应该提高以抵消。

引入全局变量deltaTime和lastFrame，在渲染循环中获得当前的时间，减去lastFrame即上一帧的时间，得到deltaTime，然后更新lastFrame=当前的时间。在processInput中使用deltaTime决定cameraSpeed。

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4
#include <stb_image.h>
5
#include <glm/glm.hpp>
6
#include <glm/gtc/matrix_transform.hpp>
7
#include <glm/gtc/type_ptr.hpp>
8
#include <myShader.h>
9

10
#include <iostream>
11

12
const unsigned int SCR_WIDTH = 800;
13
const unsigned int SCR_HEIGHT = 600;
14

15
glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
16
glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);//相机永远看向-z
17
glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
18

19
float deltaTime = 0.0f;
20
float lastFrame = 0.0f;
21

22
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
23
  glViewport(0, 0, width, height);
24
}
25
void processInput(GLFWwindow* window) {
26
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
27
    glfwSetWindowShouldClose(window, true);
28
  }
29
  float cameraSpeed = 0.25f * deltaTime;//每次移动的幅度
30
  if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
31
    cameraPos += cameraSpeed * cameraFront;//ws控制的是相机靠近或远离，而非相机向上或向下，要实现后者得是cameraUp
32
  }
33
  if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
34
    cameraPos -= cameraSpeed * cameraFront;
35
  }
36
  if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
37
    cameraPos -= glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
38
  }
39
  if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
40
    cameraPos += glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
41
  }
42
}
43

44
int main() {
45
  glfwInit();
46
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
47
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
48
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
49

50
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
51
  if (window == NULL) {
52
    cout << "Failed to create window" << endl;
53
    glfwTerminate();
54
    return -1;
55
  }
56
  glfwMakeContextCurrent(window);
57
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
58

59
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
60
    cout << "Failed to load GLAD" << endl;
61
    glfwTerminate();
62
    return -1;
63
  }
64

65
  //开启深度测试
66
  glEnable(GL_DEPTH_TEST);
67

68
  Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
69

70
  float vertices[] = {
71
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
72
     0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
73
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
74
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
75
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
76
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
77

78
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
79
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
80
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
81
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
82
    -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
83
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
84

85
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
86
    -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
87
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
88
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
89
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
90
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
91

92
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
93
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
94
     0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
95
     0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
96
     0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
97
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
98

99
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
100
     0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
101
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
102
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
103
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
104
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
105

106
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
107
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
108
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
109
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
110
    -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
111
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
112
  };
113

114
  glm::vec3 cubePositions[] = {
115
    glm::vec3(0.0f,  0.0f,  0.0f),
116
    glm::vec3(2.0f,  5.0f, -15.0f),
117
    glm::vec3(-1.5f, -2.2f, -2.5f),
118
    glm::vec3(-3.8f, -2.0f, -12.3f),
119
    glm::vec3(2.4f, -0.4f, -3.5f),
120
    glm::vec3(-1.7f,  3.0f, -7.5f),
121
    glm::vec3(1.3f, -2.0f, -2.5f),
122
    glm::vec3(1.5f,  2.0f, -2.5f),
123
    glm::vec3(1.5f,  0.2f, -1.5f),
124
    glm::vec3(-1.3f,  1.0f, -1.5f)
125
  };
126

127
  unsigned int VBO, VAO;
128
  glGenVertexArrays(1, &VAO);
129
  glGenBuffers(1, &VBO);
130

131
  glBindVertexArray(VAO);
132
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
133
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
134

135
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
136
  glEnableVertexAttribArray(0);
137
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
138
  glEnableVertexAttribArray(1);
139

140
  glBindVertexArray(0);
141

142
  unsigned int texture1, texture2;
143
  glGenTextures(1, &texture1);
144
  glBindTexture(GL_TEXTURE_2D, texture1);
145
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
146
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
147
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
148
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
149

150
  int width, height, nrChannels;
151
  stbi_set_flip_vertically_on_load(true);
152
  unsigned char* data = stbi_load("resources/textures/container.jpg", &width, &height, &nrChannels, 0);
153
  if (data) {
154
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
155
    glGenerateMipmap(GL_TEXTURE_2D);
156
  }
157
  else {
158
    cout << "Failed to load image" << endl;
159
  }
160
  stbi_image_free(data);
161

162
  glGenTextures(1, &texture2);
163
  glBindTexture(GL_TEXTURE_2D, texture2);
164
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
165
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
166
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
167
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
168
  data = stbi_load("resources/textures/awesomeface.png", &width, &height, &nrChannels, 0);
169
  if (data) {
170
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
171
    glGenerateMipmap(GL_TEXTURE_2D);
172
  }
173
  else {
174
    cout << "Failed to load image" << endl;
175
  }
176
  stbi_image_free(data);
177

178
  ourShader.use();
179
  ourShader.setInt("texture1", 0);
180
  ourShader.setInt("texture2", 1);
181

182
  glm::mat4 project;//投影矩阵很少变化，在循环外设置
183
  project = glm::perspective(glm::radians(45.0f), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
184
  unsigned int projectLoc = glGetUniformLocation(ourShader.ID, "project");
185
  glUniformMatrix4fv(projectLoc, 1, GL_FALSE, glm::value_ptr(project));
186

187
  while (!glfwWindowShouldClose(window)) {
188
    float currentFrame = static_cast<float>(glfwGetTime());
189
    deltaTime = currentFrame - lastFrame;
190
    lastFrame = currentFrame;
191

192
    processInput(window);
193

194
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
195
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
196

197
    glActiveTexture(GL_TEXTURE0);
198
    glBindTexture(GL_TEXTURE_2D, texture1);
199
    glActiveTexture(GL_TEXTURE1);
200
    glBindTexture(GL_TEXTURE_2D, texture2);
201

202
    ourShader.use();
203
    glBindVertexArray(VAO);
204
    glm::mat4 view;
205
    view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
206
    unsigned int viewLoc = glGetUniformLocation(ourShader.ID, "view");
207
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
208

209
    for (unsigned int i = 0; i < 10; i++) {
210
      glm::mat4 model;
211
      model = glm::translate(model, cubePositions[i]);
212
      float angle = 20.0f * i;
213
      unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
214
      glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
215
      glDrawArrays(GL_TRIANGLES, 0, 36);
216
    }
217
    glfwSwapBuffers(window);
218
    glfwPollEvents();
219
  }
220
  glDeleteVertexArrays(1, &VAO);
221
  glDeleteBuffers(1, &VBO);
222

223
  glfwTerminate();
224
  return 0;
225
}

example4: 鼠标控制相机移动#

鼠标移动的offset转变为相机的俯仰角和偏航角。利用这两个角度重新计算相机的向前方向，再计算相机的lookAt矩阵。加入缩放控制，鼠标滚轮的上下滑动修改fov，进而修改投影矩阵。

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4
#include <stb_image.h>
5
#include <glm/glm.hpp>
6
#include <glm/gtc/matrix_transform.hpp>
7
#include <glm/gtc/type_ptr.hpp>
8
#include <myShader.h>
9

10
#include <iostream>
11

12
const unsigned int SCR_WIDTH = 800;
13
const unsigned int SCR_HEIGHT = 600;
14

15
glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
16
glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);//相机永远看向-z
17
glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
18

19
float deltaTime = 0.0f;
20
float lastFrame = 0.0f;
21

22
bool firstMouse = true;
23
float yaw = -90.0f;//初始偏航角为-90，是因为初始时相机看向-z，即front=(0,0,-1)，根据picth和yaw和front的关系计算得到
24
float pitch = 0.0f;//初始俯仰角为零，表示相机看向水平面
25
float lastX = 400, lastY = 300;//鼠标的初始位置设在屏幕中心
26
float fov = 45.0f;
27

28
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
29
  glViewport(0, 0, width, height);
30
}
31
void processInput(GLFWwindow* window) {
32
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
33
    glfwSetWindowShouldClose(window, true);
34
  }
35
}
36
void mouse_callback(GLFWwindow* window, double xpos, double ypos) {
37
  if (firstMouse) {
38
    lastX = static_cast<float>(xpos);
39
    lastY = static_cast<float>(ypos);
40
    firstMouse = false;
41
  }
42
  float offsetX = static_cast<float>(xpos - lastX);
43
  float offsetY = static_cast<float>(lastY - ypos);//对于GLFW窗口而言，坐标原点是窗口左上角，向下为Y轴增大方向，鼠标坐标也是在这个GLFW窗口内的，也就是向下移动鼠标，鼠标坐标的Y分量是增大的。但是相机坐标系中，向上是Y轴增大方向，所以需要翻转，以符合相机坐标系
44
  lastX = static_cast<float>(xpos);
45
  lastY = static_cast<float>(ypos);//用当前的鼠标位置更新上一帧鼠标位置
46

47
  float sensitivity = 0.05f;
48
  offsetX *= sensitivity;
49
  offsetY *= sensitivity;//用sensitivity控制鼠标移动->相机移动的距离关系，sensitivity=1时，鼠标移动多少->相机移动多少，比较灵敏
50

51
  yaw += offsetX;
52
  pitch += offsetY;
53

54
  if (pitch > 89.0f) {
55
    pitch = 89.0f;
56
  }
57
  if (pitch < -89.0f) {
58
    pitch = -89.0f;
59
  }
60
  //对pitch的角度范围进行限制，当picth=90或-90时，相机看向天空或者地面，这时front和up平行，导致right计算错误（right计算需要借助front和up的叉乘）
61
  glm::vec3 front;
62
  front.x = cos(glm::radians(pitch)) * cos(glm::radians(yaw));
63
  front.y = sin(glm::radians(pitch));
64
  front.z = cos(glm::radians(pitch)) * sin(glm::radians(yaw));
65
  cameraFront = glm::normalize(front);
66
}
67
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
68
  if (fov >= 1.0f && fov <= 45.0f) {
69
    fov -= static_cast<float>(yoffset);//鼠标滚轮向上滚，yoffset是正数，画面应该放大，则fov应该缩小；故fov和yoffset成反比
70
  }
71
  if (fov < 1.0f) {
72
    fov = 1.0f;
73
  }
74
  if (fov > 45.0f) {
75
    fov = 45.0f;
76
  }
77
}
78

79
int main() {
80
  glfwInit();
81
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
82
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
83
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
84

85
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
86
  if (window == NULL) {
87
    cout << "Failed to create window" << endl;
88
    glfwTerminate();
89
    return -1;
90
  }
91
  glfwMakeContextCurrent(window);
92
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
93
  glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);//隐藏光标并限制光变停留在程序窗口中
94
  glfwSetCursorPosCallback(window, mouse_callback);//一旦鼠标移动，则调用回调函数，并将鼠标的位置传递给回调函数
95
  glfwSetScrollCallback(window, scroll_callback);
96

97
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
98
    cout << "Failed to load GLAD" << endl;
99
    glfwTerminate();
100
    return -1;
101
  }
102

103
  //开启深度测试
104
  glEnable(GL_DEPTH_TEST);
105

106
  Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
107

108
  float vertices[] = {
109
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
110
     0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
111
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
112
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
113
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
114
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
115

116
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
117
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
118
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
119
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
120
    -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
121
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
122

123
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
124
    -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
125
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
126
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
127
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
128
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
129

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

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

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

152
  glm::vec3 cubePositions[] = {
153
    glm::vec3(0.0f,  0.0f,  0.0f),
154
    glm::vec3(2.0f,  5.0f, -15.0f),
155
    glm::vec3(-1.5f, -2.2f, -2.5f),
156
    glm::vec3(-3.8f, -2.0f, -12.3f),
157
    glm::vec3(2.4f, -0.4f, -3.5f),
158
    glm::vec3(-1.7f,  3.0f, -7.5f),
159
    glm::vec3(1.3f, -2.0f, -2.5f),
160
    glm::vec3(1.5f,  2.0f, -2.5f),
161
    glm::vec3(1.5f,  0.2f, -1.5f),
162
    glm::vec3(-1.3f,  1.0f, -1.5f)
163
  };
164

165
  unsigned int VBO, VAO;
166
  glGenVertexArrays(1, &VAO);
167
  glGenBuffers(1, &VBO);
168

169
  glBindVertexArray(VAO);
170
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
171
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
172

173
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
174
  glEnableVertexAttribArray(0);
175
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
176
  glEnableVertexAttribArray(1);
177

178
  glBindVertexArray(0);
179

180
  unsigned int texture1, texture2;
181
  glGenTextures(1, &texture1);
182
  glBindTexture(GL_TEXTURE_2D, texture1);
183
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
184
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
185
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
186
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
187

188
  int width, height, nrChannels;
189
  stbi_set_flip_vertically_on_load(true);
190
  unsigned char* data = stbi_load("resources/textures/container.jpg", &width, &height, &nrChannels, 0);
191
  if (data) {
192
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
193
    glGenerateMipmap(GL_TEXTURE_2D);
194
  }
195
  else {
196
    cout << "Failed to load image" << endl;
197
  }
198
  stbi_image_free(data);
199

200
  glGenTextures(1, &texture2);
201
  glBindTexture(GL_TEXTURE_2D, texture2);
202
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
203
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
204
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
205
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
206
  data = stbi_load("resources/textures/awesomeface.png", &width, &height, &nrChannels, 0);
207
  if (data) {
208
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
209
    glGenerateMipmap(GL_TEXTURE_2D);
210
  }
211
  else {
212
    cout << "Failed to load image" << endl;
213
  }
214
  stbi_image_free(data);
215

216
  ourShader.use();
217
  ourShader.setInt("texture1", 0);
218
  ourShader.setInt("texture2", 1);
219

220
  while (!glfwWindowShouldClose(window)) {
221
    float currentFrame = static_cast<float>(glfwGetTime());
222
    deltaTime = currentFrame - lastFrame;
223
    lastFrame = currentFrame;
224

225
    processInput(window);
226

227
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
228
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
229

230
    glActiveTexture(GL_TEXTURE0);
231
    glBindTexture(GL_TEXTURE_2D, texture1);
232
    glActiveTexture(GL_TEXTURE1);
233
    glBindTexture(GL_TEXTURE_2D, texture2);
234

235
    ourShader.use();
236
    glBindVertexArray(VAO);
237
    glm::mat4 view;
238
    view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
239
    unsigned int viewLoc = glGetUniformLocation(ourShader.ID, "view");
240
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
241

242
    glm::mat4 project;//滚轮缩放需要每帧读取用户的输入，所以应该写在循环内
243
    project = glm::perspective(glm::radians(fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
244
    unsigned int projectLoc = glGetUniformLocation(ourShader.ID, "project");
245
    glUniformMatrix4fv(projectLoc, 1, GL_FALSE, glm::value_ptr(project));
246

247
    for (unsigned int i = 0; i < 10; i++) {
248
      glm::mat4 model;
249
      model = glm::translate(model, cubePositions[i]);
250
      float angle = 20.0f * i;
251
      unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
252
      glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
253
      glDrawArrays(GL_TRIANGLES, 0, 36);
254
    }
255
    glfwSwapBuffers(window);
256
    glfwPollEvents();
257
  }
258
  glDeleteVertexArrays(1, &VAO);
259
  glDeleteBuffers(1, &VBO);
260

261
  glfwTerminate();
262
  return 0;
263
}

example5: 将相机的相关变量和方法抽离成相机类#

1
#pragma once
2
#ifndef CAMERA_H
3
#define CAMERA_H
4

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

10
enum Camera_Movement {
11
  FORWARD,
12
  BACKWARD,
13
  LEFT,
14
  RIGHT
15
};
16

17
const float YAW = -90.0f;
18
const float PITCH = 0.0f;
19
const float SPEED = 2.5f;
20
const float SENSITIVITY = 0.1f;
21
const float ZOOM = 45.0f;
22
//这些常量是默认值/初始值，支持创建相机时不传入参数时用这些常量初始化
23
class Camera {
24
public:
25
  glm::vec3 Position;
26
  glm::vec3 Front;
27
  glm::vec3 Up;//相机的向上方向，会根据相机抬头或低头而发生变化
28
  glm::vec3 Right;
29
  glm::vec3 WorldUp;//世界向上方向，永远不变。用于初始化相机向上方向而计算向右方向
30

31
  float Yaw;
32
  float Pitch;
33

34
  float MovementSpeed;
35
  float MouseSensitivity;
36
  float Zoom;
37

38
  Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) :Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM) {
39
    Position = position;
40
    WorldUp = up;//初始化时给的向上方向是世界向上方向，仍需要传入的原因时特殊情况下WorldUp！=（0，1，0）
41
    Yaw = yaw;
42
    Pitch = pitch;
43
    updateCameraVectors();
44
  }//这四个变量是经常要改的，所以允许外部传入，并修改默认值。但同样允许扩充或者减少外部传入参数的数量
45

46
  Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch) :Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM) {
47
    Position = glm::vec3(posX, posY, posZ);
48
    WorldUp = glm::vec3(upX, upY, upZ);
49
    Yaw = yaw;
50
    Pitch = pitch;
51
    updateCameraVectors();
52
  }
53

54
  glm::mat4 GetViewMatrix() {
55
    return glm::lookAt(Position, Position + Front, Up);//计算lookAt矩阵时需要的是相机自己的向上方向
56
  }
57

58
  //相机可支持键盘移动（前后左右）
59
  void processKeyboard(Camera_Movement direction, float deltaTime) {
60
    float velocity = deltaTime * MovementSpeed;
61
    if (direction == FORWARD) {
62
      Position += Front * velocity;
63
    }
64
    if (direction == BACKWARD) {
65
      Position -= Front * velocity;
66
    }
67
    if (direction == LEFT) {
68
      Position -= Right * velocity;
69
    }
70
    if (direction == RIGHT) {
71
      Position += Right * velocity;
72
    }
73
  }
74

75
  //相机可支持鼠标更改看向方向
76
  void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true) {//为什么contrainPitch的类型不是bool？GLFW/OpenGL习惯，本质和bool一样，只是类型名不同
77
    xoffset *= MouseSensitivity;
78
    yoffset *= MouseSensitivity;
79

80
    Yaw += xoffset;
81
    Pitch += yoffset;
82

83
    if (constrainPitch) {//contrainPitch默认情况下是true，表示需要限制相机的俯仰角，但是有些特殊效果（如飞行相机）需要360°旋转，不需要限制
84
      if (Pitch > 89.0f) {
85
        Pitch = 89.0f;
86
      }
87
      if (Pitch < -89.0f) {
88
        Pitch = -89.0f;
89
      }
90
    }
91

92
    updateCameraVectors();
93
  }
94

95
  //相机可支持鼠标滚轮空间画面缩放
96
  void ProcessMouseScroll(float yoffset) {
97
    Zoom -= yoffset;
98
    if (Zoom < 1.0f) {
99
      Zoom = 1.0f;
100
    }
101
    if (Zoom > 45.0f) {
102
      Zoom = 45.0f;
103
    }
104
  }
105

106
private:
107
  //更新相机的三个轴向
108
  void updateCameraVectors() {
109
    glm::vec3 front;
110
    front.x = cos(glm::radians(Pitch)) * cos(glm::radians(Yaw));//glm::cos/glm::sin都必须接收弧度制的输入
111
    front.y = sin(glm::radians(Pitch));
112
    front.z = cos(glm::radians(Pitch)) * sin(glm::radians(Yaw));
113

114
    Front = glm::normalize(front);
115

116
    Right = glm::normalize(glm::cross(Front, WorldUp));
117

118
    Up = glm::normalize(glm::cross(Right, Front));//叉乘的顺序不能换，否则画面上下颠倒
119
  }
120
};
121

122
#endif

1
#define STB_IMAGE_IMPLEMENTATION
2
#include <glad/glad.h>
3
#include <GLFW/glfw3.h>
4
#include <stb_image.h>
5
#include <glm/glm.hpp>
6
#include <glm/gtc/matrix_transform.hpp>
7
#include <glm/gtc/type_ptr.hpp>
8
#include <myShader.h>
9
#include <myCamera.h>
10

11
#include <iostream>
12

13
const unsigned int SCR_WIDTH = 800;
14
const unsigned int SCR_HEIGHT = 600;
15

16
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
17
float lastX = SCR_WIDTH / 2.0f;
18
float lastY = SCR_HEIGHT / 2.0f;
19
bool firstMouse = true;
20

21
float deltaTime = 0.0f;
22
float lastFrame = 0.0f;
23

24
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
25
  glViewport(0, 0, width, height);
26
}
27
void processInput(GLFWwindow* window) {
28
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
29
    glfwSetWindowShouldClose(window, true);
30
  }
31
  if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
32
    camera.processKeyboard(FORWARD, deltaTime);
33
  }
34
  if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
35
    camera.processKeyboard(BACKWARD, deltaTime);
36
  }
37
  if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
38
    camera.processKeyboard(LEFT, deltaTime);
39
  }
40
  if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
41
    camera.processKeyboard(RIGHT, deltaTime);
42
  }
43
}
44
void mouse_callback(GLFWwindow* window, double xpos, double ypos) {
45
  if (firstMouse) {
46
    lastX = static_cast<float>(xpos);
47
    lastY = static_cast<float>(ypos);
48
    firstMouse = false;
49
  }
50
  float offsetX = static_cast<float>(xpos - lastX);
51
  float offsetY = static_cast<float>(lastY - ypos);//对于GLFW窗口而言，坐标原点是窗口左上角，向下为Y轴增大方向，鼠标坐标也是在这个GLFW窗口内的，也就是向下移动鼠标，鼠标坐标的Y分量是增大的。但是相机坐标系中，向上是Y轴增大方向，所以需要翻转，以符合相机坐标系
52
  lastX = static_cast<float>(xpos);
53
  lastY = static_cast<float>(ypos);//用当前的鼠标位置更新上一帧鼠标位置
54

55
  camera.ProcessMouseMovement(offsetX, offsetY, true);
56
}
57
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
58
  camera.ProcessMouseScroll(static_cast<float>(yoffset));
59
}
60

61
int main() {
62
  glfwInit();
63
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
64
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
65
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
66

67
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
68
  if (window == NULL) {
69
    cout << "Failed to create window" << endl;
70
    glfwTerminate();
71
    return -1;
72
  }
73
  glfwMakeContextCurrent(window);
74
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
75
  glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);//隐藏光标并限制光变停留在程序窗口中
76
  glfwSetCursorPosCallback(window, mouse_callback);//一旦鼠标移动，则调用回调函数，并将鼠标的位置传递给回调函数
77
  glfwSetScrollCallback(window, scroll_callback);
78

79
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
80
    cout << "Failed to load GLAD" << endl;
81
    glfwTerminate();
82
    return -1;
83
  }
84

85
  //开启深度测试
86
  glEnable(GL_DEPTH_TEST);
87

88
  Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
89

90
  float vertices[] = {
91
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
92
     0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
93
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
94
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
95
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
96
    -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
97

98
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
99
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
100
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
101
     0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
102
    -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
103
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
104

105
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
106
    -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
107
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
108
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
109
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
110
    -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
111

112
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
113
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
114
     0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
115
     0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
116
     0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
117
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
118

119
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
120
     0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
121
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
122
     0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
123
    -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
124
    -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
125

126
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
127
     0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
128
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
129
     0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
130
    -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
131
    -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
132
  };
133

134
  glm::vec3 cubePositions[] = {
135
    glm::vec3(0.0f,  0.0f,  0.0f),
136
    glm::vec3(2.0f,  5.0f, -15.0f),
137
    glm::vec3(-1.5f, -2.2f, -2.5f),
138
    glm::vec3(-3.8f, -2.0f, -12.3f),
139
    glm::vec3(2.4f, -0.4f, -3.5f),
140
    glm::vec3(-1.7f,  3.0f, -7.5f),
141
    glm::vec3(1.3f, -2.0f, -2.5f),
142
    glm::vec3(1.5f,  2.0f, -2.5f),
143
    glm::vec3(1.5f,  0.2f, -1.5f),
144
    glm::vec3(-1.3f,  1.0f, -1.5f)
145
  };
146

147
  unsigned int VBO, VAO;
148
  glGenVertexArrays(1, &VAO);
149
  glGenBuffers(1, &VBO);
150

151
  glBindVertexArray(VAO);
152
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
153
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
154

155
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
156
  glEnableVertexAttribArray(0);
157
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
158
  glEnableVertexAttribArray(1);
159

160
  glBindVertexArray(0);
161

162
  unsigned int texture1, texture2;
163
  glGenTextures(1, &texture1);
164
  glBindTexture(GL_TEXTURE_2D, texture1);
165
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
166
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
167
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
168
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
169

170
  int width, height, nrChannels;
171
  stbi_set_flip_vertically_on_load(true);
172
  unsigned char* data = stbi_load("resources/textures/container.jpg", &width, &height, &nrChannels, 0);
173
  if (data) {
174
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
175
    glGenerateMipmap(GL_TEXTURE_2D);
176
  }
177
  else {
178
    cout << "Failed to load image" << endl;
179
  }
180
  stbi_image_free(data);
181

182
  glGenTextures(1, &texture2);
183
  glBindTexture(GL_TEXTURE_2D, texture2);
184
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
185
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
186
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
187
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
188
  data = stbi_load("resources/textures/awesomeface.png", &width, &height, &nrChannels, 0);
189
  if (data) {
190
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
191
    glGenerateMipmap(GL_TEXTURE_2D);
192
  }
193
  else {
194
    cout << "Failed to load image" << endl;
195
  }
196
  stbi_image_free(data);
197

198
  ourShader.use();
199
  ourShader.setInt("texture1", 0);
200
  ourShader.setInt("texture2", 1);
201

202
  while (!glfwWindowShouldClose(window)) {
203
    float currentFrame = static_cast<float>(glfwGetTime());
204
    deltaTime = currentFrame - lastFrame;
205
    lastFrame = currentFrame;
206

207
    processInput(window);
208

209
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
210
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
211

212
    glActiveTexture(GL_TEXTURE0);
213
    glBindTexture(GL_TEXTURE_2D, texture1);
214
    glActiveTexture(GL_TEXTURE1);
215
    glBindTexture(GL_TEXTURE_2D, texture2);
216

217
    ourShader.use();
218
    glBindVertexArray(VAO);
219
    glm::mat4 view;
220
    view = camera.GetViewMatrix();
221
    unsigned int viewLoc = glGetUniformLocation(ourShader.ID, "view");
222
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
223

224
    glm::mat4 project;//滚轮缩放需要每帧读取用户的输入，所以应该写在循环内
225
    project = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
226
    unsigned int projectLoc = glGetUniformLocation(ourShader.ID, "project");
227
    glUniformMatrix4fv(projectLoc, 1, GL_FALSE, glm::value_ptr(project));
228

229
    for (unsigned int i = 0; i < 10; i++) {
230
      glm::mat4 model;
231
      model = glm::translate(model, cubePositions[i]);
232
      float angle = 20.0f * i;
233
      unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
234
      glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
235
      glDrawArrays(GL_TRIANGLES, 0, 36);
236
    }
237
    glfwSwapBuffers(window);
238
    glfwPollEvents();
239
  }
240
  glDeleteVertexArrays(1, &VAO);
241
  glDeleteBuffers(1, &VBO);
242

243
  glfwTerminate();
244
  return 0;
245
}

homework1#

看看你是否能够修改摄像机类，使得其能够变成一个真正的FPS摄像机（也就是说不能够随意飞行）；你只能够呆在xz平面上。

思路：当相机俯仰角不等于0时，方向向量的y分量就不为0，那么相机向前移动之后，就可能跑出xoz平面。所以如果要把相机限制在xoz平面上，那么相机的向前移动方向的y分量就不能为0.不限制俯仰角必须为0，而是限制相机移动方向的y分量为0，这样相机还是可以到处看，只是移动限制在水平面了。

1
void ProcessKeyboard(Camera_Movement direction, float deltaTime) {
2
  float velocity = CameraMovementSpeed * deltaTime;
3
  if (direction == FORWARD) {
4
    Position += Front * velocity;
5
  }
6
  if (direction == BACKWARD) {
7
    Position -= Front * velocity;
8
  }
9
  if (direction == LEFT) {
10
    Position -= Right * velocity;
11
  }
12
  if (direction == RIGHT) {
13
    Position += Right * velocity;
14
  }
15
  Position.y = 0;
16
}

homework2#

试着创建你自己的LookAt函数，其中你需要手动创建一个我们在一开始讨论的观察矩阵。用你的函数实现来替换GLM的LookAt函数，看看它是否还能一样地工作。

思路：手动构建LookAt矩阵，包含平移和缩放两部分。主要注意的点是，OpenGL的矩阵索引是列索引在前，行索引在后。

1
glm::mat4 calculate_lookAt_matrix(glm::vec3 position, glm::vec3 target, glm::vec3 worldUp) {
2
  glm::mat4 translateMatrix;
3
  translateMatrix[3][0] = -position.x;
4
  translateMatrix[3][1] = -position.y;
5
  translateMatrix[3][2] = -position.z;
6
  glm::mat4 rotateMatrix;
7
  glm::vec3 zBasis = glm::normalize(position-target);//D
8
  glm::vec3 xBasis = glm::normalize(glm::cross(zBasis, worldUp));//R
9
  glm::vec3 yBasis = glm::normalize(glm::cross(xBasis, zBasis));//U
10
  rotateMatrix[0][0] = xBasis.x;
11
  rotateMatrix[1][0] = xBasis.y;
12
  rotateMatrix[2][0] = xBasis.z;
13
  rotateMatrix[0][1] = yBasis.x;
14
  rotateMatrix[1][1] = yBasis.y;
15
  rotateMatrix[2][1] = yBasis.z;
16
  rotateMatrix[0][2] = zBasis.x;
17
  rotateMatrix[1][2] = zBasis.y;
18
  rotateMatrix[2][2] = zBasis.z;
19
  return rotateMatrix * translateMatrix;
20
}