投影变换与坐标流水线#

完整坐标变换过程#

投影矩阵的核心作用：将观察空间坐标变换为裁剪空间坐标，再通过GPU自动计算完成后续坐标转换，最终映射为屏幕坐标。完整流水线如下：观察空间（4D坐标，w=1） → 投影变换 → 投影/裁剪空间（4D坐标，w=-z_view） → 透视除法（GPU自动执行） → 3D NDC标准设备坐标 → 视口/深度范围变换 → 屏幕坐标 + 深度缓冲值关键说明：透视除法在每个顶点着色器执行后自动触发，将裁剪空间 x/y/z/w 全部除以w，使新的 w=1 并舍弃，得到归一化NDC坐标。 NDC坐标后续处理：

x、y 分量：经 glViewport 变换，映射为屏幕像素坐标（范围：x:0~宽度，y:0~高度）
z 分量：经 glDepthRange 变换，映射为 0~1 区间，最终存入深度缓冲

两类投影矩阵#

正射投影#

观察空间视锥体为立方体平头截体，通过近平面、远平面的宽、高、距离定义可视范围。正射投影将视锥体内的顶点变换至裁剪空间，变换后所有顶点 w=1，无透视缩放效果，可直接将观察空间坐标映射为NDC坐标，物体大小不受距离影响。 OpenGL 使用（GLM）：

1
// 参数：左、右、下、上、近平面距离、远平面距离
2
glm::ortho(left, right, bottom, top, near, far);

透视投影#

观察空间视锥体为锥形平头截体，截体外部的顶点会被裁剪，不会参与渲染。透视投影不仅将视锥体映射到裁剪空间，还会修改顶点 w 分量：顶点距离观察者越远，w 值越大。经过透视除法后，远距离顶点坐标更小，实现近大远小的真实视觉效果。 OpenGL 使用（GLM）：

1
// 参数：视角fov、屏幕宽高比、近平面距离、远平面距离
2
glm::perspective(fov, aspectRatio, near, far);

MVP变换整体逻辑#

顶点依次经过 M模型变换、V视图变换、P投影变换 后，从模型空间转换到裁剪空间。将最终坐标赋值给 gl_Position，OpenGL 会自动完成透视除法、视锥体裁剪，无需手动干预。

深度缓冲和深度测试#

核心原理#

OpenGL 通过**深度缓冲（Z缓冲）**存储场景像素的深度信息，GLFW 会自动创建深度缓冲。每个渲染片段都携带独立深度值，用于标识像素距离观察者的远近。 深度测试（Depth Testing）：片段输出颜色前，OpenGL 会自动对比当前片段深度值与深度缓冲中已存储的深度值。若当前片段处于后方，直接丢弃；若处于前方，则覆盖颜色与深度缓冲数据，解决物体遮挡错乱问题。

开关与配置代码#

深度测试默认关闭，需手动开启，开启后对比、丢弃、保留逻辑均由GPU自动执行，无需手动编写判断逻辑。

1
// 开启深度测试
2
glEnable(GL_DEPTH_TEST);
3
// 关闭深度测试（仅透明物体等特殊场景使用，无需常规关闭）
4
glDisable(GL_DEPTH_TEST);

深度缓冲清空规则#

开启深度测试后，GPU 会持续写入深度缓冲数据。为避免上一帧深度数据干扰当前帧渲染，每一帧渲染开始前必须清空深度缓冲，与清空颜色缓冲逻辑对应：

1
// 同时清空颜色缓冲与深度缓冲
2
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

example1: 使用MVP矩阵变换之前的平面，使之看起来像在3D空间#

首先对于模型矩阵，这里施加一个旋转，让平面绕着x轴向后旋转，看起来像铺在地面上然后对于视图矩阵，将物体沿着z轴负方向移动，则远离相机。等价于将相机沿着z轴正方向移动最后对于投影矩阵，使用透视投影。

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
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
16
  glViewport(0, 0, width, height);
17
}
18
void processInput(GLFWwindow* window) {
19
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
20
    glfwSetWindowShouldClose(window, true);
21
  }
22
}
23

24
int main() {
25
  glfwInit();
26
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
27
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
28
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
29

30
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
31
  if (window == NULL) {
32
    cout << "Failed to create window" << endl;
33
    glfwTerminate();
34
    return -1;
35
  }
36
  glfwMakeContextCurrent(window);
37
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
38

39
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
40
    cout << "Failed to load GLAD" << endl;
41
    glfwTerminate();
42
    return -1;
43
  }
44

45
  Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
46

47
  float vertices[] = {
48
    0.5f,0.5f,0.0f, 1.0f, 1.0f,
49
    0.5f,-0.5f,0.0f, 1.0f,0.0f,
50
    -0.5f,-0.5f,0.0f, 0.0f,0.0f,
51
    -0.5f,0.5f,0.0f, 0.0f,1.0f
52
  };
53

54
  unsigned int indices[] = {
55
    0,1,3,
56
    1,2,3
57
  };
58

59
  unsigned int VBO, EBO, VAO;
60
  glGenVertexArrays(1, &VAO);
61
  glGenBuffers(1, &VBO);
62
  glGenBuffers(1, &EBO);
63

64
  glBindVertexArray(VAO);
65
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
66
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
67
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
68
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
69

70
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
71
  glEnableVertexAttribArray(0);
72
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
73
  glEnableVertexAttribArray(1);
74

75
  glBindVertexArray(0);
76

77
  unsigned int texture1, texture2;
78
  glGenTextures(1, &texture1);
79
  glBindTexture(GL_TEXTURE_2D, texture1);
80
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
81
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
82
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
83
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
84

85
  int width, height, nrChannels;
86
  stbi_set_flip_vertically_on_load(true);
87
  unsigned char* data = stbi_load("resources/textures/container.jpg", &width, &height, &nrChannels, 0);
88
  if (data) {
89
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
90
    glGenerateMipmap(GL_TEXTURE_2D);
91
  }
92
  else {
93
    cout << "Failed to load image" << endl;
94
  }
95
  stbi_image_free(data);
96

97
  glGenTextures(1, &texture2);
98
  glBindTexture(GL_TEXTURE_2D, texture2);
99
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
100
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
101
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
102
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
103
  data = stbi_load("resources/textures/awesomeface.png", &width, &height, &nrChannels, 0);
104
  if (data) {
105
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
106
    glGenerateMipmap(GL_TEXTURE_2D);
107
  }
108
  else {
109
    cout << "Failed to load image" << endl;
110
  }
111
  stbi_image_free(data);
112

113
  ourShader.use();
114
  ourShader.setInt("texture1", 0);
115
  ourShader.setInt("texture2", 1);
116

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

122
  while (!glfwWindowShouldClose(window)) {
123
    processInput(window);
124

125
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
126
    glClear(GL_COLOR_BUFFER_BIT);
127

128
    glActiveTexture(GL_TEXTURE0);
129
    glBindTexture(GL_TEXTURE_2D, texture1);
130
    glActiveTexture(GL_TEXTURE1);
131
    glBindTexture(GL_TEXTURE_2D, texture2);
132

133
    ourShader.use();
134
    glBindVertexArray(VAO);
135
    glm::mat4 model;
136
    model = glm::rotate(model, glm::radians(-55.0f), glm::vec3(1, 0, 0));
137
    glm::mat4 view;
138
    view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
139

140
    unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
141
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
142
    unsigned int viewLoc = glGetUniformLocation(ourShader.ID, "view");
143
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
144

145
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
146

147
    glfwSwapBuffers(window);
148
    glfwPollEvents();
149
  }
150
  glDeleteVertexArrays(1, &VAO);
151
  glDeleteBuffers(1, &VBO);
152
  glDeleteBuffers(1, &EBO);
153

154
  glfwTerminate();
155
  return 0;
156
}

顶点着色器中需要定义对应的uniform变量，并用这些变换矩阵的组合变换顶点。

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

5
out vec2 ourTexcoord;
6

7
uniform mat4 model;
8
uniform mat4 view;
9
uniform mat4 project;
10
void main(){
11
  gl_Position = project*view*model*vec4(aPos,1.0f);
12
  ourTexcoord = aTexcoord;
13
}

example2: 将平面变为立方体，使之更加立体#

扩充顶点数组，使之包含36个顶点（6个面，每个面2个三角形，每个三角形3个顶点）；然后修改model矩阵，使之随着时间不断旋转。最后使用glDrawArrays绘制。

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
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
16
  glViewport(0, 0, width, height);
17
}
18
void processInput(GLFWwindow* window) {
19
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
20
    glfwSetWindowShouldClose(window, true);
21
  }
22
}
23

24
int main() {
25
  glfwInit();
26
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
27
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
28
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
29

30
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
31
  if (window == NULL) {
32
    cout << "Failed to create window" << endl;
33
    glfwTerminate();
34
    return -1;
35
  }
36
  glfwMakeContextCurrent(window);
37
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
38

39
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
40
    cout << "Failed to load GLAD" << endl;
41
    glfwTerminate();
42
    return -1;
43
  }
44

45
  Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
46

47
  float vertices[] = {
48
  -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
49
   0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
50
   0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
51
   0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
52
  -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
53
  -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
54

55
  -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
56
   0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
57
   0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
58
   0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
59
  -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
60
  -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
61

62
  -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
63
  -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
64
  -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
65
  -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
66
  -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
67
  -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
68

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,  0.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
   0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
75

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

83
  -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
84
   0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
85
   0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
86
   0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
87
  -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
88
  -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
89
  };
90

91
  unsigned int indices[] = {
92
    0,1,3,
93
    1,2,3
94
  };
95

96
  unsigned int VBO, EBO, VAO;
97
  glGenVertexArrays(1, &VAO);
98
  glGenBuffers(1, &VBO);
99
  glGenBuffers(1, &EBO);
100

101
  glBindVertexArray(VAO);
102
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
103
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
104
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
105
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
106

107
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
108
  glEnableVertexAttribArray(0);
109
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
110
  glEnableVertexAttribArray(1);
111

112
  glBindVertexArray(0);
113

114
  unsigned int texture1, texture2;
115
  glGenTextures(1, &texture1);
116
  glBindTexture(GL_TEXTURE_2D, texture1);
117
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
118
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
119
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
120
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
121

122
  int width, height, nrChannels;
123
  stbi_set_flip_vertically_on_load(true);
124
  unsigned char* data = stbi_load("resources/textures/container.jpg", &width, &height, &nrChannels, 0);
125
  if (data) {
126
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
127
    glGenerateMipmap(GL_TEXTURE_2D);
128
  }
129
  else {
130
    cout << "Failed to load image" << endl;
131
  }
132
  stbi_image_free(data);
133

134
  glGenTextures(1, &texture2);
135
  glBindTexture(GL_TEXTURE_2D, texture2);
136
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
137
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
138
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
139
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
140
  data = stbi_load("resources/textures/awesomeface.png", &width, &height, &nrChannels, 0);
141
  if (data) {
142
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
143
    glGenerateMipmap(GL_TEXTURE_2D);
144
  }
145
  else {
146
    cout << "Failed to load image" << endl;
147
  }
148
  stbi_image_free(data);
149

150
  ourShader.use();
151
  ourShader.setInt("texture1", 0);
152
  ourShader.setInt("texture2", 1);
153

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

159
  while (!glfwWindowShouldClose(window)) {
160
    processInput(window);
161

162
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
163
    glClear(GL_COLOR_BUFFER_BIT);
164

165
    glActiveTexture(GL_TEXTURE0);
166
    glBindTexture(GL_TEXTURE_2D, texture1);
167
    glActiveTexture(GL_TEXTURE1);
168
    glBindTexture(GL_TEXTURE_2D, texture2);
169

170
    ourShader.use();
171
    glBindVertexArray(VAO);
172
    glm::mat4 model;
173
    model = glm::rotate(model, (float)glfwGetTime()*glm::radians(50.0f), glm::vec3(0.5, 1.0, 0));
174
    glm::mat4 view;
175
    view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
176

177
    unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
178
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
179
    unsigned int viewLoc = glGetUniformLocation(ourShader.ID, "view");
180
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
181

182
    glDrawArrays(GL_TRIANGLES, 0, 36);
183

184
    glfwSwapBuffers(window);
185
    glfwPollEvents();
186
  }
187
  glDeleteVertexArrays(1, &VAO);
188
  glDeleteBuffers(1, &VBO);
189
  glDeleteBuffers(1, &EBO);
190

191
  glfwTerminate();
192
  return 0;
193
}

上面代码实现的效果有些奇怪，立方体的某些本应被遮挡住的面被绘制在了这个立方体其他面之上。这是因为当使用glDrawArrays时，OpenGL是根据你所指定的顺序绘制三角形的，后画的三角形会覆盖之前画的三角形。如果指定顺序符合从远至近，则绘制效果正常。但如果顺序反了，就不符合常理，看起来很奇怪。通过深度缓冲，可以让OpenGL先比较远近，然后只绘制近的，确保近的遮挡远的。

example3: 开启深度测试#

使用glEnable开启深度测试，OpenGL就会写入深度缓冲并在每次绘制前进行深度比较。因此需要确保深度缓冲是干净的，则需要在渲染循环开头清除深度缓冲。

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
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
16
  glViewport(0, 0, width, height);
17
}
18
void processInput(GLFWwindow* window) {
19
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
20
    glfwSetWindowShouldClose(window, true);
21
  }
22
}
23

24
int main() {
25
  glfwInit();
26
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
27
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
28
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
29

30
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
31
  if (window == NULL) {
32
    cout << "Failed to create window" << endl;
33
    glfwTerminate();
34
    return -1;
35
  }
36
  glfwMakeContextCurrent(window);
37
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
38

39
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
40
    cout << "Failed to load GLAD" << endl;
41
    glfwTerminate();
42
    return -1;
43
  }
44

45
  //开启深度测试
46
  glEnable(GL_DEPTH_TEST);
47

48
  Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
49

50
  float vertices[] = {
51
  -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
52
   0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
53
   0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
54
   0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
55
  -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
56
  -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
57

58
  -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
59
   0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
60
   0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
61
   0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
62
  -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
63
  -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
64

65
  -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
66
  -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
67
  -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
68
  -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
69
  -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
70
  -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
71

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,  0.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
   0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
78

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

86
  -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
87
   0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
88
   0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
89
   0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
90
  -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
91
  -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
92
  };
93

94
  unsigned int indices[] = {
95
    0,1,3,
96
    1,2,3
97
  };
98

99
  unsigned int VBO, EBO, VAO;
100
  glGenVertexArrays(1, &VAO);
101
  glGenBuffers(1, &VBO);
102
  glGenBuffers(1, &EBO);
103

104
  glBindVertexArray(VAO);
105
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
106
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
107
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
108
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
109

110
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
111
  glEnableVertexAttribArray(0);
112
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
113
  glEnableVertexAttribArray(1);
114

115
  glBindVertexArray(0);
116

117
  unsigned int texture1, texture2;
118
  glGenTextures(1, &texture1);
119
  glBindTexture(GL_TEXTURE_2D, texture1);
120
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
121
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
122
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
123
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
124

125
  int width, height, nrChannels;
126
  stbi_set_flip_vertically_on_load(true);
127
  unsigned char* data = stbi_load("resources/textures/container.jpg", &width, &height, &nrChannels, 0);
128
  if (data) {
129
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
130
    glGenerateMipmap(GL_TEXTURE_2D);
131
  }
132
  else {
133
    cout << "Failed to load image" << endl;
134
  }
135
  stbi_image_free(data);
136

137
  glGenTextures(1, &texture2);
138
  glBindTexture(GL_TEXTURE_2D, texture2);
139
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
140
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
141
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
142
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
143
  data = stbi_load("resources/textures/awesomeface.png", &width, &height, &nrChannels, 0);
144
  if (data) {
145
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
146
    glGenerateMipmap(GL_TEXTURE_2D);
147
  }
148
  else {
149
    cout << "Failed to load image" << endl;
150
  }
151
  stbi_image_free(data);
152

153
  ourShader.use();
154
  ourShader.setInt("texture1", 0);
155
  ourShader.setInt("texture2", 1);
156

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

162
  while (!glfwWindowShouldClose(window)) {
163
    processInput(window);
164

165
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
166
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
167

168
    glActiveTexture(GL_TEXTURE0);
169
    glBindTexture(GL_TEXTURE_2D, texture1);
170
    glActiveTexture(GL_TEXTURE1);
171
    glBindTexture(GL_TEXTURE_2D, texture2);
172

173
    ourShader.use();
174
    glBindVertexArray(VAO);
175
    glm::mat4 model;
176
    model = glm::rotate(model, (float)glfwGetTime()*glm::radians(50.0f), glm::vec3(0.5, 1.0, 0));
177
    glm::mat4 view;
178
    view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
179

180
    unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
181
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
182
    unsigned int viewLoc = glGetUniformLocation(ourShader.ID, "view");
183
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
184

185
    glDrawArrays(GL_TRIANGLES, 0, 36);
186

187
    glfwSwapBuffers(window);
188
    glfwPollEvents();
189
  }
190
  glDeleteVertexArrays(1, &VAO);
191
  glDeleteBuffers(1, &VBO);
192
  glDeleteBuffers(1, &EBO);
193

194
  glfwTerminate();
195
  return 0;
196
}

example4: 画更多的箱子#

因为这些箱子的外观、设置都是一样的，区别仅在于世界空间的位置和旋转，所以不用重复定义顶点数组，而是在渲染循环中调用十次glDrawArrays，每次调用前，计算新的模型变换矩阵并传递给着色器。考虑到重复代码较多，可以使用循环。定义十个箱子在世界空间的偏移，然后模型矩阵同时包含旋转和平移。 BQACAgUAAyEGAASHRsPbAAEWKbhqP0BPvNar9Qh-mXoHwwagOnGJigACYiIAAk05AVaw5aYRzVs54TwE.png

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
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
16
  glViewport(0, 0, width, height);
17
}
18
void processInput(GLFWwindow* window) {
19
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
20
    glfwSetWindowShouldClose(window, true);
21
  }
22
}
23

24
int main() {
25
  glfwInit();
26
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
27
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
28
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
29

30
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
31
  if (window == NULL) {
32
    cout << "Failed to create window" << endl;
33
    glfwTerminate();
34
    return -1;
35
  }
36
  glfwMakeContextCurrent(window);
37
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
38

39
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
40
    cout << "Failed to load GLAD" << endl;
41
    glfwTerminate();
42
    return -1;
43
  }
44

45
  //开启深度测试
46
  glEnable(GL_DEPTH_TEST);
47

48
  Shader ourShader("src/Shader/vertexShader.txt", "src/Shader/fragmentShader.txt");
49

50
  float vertices[] = {
51
  -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
52
   0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
53
   0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
54
   0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
55
  -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
56
  -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
57

58
  -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
59
   0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
60
   0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
61
   0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
62
  -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
63
  -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
64

65
  -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
66
  -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
67
  -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
68
  -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
69
  -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
70
  -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
71

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,  0.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
   0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
78

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

86
  -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
87
   0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
88
   0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
89
   0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
90
  -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
91
  -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
92
  };
93

94
  glm::vec3 cubePositions[] = {
95
    glm::vec3(0.0f,  0.0f,  0.0f),
96
    glm::vec3(2.0f,  5.0f, -15.0f),
97
    glm::vec3(-1.5f, -2.2f, -2.5f),
98
    glm::vec3(-3.8f, -2.0f, -12.3f),
99
    glm::vec3(2.4f, -0.4f, -3.5f),
100
    glm::vec3(-1.7f,  3.0f, -7.5f),
101
    glm::vec3(1.3f, -2.0f, -2.5f),
102
    glm::vec3(1.5f,  2.0f, -2.5f),
103
    glm::vec3(1.5f,  0.2f, -1.5f),
104
    glm::vec3(-1.3f,  1.0f, -1.5f)
105
  };
106

107
  unsigned int VBO, VAO;
108
  glGenVertexArrays(1, &VAO);
109
  glGenBuffers(1, &VBO);
110

111
  glBindVertexArray(VAO);
112
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
113
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
114

115
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
116
  glEnableVertexAttribArray(0);
117
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
118
  glEnableVertexAttribArray(1);
119

120
  glBindVertexArray(0);
121

122
  unsigned int texture1, texture2;
123
  glGenTextures(1, &texture1);
124
  glBindTexture(GL_TEXTURE_2D, texture1);
125
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
126
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
127
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
128
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
129

130
  int width, height, nrChannels;
131
  stbi_set_flip_vertically_on_load(true);
132
  unsigned char* data = stbi_load("resources/textures/container.jpg", &width, &height, &nrChannels, 0);
133
  if (data) {
134
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
135
    glGenerateMipmap(GL_TEXTURE_2D);
136
  }
137
  else {
138
    cout << "Failed to load image" << endl;
139
  }
140
  stbi_image_free(data);
141

142
  glGenTextures(1, &texture2);
143
  glBindTexture(GL_TEXTURE_2D, texture2);
144
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
145
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
146
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
147
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
148
  data = stbi_load("resources/textures/awesomeface.png", &width, &height, &nrChannels, 0);
149
  if (data) {
150
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
151
    glGenerateMipmap(GL_TEXTURE_2D);
152
  }
153
  else {
154
    cout << "Failed to load image" << endl;
155
  }
156
  stbi_image_free(data);
157

158
  ourShader.use();
159
  ourShader.setInt("texture1", 0);
160
  ourShader.setInt("texture2", 1);
161

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

167
  while (!glfwWindowShouldClose(window)) {
168
    processInput(window);
169

170
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
171
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
172

173
    glActiveTexture(GL_TEXTURE0);
174
    glBindTexture(GL_TEXTURE_2D, texture1);
175
    glActiveTexture(GL_TEXTURE1);
176
    glBindTexture(GL_TEXTURE_2D, texture2);
177

178
    ourShader.use();
179
    glBindVertexArray(VAO);
180
    glm::mat4 view;
181
    view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
182
    unsigned int viewLoc = glGetUniformLocation(ourShader.ID, "view");
183
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
184

185
    for (unsigned int i = 0; i < 10; i++) {
186
      glm::mat4 model;
187
      model = glm::translate(model, cubePositions[i]);
188
      //model = glm::rotate(model, (float)glfwGetTime() * glm::radians(20.0f), glm::vec3(0.5, 1.0, 0.0));
189
      float angle = 20.0f * i;
190
      model = glm::rotate(model, glm::radians(angle), glm::vec3(1.0f, 0.3f, 0.5f));
191
      unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
192
      glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
193
      glDrawArrays(GL_TRIANGLES, 0, 36);
194
    }
195

196
    glfwSwapBuffers(window);
197
    glfwPollEvents();
198
  }
199
  glDeleteVertexArrays(1, &VAO);
200
  glDeleteBuffers(1, &VBO);
201

202
  glfwTerminate();
203
  return 0;
204
}

homework1#

对GLM的perspective函数中的FoV和aspect-ratio参数进行实验。看能否搞懂它们是如何影响透视平截头体的。测试： fov=45： BQACAgUAAyEGAASHRsPbAAEWKb1qP0CloGxxAouG91NDgj5DyfUpkwACaSIAAk05AVapoCDca3bJQjwE.png fov=20： BQACAgUAAyEGAASHRsPbAAEWKcBqP0DO4Bb8IynEsQj2msldTK3tdQACbCIAAk05AVZKg8pxRiZ9HTwE.png (float)(SCR_WIDTH*0.5)/(float)SCR_HEIGHT： BQACAgUAAyEGAASHRsPbAAEWKcNqP0EFDPkAAQZbdEchlpjgnNRn5OoAAnEiAAJNOQFWflLx2HgTGzY8BA.png 总结：fov变小，可视范围变窄，物体被裁剪，竖直高度变短，但仍需映射到[-1,1]，所以竖直被拉伸，铺满屏幕，视觉放大；宽高比降低，即宽度降低（大于高度降低），视锥体左右收紧，近平面的宽度变小，但仍需映射到[-1,1]，所以物体被横向拉伸。

homework2#

将观察矩阵在各个方向上进行位移，来看看场景是如何改变的。注意把观察矩阵当成摄像机对象。测试：

1
view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
2
view = glm::translate(view, glm::vec3(0.0f, 0.0f, -10.0f));
3
view = glm::translate(view, glm::vec3(0.0f, 0.0f, -0.1f));

BQACAgUAAyEGAASHRsPbAAEWKctqP0Ff834XvGHoEN5s4_A7niySOAACfCIAAk05AVbmwUu-DC3k3TwE.png BQACAgUAAyEGAASHRsPbAAEWKcxqP0F63UWd-2l4QQayBX_vZtAh_AACfSIAAk05AVZgriLcLQVhzDwE.png BQACAgUAAyEGAASHRsPbAAEWKc1qP0GVjYI9mO31UYwrGBYwuD46awACfiIAAk05AVY_b9C3Oz5aMjwE.png 总结：物体z越小，越向z的负半轴移动，则越远离相机，则物体越小；z越大，越向z的正半轴移动，则越靠近相机，则物体越大，且如果向z的正半轴移动距离过大，会跑到相机和视锥体近裁剪面中间或者相机背后，导致看不到物体。对于x和y分量，x减小则向左移动，y减小则向下移动

homework3#

使用模型矩阵只让是3倍数的箱子旋转（以及第1个箱子），而让剩下的箱子保持静止。

思路：在循环内部加一个判断，只对i能整除3的那些箱子施加旋转矩阵

1
for (unsigned int i = 0; i < 10; i++) {
2
  glm::mat4 model;
3
  model = glm::translate(model, cubePositions[i]);
4
  float angle = 20.0f * i;
5
  if (i % 3 == 0) {
6
    angle = glfwGetTime() * 2.0f;
7
    model = glm::rotate(model, angle, glm::vec3(0.5f, 1.0f, 0.0f));
8
  }
9
  unsigned int modelLoc = glGetUniformLocation(ourShader.ID, "model");
10
  glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
11
  glDrawArrays(GL_TRIANGLES, 0, 36);
12
}