EBO 详解#

1.VBO：vertex buffer object#

在GPU中开辟一块内存空间，把CPU端的顶点数组，完整拷贝到这块显存里。后续绘制时，GPU直接读显存，不用反复从CPU拿数据，效率高。

VBO是一个数组，存储一长串数字，可以是位置、颜色、纹理坐标、法向量等等，但是它并不知道哪些元素对应位置、哪些元素对应颜色，所以需要显式指定。

OpenGL使用步骤#

定义顶点数据：

1
float vertices[] = {
2
    -0.5f, -0.5f, 0.0f,
3
     0.5f, -0.5f, 0.0f,
4
     0.0f,  0.5f, 0.0f
5
};

创建VBO对象：

1
unsigned int VBO;
2
glGenBuffers(1,&VBO);//生成一个VBO，相当于申请一块显存

绑定VBO对象：

1
glBindBuffer(GL_ARRAY_BUFFER,VBO);//GL_ARRAY_BUFFER是顶点缓冲对象的类型，相当于把这块显存标记为顶点数据缓冲

传递顶点数据：

1
glBufferData(GL_ARRAY_BUFFER,sizeof(vertices),vertices,GL_STATIC_DRAW);//把CPU上的顶点数组复制到GPU的VBO里

2.VAO：vertex array object#

状态容器，记录绘制顶点时所需的全部配置，是VBO的读取规则。内部存有若干条（最多16条，0-15）attribute pointer，每个pointer代表一个顶点属性（位置、颜色等），对应使用glVertexAttribPointer设置的读取规则。

每个规则包含的信息（也就是glVertexAttribPointer的6个参数）：

index：属性索引，在定义顶点属性时用Layout(location=xx)声明的这个属性的编号（比如0就是位置，1就是颜色）
size：分量数，对应这个属性的数据类型的分量数，比如vec3对应size=3
type：数据类型，比如GL_FLOAT和GL_INT等
normalized：是否归一化，GL_TRUE或者GL_FALSE，无符号类型的数据会被归一化到0-1，有符号类型的数据会被归一化到-1-1
stride：步长，在VBO中，同一个属性，第一个值到第二个值之间的字节数
pointer：偏移量，从VBO的第几个字节开始读这个属性

这六个参数会完整的存在VAO的一条attribute pointer中，表明从当前VBO（当前 GL_ARRAY_BUFFER 绑定的 VBO）中读取当前属性的规则。

VAO中还存储了当前绑定的EBO的ID

OpenGL使用步骤#

创建VAO：

1
unsigned int VAO;
2
glGenVertexArrays(1,&VAO);

绑定VAO：标识开始记录配置

1
glBindVertexArray(VAO);

配置VBO、EBO、顶点属性：

1
glBindBuffer(GL_ARRAY_BUFFER,VBO);
2
glBindBuffer(GL_ELEMENT_BUFFER,EBO);
3
glVertexAttribPointer(...);
4
glEnableVertexAttribArray(0);

调用VAO绘制：

1
glBindVertexArray(VAO);
2
glDrawElements(...);

3.EBO：elment buffer object#

一个顶点序号数组，表示顶点绘制顺序。实现顶点复用，减少存储开销。

OpenGL使用步骤#

定义索引数组：

1
unsigned int indices[] = {0,1,2,0,2,3};

创建EBO：

1
unsigned int EBO;
2
glGenBuffers(1,&EBO);

绑定EBO（需要在绑定VAO之后，这样VAO会自动记录这个EBO的ID，调用VAO进行绘制时才能找到对应的EBO）：

1
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO);

传递索引数据：

1
glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(indices),indices,GL_STATIC_DRAW);

调用VAO绘制：

1
glBindVertexArray(VAO);
2
glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_INT,0);
3
//第一个参数是绘制模式，第二个参数是绘制顶点数，第三个参数是索引类型，第四个参数是要读取的第一个数在EBO中的偏移。
4
//GPU从VAO中找到VBO，读取索引，按索引去VAO中找顶点，绘制。

第一份完整的OpenGL程序#

1
//first part: 头文件
2
#include <glad/glad.h>//帮助找到OpenGL的位置，以便可以使用OpenGL函数
3
#include <GLFW/glfw3.h>//GLFW库能够创建窗口、处理鼠标键盘输入
4
#include <iostream>//可以使用cin、cout等函数
5

6
using namespace std;
7

8
//second part: 函数定义
9
//回调函数
10
//当某些事件被触发，这些函数会被自动调用（怎么判定事件发生？用户操作触发事件，操作系统给GLFW发消息，GLFW收到后，自动调用写的回调函数）
11
//编写格式：
12
/*
13
  void 函数名（GLFWwindow* window,其他参数)
14
  {
15
    逻辑代码
16
  }
17
*/
18
//当窗口大小改变时，GLFW自动调用这个函数，让画面自适应窗口大小。传入的width和height就是改变后的窗口大小
19
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
20
  glViewport(0, 0, width, height);//设置OpenGL画图的区域。(0,0)是绘图区域的原点，是左下角
21
};
22
//工具函数定义
23
void processInput(GLFWwindow* window) {//传入指向窗口对象的指针，表示要处理哪个窗口的输入
24
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
25
    glfwSetWindowShouldClose(window, true);//表示这个窗口可以关闭了
26
  }
27
}
28

29
//third part: 窗口大小设置
30
const unsigned int SCR_WIDTH = 800;
31
const unsigned int SCR_HEIGHT = 600;
32

33
//fourth part: 着色器源码
34
//使用const char* ：着色器源码是一段字符串，传给GPU编译
35
const char* vertexShaderSource = "#version 330 core\n"
36
"layout (location = 0) in vec3 aPos;\n"
37
"void main()\n"
38
"{\n"
39
"  gl_Position = vec4(aPos,1.0);\n"
40
"}\n\0";//注意有一个字符结束符
41

42
const char* fragmentShaderSource = "#version 330 core\n"
43
"out vec4 FragColor;\n"
44
"void main()\n"
45
"{\n"
46
"  FragColor = vec4(1.0,0.5,0.2,1.0);\n"
47
"}\n\0";
48

49
//fifth part: 主函数入口、程序入口
50
int main() {
51
  //first task: 初始化GLFW
52
  //怎么理解这四行函数以及重复出现的glfwWindowHint
53
  glfwInit();
54
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//主版本
55
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//次版本。合起来就是要使用OpenGL3.3
56
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//核心模式
57

58
  //second task: 创建窗口
59
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
60
  if (window == NULL) {
61
    cout << "Failed to create GLFW window" << endl;
62
    glfwTerminate();
63
    return -1;
64
  }
65
  //窗口相关设置
66
  glfwMakeContextCurrent(window);//把当前窗口设置为OpenGL绘图上下文
67
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);//注册窗口大小变化回调
68
  //为什么需要注册这个回调？告诉GLFW当窗口大小变了之后，调用这个函数
69

70
  //third task: 初始化GLAD
71
  //OPENGL存在显卡驱动里，每个显卡位置不一样，GLAD负责找到所有OpenGL函数的地址
72
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
73
  {
74
    cout << "Failed to initialize GLAD" << endl;
75
    return -1;
76
  }
77

78
  //fourth task: 着色器相关
79
  //顶点着色器
80
  //创建顶点着色器
81
  unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
82
  //把源码绑定到顶点着色器
83
  glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);//四个参数：着色器参数、源码字符串数量、源码字符串地址、长度（NULL=自动计算）
84
  //编译
85
  glCompileShader(vertexShader);
86
  //检查着色器是否编译成功
87
  int success;
88
  char infoLog[512];
89
  glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);//三个参数：哪个着色器、问什么状态、结果存到哪里。成功：success=1，失败success=0
90
  if (!success) {
91
    glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);//四个形参：着色器、日志大小、NULL、存日志的数组。如果编译失败，给出日志
92
    cout << "ERROR::SHADER::VERTEX::COMPILATION FAILED\n" << infoLog << endl;
93
  }
94

95
  //片元着色器
96
  unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
97
  glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
98
  glCompileShader(fragmentShader);
99
  glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
100
  if (!success) {
101
    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
102
    cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << endl;
103
  }
104

105
  //创建着色器程序
106
  unsigned int shaderProgram = glCreateProgram();
107
  //附加着色器
108
  glAttachShader(shaderProgram, vertexShader);
109
  glAttachShader(shaderProgram, fragmentShader);
110
  //链接着色器
111
  glLinkProgram(shaderProgram);
112
  //检查链接是否成功
113
  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
114
  if (!success) {
115
    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
116
    cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << endl;
117
  }
118
  //删除着色器（为什么可以删除了？编译好的Shader已经复制到shaderProgram中了，原来的Shader就没用了，删除可以省内存）
119
  glDeleteShader(vertexShader);
120
  glDeleteShader(fragmentShader);
121

122
  //fifth task: 定义顶点数据和索引数组
123
  //如果定义了索引数组，顶点数据就可以简洁而不重复的定义了
124
  float vertices[] = {
125
    0.5f,0.5f,0.0f,//右上
126
    0.5f,-0.5f,0.0f,//右下
127
    -0.5f,-0.5f,0.0f,//左下
128
    -0.5f,0.5f,0.0f//左上
129
  };
130
  unsigned int indices[] = {
131
    0,1,3,
132
    1,2,3
133
  };
134

135
  //sixth task: 定义VBO、EBO、VAO对象
136
  unsigned int VBO, VAO, EBO;
137
  //seventh task: 生成VBO、EBO、VAO对象
138
  glGenVertexArrays(1, &VAO);//1表示生成多少个VAO对象
139
  glGenBuffers(1, &VBO);
140
  glGenBuffers(1, &EBO);
141
  //怎么理解上述创建三个对象使用了不同的创建函数？
142
  //VAO是状态记录器，VBO和EBO需要存数据
143

144
  //eigth task: 绑定VAO，开始配置VBO和EBO的属性
145
  glBindVertexArray(VAO);
146
  //ninth task: 绑定VBO，传递数据
147
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
148
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
149

150
  //tenth task: 绑定EBO，传递数据
151
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
152
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
153

154
  //eleven th task: 设置顶点属性
155
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
156
  //并启用
157
  glEnableVertexAttribArray(0);//这里的0和顶点着色器里的layout (location=0)对应，表示第0号属性
158

159
  //twelve th task: 解绑（已经设置完顶点属性了）
160
  //解绑VBO
161
  glBindBuffer(GL_ARRAY_BUFFER, 0);
162
  //解绑VAO
163
  glBindVertexArray(0);
164

165
  //13 th task: 渲染循环
166
  while (!glfwWindowShouldClose(window)) {
167
    //输出处理
168
    processInput(window);
169

170
    //清屏
171
    //设置清屏状态
172
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
173
    glClear(GL_COLOR_BUFFER_BIT);//清空颜色缓冲，把屏幕涂成glClearColor设置的颜色
174

175
    //调用着色器程序
176
    glUseProgram(shaderProgram);
177
    //绑定VAO（设置状态）
178
    glBindVertexArray(VAO);
179
    //画图
180
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
181
    //glDrawArrays(GL_TRIANGLES, 0, 6);
182

183
    //交换缓冲
184
    glfwSwapBuffers(window);
185
    //收集事件并更新相关状态
186
    glfwPollEvents();
187
  }
188
  //14 th task: 释放掉所有创建的
189
  glDeleteVertexArrays(1, &VAO);
190
  glDeleteBuffers(1, &VBO);
191
  glDeleteBuffers(1, &EBO);
192
  glDeleteProgram(shaderProgram);
193

194
  //15 th task: 退出
195
  glfwTerminate();
196
  return 0;
197
}

homework1#

添加更多顶点到数据中，使用glDrawArrays，尝试绘制两个彼此相连的三角形。

思路：删除indices索引数组的定义，删除EBO的相关逻辑（创建、绑定、传递数据、设置状态、释放等）。在vertices数组中定义两个三角形各三个顶点，共6个顶点的数据，顶点之间有重合，但是保证都能构成三角形。绘制时，删除原来的glDrawElements使用glDrawArrays并传入正确的参数。 BQACAgUAAyEGAASHRsPbAAEV1VBqN_Uy-621H6m2Xzgf2M6CP2t0wgACsSIAAqOTwVXeFqPa2vv9ITwE.png

1
//first part: 头文件
2
#include <glad/glad.h>//帮助找到OpenGL的位置，以便可以使用OpenGL函数
3
#include <GLFW/glfw3.h>//GLFW库能够创建窗口、处理鼠标键盘输入
4
#include <iostream>//可以使用cin、cout等函数
5

6
using namespace std;
7

8
//second part: 函数定义
9
//回调函数
10
//当某些事件被触发，这些函数会被自动调用（怎么判定事件发生？用户操作触发事件，操作系统给GLFW发消息，GLFW收到后，自动调用写的回调函数）
11
//编写格式：
12
/*
13
  void 函数名（GLFWwindow* window,其他参数)
14
  {
15
    逻辑代码
16
  }
17
*/
18
//当窗口大小改变时，GLFW自动调用这个函数，让画面自适应窗口大小。传入的width和height就是改变后的窗口大小
19
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
20
  glViewport(0, 0, width, height);//设置OpenGL画图的区域。(0,0)是绘图区域的原点，是左下角
21
};
22
//工具函数定义
23
void processInput(GLFWwindow* window) {//传入指向窗口对象的指针，表示要处理哪个窗口的输入
24
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
25
    glfwSetWindowShouldClose(window, true);//表示这个窗口可以关闭了
26
  }
27
}
28

29
//third part: 窗口大小设置
30
const unsigned int SCR_WIDTH = 800;
31
const unsigned int SCR_HEIGHT = 600;
32

33
//fourth part: 着色器源码
34
//使用const char* ：着色器源码是一段字符串，传给GPU编译
35
const char* vertexShaderSource = "#version 330 core\n"
36
"layout (location = 0) in vec3 aPos;\n"
37
"void main()\n"
38
"{\n"
39
"  gl_Position = vec4(aPos,1.0);\n"
40
"}\n\0";//注意有一个字符结束符
41

42
const char* fragmentShaderSource = "#version 330 core\n"
43
"out vec4 FragColor;\n"
44
"void main()\n"
45
"{\n"
46
"  FragColor = vec4(1.0,0.5,0.2,1.0);\n"
47
"}\n\0";
48

49
//fifth part: 主函数入口、程序入口
50
int main() {
51
  //first task: 初始化GLFW
52
  //怎么理解这四行函数以及重复出现的glfwWindowHint
53
  glfwInit();
54
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//主版本
55
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//次版本。合起来就是要使用OpenGL3.3
56
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//核心模式
57

58
  //second task: 创建窗口
59
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
60
  if (window == NULL) {
61
    cout << "Failed to create GLFW window" << endl;
62
    glfwTerminate();
63
    return -1;
64
  }
65
  //窗口相关设置
66
  glfwMakeContextCurrent(window);//把当前窗口设置为OpenGL绘图上下文
67
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);//注册窗口大小变化回调
68
  //为什么需要注册这个回调？告诉GLFW当窗口大小变了之后，调用这个函数
69

70
  //third task: 初始化GLAD
71
  //OPENGL存在显卡驱动里，每个显卡位置不一样，GLAD负责找到所有OpenGL函数的地址
72
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
73
  {
74
    cout << "Failed to initialize GLAD" << endl;
75
    return -1;
76
  }
77

78
  //fourth task: 着色器相关
79
  //顶点着色器
80
  //创建顶点着色器
81
  unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
82
  //把源码绑定到顶点着色器
83
  glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);//四个参数：着色器参数、源码字符串数量、源码字符串地址、长度（NULL=自动计算）
84
  //编译
85
  glCompileShader(vertexShader);
86
  //检查着色器是否编译成功
87
  int success;
88
  char infoLog[512];
89
  glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);//三个参数：哪个着色器、问什么状态、结果存到哪里。成功：success=1，失败success=0
90
  if (!success) {
91
    glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);//四个形参：着色器、日志大小、NULL、存日志的数组。如果编译失败，给出日志
92
    cout << "ERROR::SHADER::VERTEX::COMPILATION FAILED\n" << infoLog << endl;
93
  }
94

95
  //片元着色器
96
  unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
97
  glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
98
  glCompileShader(fragmentShader);
99
  glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
100
  if (!success) {
101
    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
102
    cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << endl;
103
  }
104

105
  //创建着色器程序
106
  unsigned int shaderProgram = glCreateProgram();
107
  //附加着色器
108
  glAttachShader(shaderProgram, vertexShader);
109
  glAttachShader(shaderProgram, fragmentShader);
110
  //链接着色器
111
  glLinkProgram(shaderProgram);
112
  //检查链接是否成功
113
  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
114
  if (!success) {
115
    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
116
    cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << endl;
117
  }
118
  //删除着色器（为什么可以删除了？编译好的Shader已经复制到shaderProgram中了，原来的Shader就没用了，删除可以省内存）
119
  glDeleteShader(vertexShader);
120
  glDeleteShader(fragmentShader);
121

122
  //fifth task: 定义顶点数据和索引数组
123
  //如果定义了索引数组，顶点数据就可以简洁而不重复的定义了
124
  //如果没有，或者不想使用索引数组和EBO，则需要根据每个三角形实际包含的顶点，定义多个重复的顶点
125
  float vertices[] = {
126
    //第一个三角形
127
    0.5f,0.5f,0.0f,//右上
128
    0.5f,-0.5f,0.0f,//右下
129
    -0.5f,-0.5f,0.0f,//左下
130

131
    //第二个三角形
132
    0.5f,0.5f,0.0f,//右上
133
    -0.5f,0.5f,0.0f,//左上
134
    -0.5f,-0.5f,0.0f//左下
135
  };
136
  unsigned int indices[] = {
137
    0,1,3,
138
    1,2,3
139
  };
140

141
  //sixth task: 定义VBO、EBO、VAO对象
142
  unsigned int VBO, VAO, EBO;
143
  //seventh task: 生成VBO、EBO、VAO对象
144
  glGenVertexArrays(1, &VAO);//1表示生成多少个VAO对象
145
  glGenBuffers(1, &VBO);
146
  glGenBuffers(1, &EBO);
147
  //怎么理解上述创建三个对象使用了不同的创建函数？
148
  //VAO是状态记录器，VBO和EBO需要存数据
149

150
  //eigth task: 绑定VAO，开始配置VBO和EBO的属性
151
  glBindVertexArray(VAO);
152
  //ninth task: 绑定VBO，传递数据
153
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
154
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
155

156
  //tenth task: 绑定EBO，传递数据
157
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
158
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
159

160
  //eleven th task: 设置顶点属性
161
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
162
  //并启用
163
  glEnableVertexAttribArray(0);//这里的0和顶点着色器里的layout (location=0)对应，表示第0号属性
164

165
  //twelve th task: 解绑（已经设置完顶点属性了）
166
  //解绑VBO
167
  glBindBuffer(GL_ARRAY_BUFFER, 0);
168
  //解绑VAO
169
  glBindVertexArray(0);
170

171
  //以线框模式绘制
172
  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
173

174
  //13 th task: 渲染循环
175
  while (!glfwWindowShouldClose(window)) {
176
    //输出处理
177
    processInput(window);
178

179
    //清屏
180
    //设置清屏状态
181
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
182
    glClear(GL_COLOR_BUFFER_BIT);//清空颜色缓冲，把屏幕涂成glClearColor设置的颜色
183

184
    //调用着色器程序
185
    glUseProgram(shaderProgram);
186
    //绑定VAO（设置状态）
187
    glBindVertexArray(VAO);
188
    //画图
189
    //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
190
    glDrawArrays(GL_TRIANGLES, 0, 6);
191

192
    //交换缓冲
193
    glfwSwapBuffers(window);
194
    //收集事件并更新相关状态
195
    glfwPollEvents();
196
  }
197
  //14 th task: 释放掉所有创建的
198
  glDeleteVertexArrays(1, &VAO);
199
  glDeleteBuffers(1, &VBO);
200
  glDeleteBuffers(1, &EBO);
201
  glDeleteProgram(shaderProgram);
202

203
  //15 th task: 退出
204
  glfwTerminate();
205
  return 0;
206
}

homework2#

创建相同的两个三角形，但对它们的数据使用不同的VAO和VBO。

思路：依旧保持删除EBO的相关逻辑。定义两份vertices数组，分别对应两个三角形的顶点数据。每一个三角形拥有独立的VAO、VBO对象，拥有独立的绑定和设置状态的逻辑，拥有独立的渲染绘制逻辑。

1
//first part: 头文件
2
#include <glad/glad.h>//帮助找到OpenGL的位置，以便可以使用OpenGL函数
3
#include <GLFW/glfw3.h>//GLFW库能够创建窗口、处理鼠标键盘输入
4
#include <iostream>//可以使用cin、cout等函数
5

6
using namespace std;
7

8
//second part: 函数定义
9
//回调函数
10
//当某些事件被触发，这些函数会被自动调用（怎么判定事件发生？用户操作触发事件，操作系统给GLFW发消息，GLFW收到后，自动调用写的回调函数）
11
//编写格式：
12
/*
13
  void 函数名（GLFWwindow* window,其他参数)
14
  {
15
    逻辑代码
16
  }
17
*/
18
//当窗口大小改变时，GLFW自动调用这个函数，让画面自适应窗口大小。传入的width和height就是改变后的窗口大小
19
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
20
  glViewport(0, 0, width, height);//设置OpenGL画图的区域。(0,0)是绘图区域的原点，是左下角
21
};
22
//工具函数定义
23
void processInput(GLFWwindow* window) {//传入指向窗口对象的指针，表示要处理哪个窗口的输入
24
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
25
    glfwSetWindowShouldClose(window, true);//表示这个窗口可以关闭了
26
  }
27
}
28

29
//third part: 窗口大小设置
30
const unsigned int SCR_WIDTH = 800;
31
const unsigned int SCR_HEIGHT = 600;
32

33
//fourth part: 着色器源码
34
//使用const char* ：着色器源码是一段字符串，传给GPU编译
35
const char* vertexShaderSource = "#version 330 core\n"
36
"layout (location = 0) in vec3 aPos;\n"
37
"void main()\n"
38
"{\n"
39
"  gl_Position = vec4(aPos,1.0);\n"
40
"}\n\0";//注意有一个字符结束符
41

42
const char* fragmentShaderSource = "#version 330 core\n"
43
"out vec4 FragColor;\n"
44
"void main()\n"
45
"{\n"
46
"  FragColor = vec4(1.0,0.5,0.2,1.0);\n"
47
"}\n\0";
48

49
//fifth part: 主函数入口、程序入口
50
int main() {
51
  //first task: 初始化GLFW
52
  //怎么理解这四行函数以及重复出现的glfwWindowHint
53
  glfwInit();
54
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//主版本
55
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//次版本。合起来就是要使用OpenGL3.3
56
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//核心模式
57

58
  //second task: 创建窗口
59
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
60
  if (window == NULL) {
61
    cout << "Failed to create GLFW window" << endl;
62
    glfwTerminate();
63
    return -1;
64
  }
65
  //窗口相关设置
66
  glfwMakeContextCurrent(window);//把当前窗口设置为OpenGL绘图上下文
67
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);//注册窗口大小变化回调
68
  //为什么需要注册这个回调？告诉GLFW当窗口大小变了之后，调用这个函数
69

70
  //third task: 初始化GLAD
71
  //OPENGL存在显卡驱动里，每个显卡位置不一样，GLAD负责找到所有OpenGL函数的地址
72
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
73
  {
74
    cout << "Failed to initialize GLAD" << endl;
75
    return -1;
76
  }
77

78
  //fourth task: 着色器相关
79
  //顶点着色器
80
  //创建顶点着色器
81
  unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
82
  //把源码绑定到顶点着色器
83
  glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);//四个参数：着色器参数、源码字符串数量、源码字符串地址、长度（NULL=自动计算）
84
  //编译
85
  glCompileShader(vertexShader);
86
  //检查着色器是否编译成功
87
  int success;
88
  char infoLog[512];
89
  glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);//三个参数：哪个着色器、问什么状态、结果存到哪里。成功：success=1，失败success=0
90
  if (!success) {
91
    glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);//四个形参：着色器、日志大小、NULL、存日志的数组。如果编译失败，给出日志
92
    cout << "ERROR::SHADER::VERTEX::COMPILATION FAILED\n" << infoLog << endl;
93
  }
94

95
  //片元着色器
96
  unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
97
  glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
98
  glCompileShader(fragmentShader);
99
  glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
100
  if (!success) {
101
    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
102
    cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << endl;
103
  }
104

105
  //创建着色器程序
106
  unsigned int shaderProgram = glCreateProgram();
107
  //附加着色器
108
  glAttachShader(shaderProgram, vertexShader);
109
  glAttachShader(shaderProgram, fragmentShader);
110
  //链接着色器
111
  glLinkProgram(shaderProgram);
112
  //检查链接是否成功
113
  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
114
  if (!success) {
115
    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
116
    cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << endl;
117
  }
118
  //删除着色器（为什么可以删除了？编译好的Shader已经复制到shaderProgram中了，原来的Shader就没用了，删除可以省内存）
119
  glDeleteShader(vertexShader);
120
  glDeleteShader(fragmentShader);
121

122
  //fifth task: 定义顶点数据和索引数组
123
  //如果定义了索引数组，顶点数据就可以简洁而不重复的定义了
124
  //如果没有，或者不想使用索引数组和EBO，则需要根据每个三角形实际包含的顶点，定义多个重复的顶点
125
  float vertices_tri1[] = {
126
    //第一个三角形
127
    0.5f,0.5f,0.0f,//右上
128
    0.5f,-0.5f,0.0f,//右下
129
    -0.5f,-0.5f,0.0f,//左下
130
  };
131

132
  float vertices_tri2[] = {
133
    //第二个三角形
134
    0.5f,0.5f,0.0f,//右上
135
    -0.5f,0.5f,0.0f,//左上
136
    -0.5f,-0.5f,0.0f//左下
137
  };
138

139
  //sixth task: 定义VBO、VAO对象
140
  //第一个三角形
141
  unsigned int VBO1, VAO1;
142

143
  //第二个三角形
144
  unsigned int VBO2, VAO2;
145

146
  //seventh task: 生成VBO、VAO对象
147
  //第一个三角形
148
  glGenVertexArrays(1, &VAO1);//1表示生成多少个VAO对象
149
  glGenBuffers(1, &VBO1);
150

151

152
  //第二个三角形
153
  glGenVertexArrays(1, &VAO2);
154
  glGenBuffers(1, &VBO2);
155
  //怎么理解上述创建三个对象使用了不同的创建函数？
156
  //VAO是状态记录器，VBO和EBO需要存数据
157

158
  //eigth task: 绑定VAO，开始配置VBO的属性
159
  //第一个三角形
160
  glBindVertexArray(VAO1);
161
  //ninth task: 绑定VBO，传递数据
162
  glBindBuffer(GL_ARRAY_BUFFER, VBO1);
163
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_tri1), vertices_tri1, GL_STATIC_DRAW);
164

165
  //eleven th task: 设置顶点属性
166
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
167
  //并启用
168
  glEnableVertexAttribArray(0);//这里的0和顶点着色器里的layout (location=0)对应，表示第0号属性
169

170
  //twelve th task: 解绑（已经设置完顶点属性了）
171
  //解绑VBO
172
  glBindBuffer(GL_ARRAY_BUFFER, 0);
173
  //解绑VAO
174
  glBindVertexArray(0);
175

176
  //第二个三角形
177
  glBindVertexArray(VAO2);
178
  glBindBuffer(GL_ARRAY_BUFFER, VBO2);
179
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_tri2), vertices_tri2, GL_STATIC_DRAW);
180
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
181
  glEnableVertexAttribArray(0);
182
  glBindBuffer(GL_ARRAY_BUFFER, 0);
183
  glBindVertexArray(0);
184

185
  //以线框模式绘制
186
  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
187

188
  //13 th task: 渲染循环
189
  while (!glfwWindowShouldClose(window)) {
190
    //输出处理
191
    processInput(window);
192

193
    //清屏
194
    //设置清屏状态
195
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
196
    glClear(GL_COLOR_BUFFER_BIT);//清空颜色缓冲，把屏幕涂成glClearColor设置的颜色
197

198
    //调用着色器程序
199
    glUseProgram(shaderProgram);
200

201
    //画第一个三角形
202
    //绑定VAO1（设置状态）
203
    glBindVertexArray(VAO1);
204
    //画图
205
    //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
206
    glDrawArrays(GL_TRIANGLES, 0, 3);
207

208
    //画第二个三角形
209
    glBindVertexArray(VAO2);
210
    glDrawArrays(GL_TRIANGLES, 0, 3);
211

212
    //交换缓冲
213
    glfwSwapBuffers(window);
214
    //收集事件并更新相关状态
215
    glfwPollEvents();
216
  }
217
  //14 th task: 释放掉所有创建的
218
  glDeleteVertexArrays(1, &VAO1);
219
  glDeleteVertexArrays(1, &VAO2);
220
  glDeleteBuffers(1, &VBO1);
221
  glDeleteBuffers(1, &VBO2);
222
  glDeleteProgram(shaderProgram);
223

224
  //15 th task: 退出
225
  glfwTerminate();
226
  return 0;
227
}

homework3#

创建两个着色器程序，第二个程序使用一个不同的片段着色器，输出黄色；再次绘制这两个三角形，让其中一个输出为黄色。

思路：首先编写第二个片元着色器，在main中让FragColor输出为黄色（红+绿）；然后创建第二个片元着色器、编译。（无需创建两个一样的顶点着色器，一个顶点着色器可以参与到多个着色器程序，但是第一个着色器定义链接完之后，不能删除了顶点着色器，因为第二个着色器程序还需要用）。接着创建第二个着色器程序，附加顶点着色器、第二个片元着色器，链接顶点着色器和第二个片元着色器。链接完毕后，可以删除顶点着色器和第二个片元着色器。在渲染循环中，分两次画，分别绘制第一和第二个三角形，分别激活第一和第二个着色器程序。 BQACAgUAAyEGAASHRsPbAAEV1VdqN_W0bYdg1F7sHttWzXlTzHAauQACuSIAAqOTwVVaQxjcIlyQ6DwE.png

1
//first part: 头文件
2
#include <glad/glad.h>//帮助找到OpenGL的位置，以便可以使用OpenGL函数
3
#include <GLFW/glfw3.h>//GLFW库能够创建窗口、处理鼠标键盘输入
4
#include <iostream>//可以使用cin、cout等函数
5

6
using namespace std;
7

8
//second part: 函数定义
9
//回调函数
10
//当某些事件被触发，这些函数会被自动调用（怎么判定事件发生？用户操作触发事件，操作系统给GLFW发消息，GLFW收到后，自动调用写的回调函数）
11
//编写格式：
12
/*
13
  void 函数名（GLFWwindow* window,其他参数)
14
  {
15
    逻辑代码
16
  }
17
*/
18
//当窗口大小改变时，GLFW自动调用这个函数，让画面自适应窗口大小。传入的width和height就是改变后的窗口大小
19
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
20
  glViewport(0, 0, width, height);//设置OpenGL画图的区域。(0,0)是绘图区域的原点，是左下角
21
};
22
//工具函数定义
23
void processInput(GLFWwindow* window) {//传入指向窗口对象的指针，表示要处理哪个窗口的输入
24
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
25
    glfwSetWindowShouldClose(window, true);//表示这个窗口可以关闭了
26
  }
27
}
28

29
//third part: 窗口大小设置
30
const unsigned int SCR_WIDTH = 800;
31
const unsigned int SCR_HEIGHT = 600;
32

33
//fourth part: 着色器源码
34
//使用const char* ：着色器源码是一段字符串，传给GPU编译
35
const char* vertexShaderSource = "#version 330 core\n"
36
"layout (location = 0) in vec3 aPos;\n"
37
"void main()\n"
38
"{\n"
39
"  gl_Position = vec4(aPos,1.0);\n"
40
"}\n\0";//注意有一个字符结束符
41

42
//第一个片元着色器
43
const char* fragmentShaderSource = "#version 330 core\n"
44
"out vec4 FragColor;\n"
45
"void main()\n"
46
"{\n"
47
"  FragColor = vec4(1.0,0.5,0.2,1.0);\n"
48
"}\n\0";
49

50
//第二个片元着色器
51
const char* fragmentShaderSource2 = "#version 330 core\n"
52
"out vec4 FragColor;\n"
53
"void main()\n"
54
"{\n"
55
"  FragColor = vec4(1.0,1.0,0,1.0);\n"
56
"}\n\0";
57

58
//fifth part: 主函数入口、程序入口
59
int main() {
60
  //first task: 初始化GLFW
61
  //怎么理解这四行函数以及重复出现的glfwWindowHint
62
  glfwInit();
63
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//主版本
64
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//次版本。合起来就是要使用OpenGL3.3
65
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//核心模式
66

67
  //second task: 创建窗口
68
  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
69
  if (window == NULL) {
70
    cout << "Failed to create GLFW window" << endl;
71
    glfwTerminate();
72
    return -1;
73
  }
74
  //窗口相关设置
75
  glfwMakeContextCurrent(window);//把当前窗口设置为OpenGL绘图上下文
76
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);//注册窗口大小变化回调
77
  //为什么需要注册这个回调？告诉GLFW当窗口大小变了之后，调用这个函数
78

79
  //third task: 初始化GLAD
80
  //OPENGL存在显卡驱动里，每个显卡位置不一样，GLAD负责找到所有OpenGL函数的地址
81
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
82
  {
83
    cout << "Failed to initialize GLAD" << endl;
84
    return -1;
85
  }
86

87
  //fourth task: 着色器相关
88
  //顶点着色器
89
  //创建顶点着色器
90
  unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
91
  //把源码绑定到顶点着色器
92
  glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);//四个参数：着色器参数、源码字符串数量、源码字符串地址、长度（NULL=自动计算）
93
  //编译
94
  glCompileShader(vertexShader);
95
  //检查着色器是否编译成功
96
  int success;
97
  char infoLog[512];
98
  glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);//三个参数：哪个着色器、问什么状态、结果存到哪里。成功：success=1，失败success=0
99
  if (!success) {
100
    glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);//四个形参：着色器、日志大小、NULL、存日志的数组。如果编译失败，给出日志
101
    cout << "ERROR::SHADER::VERTEX::COMPILATION FAILED\n" << infoLog << endl;
102
  }
103

104
  //片元着色器
105
  //第一个片元着色器
106
  unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
107
  glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
108
  glCompileShader(fragmentShader);
109
  glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
110
  if (!success) {
111
    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
112
    cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << endl;
113
  }
114

115
  //第二个片元着色器
116
  unsigned int fragmentShader2 = glCreateShader(GL_FRAGMENT_SHADER);
117
  glShaderSource(fragmentShader2, 1, &fragmentShaderSource2, NULL);
118
  glCompileShader(fragmentShader2);
119
  glGetShaderiv(fragmentShader2, GL_COMPILE_STATUS, &success);
120
  if (!success) {
121
    glGetShaderInfoLog(fragmentShader2, 512, NULL, infoLog);
122
    cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << endl;
123
  }
124

125
  //创建着色器程序
126
  //第一个着色器程序
127
  unsigned int shaderProgram = glCreateProgram();
128
  //附加着色器
129
  glAttachShader(shaderProgram, vertexShader);
130
  glAttachShader(shaderProgram, fragmentShader);
131
  //链接着色器
132
  glLinkProgram(shaderProgram);
133
  //检查链接是否成功
134
  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
135
  if (!success) {
136
    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
137
    cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << endl;
138
  }
139
  //删除着色器（为什么可以删除了？编译好的Shader已经复制到shaderProgram中了，原来的Shader就没用了，删除可以省内存）
140
  glDeleteShader(fragmentShader);//只能先删fragmentShader，vertexShader第二个着色器程序还需要用
141

142
  //第二个着色器程序
143
  unsigned int shaderProgram2 = glCreateProgram();
144
  glAttachShader(shaderProgram2, vertexShader);
145
  glAttachShader(shaderProgram2, fragmentShader2);
146
  glLinkProgram(shaderProgram2);
147
  glGetProgramiv(shaderProgram2, GL_LINK_STATUS, &success);
148
  if (!success) {
149
    glGetProgramInfoLog(shaderProgram2, 512, NULL, infoLog);
150
    cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << endl;
151
  }
152
  glDeleteShader(vertexShader);
153
  glDeleteShader(fragmentShader2);
154

155
  //fifth task: 定义顶点数据和索引数组
156
  //如果定义了索引数组，顶点数据就可以简洁而不重复的定义了
157
  //如果没有，或者不想使用索引数组和EBO，则需要根据每个三角形实际包含的顶点，定义多个重复的顶点
158
  float vertices_tri1[] = {
159
    //第一个三角形
160
    0.5f,0.5f,0.0f,//右上
161
    0.5f,-0.5f,0.0f,//右下
162
    -0.5f,-0.5f,0.0f,//左下
163
  };
164

165
  float vertices_tri2[] = {
166
    //第二个三角形
167
    0.5f,0.5f,0.0f,//右上
168
    -0.5f,0.5f,0.0f,//左上
169
    -0.5f,-0.5f,0.0f//左下
170
  };
171

172
  //sixth task: 定义VBO、VAO对象
173
  //第一个三角形
174
  unsigned int VBO1, VAO1;
175

176
  //第二个三角形
177
  unsigned int VBO2, VAO2;
178

179
  //seventh task: 生成VBO、VAO对象
180
  //第一个三角形
181
  glGenVertexArrays(1, &VAO1);//1表示生成多少个VAO对象
182
  glGenBuffers(1, &VBO1);
183

184

185
  //第二个三角形
186
  glGenVertexArrays(1, &VAO2);
187
  glGenBuffers(1, &VBO2);
188
  //怎么理解上述创建三个对象使用了不同的创建函数？
189
  //VAO是状态记录器，VBO和EBO需要存数据
190

191
  //上面创建多个VAO和VBO对象还可以使用数组，更为简洁
192
  //unsigned int VBOs[2],VAOs[2];
193
  //glGenVertexArrays(2,VAOs);//数组名即是地址
194
  //glGenBuffers(2,VBOs);
195
  //使用时是VBOs[0],VBOs[1];VAOs[0],VAOs[1]
196

197
  //eigth task: 绑定VAO，开始配置VBO的属性
198
  //第一个三角形
199
  glBindVertexArray(VAO1);
200
  //ninth task: 绑定VBO，传递数据
201
  glBindBuffer(GL_ARRAY_BUFFER, VBO1);
202
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_tri1), vertices_tri1, GL_STATIC_DRAW);
203

204
  //eleven th task: 设置顶点属性
205
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
206
  //并启用
207
  glEnableVertexAttribArray(0);//这里的0和顶点着色器里的layout (location=0)对应，表示第0号属性
208

209
  //twelve th task: 解绑（已经设置完顶点属性了）
210
  //解绑VBO
211
  glBindBuffer(GL_ARRAY_BUFFER, 0);
212
  //解绑VAO
213
  glBindVertexArray(0);
214

215
  //第二个三角形
216
  glBindVertexArray(VAO2);
217
  glBindBuffer(GL_ARRAY_BUFFER, VBO2);
218
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_tri2), vertices_tri2, GL_STATIC_DRAW);
219
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
220
  glEnableVertexAttribArray(0);
221
  glBindBuffer(GL_ARRAY_BUFFER, 0);
222
  glBindVertexArray(0);
223

224
  //13 th task: 渲染循环
225
  while (!glfwWindowShouldClose(window)) {
226
    //输出处理
227
    processInput(window);
228

229
    //清屏
230
    //设置清屏状态
231
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
232
    glClear(GL_COLOR_BUFFER_BIT);//清空颜色缓冲，把屏幕涂成glClearColor设置的颜色
233

234
    //画第一个三角形
235
    //调用着色器程序
236
    glUseProgram(shaderProgram);
237
    //绑定VAO1（设置状态）
238
    glBindVertexArray(VAO1);
239
    //画图
240
    //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
241
    glDrawArrays(GL_TRIANGLES, 0, 3);
242

243
    //画第二个三角形
244
    glUseProgram(shaderProgram2);
245
    glBindVertexArray(VAO2);
246
    glDrawArrays(GL_TRIANGLES, 0, 3);
247

248
    //交换缓冲
249
    glfwSwapBuffers(window);
250
    //收集事件并更新相关状态
251
    glfwPollEvents();
252
  }
253
  //14 th task: 释放掉所有创建的
254
  glDeleteVertexArrays(1, &VAO1);
255
  glDeleteVertexArrays(1, &VAO2);
256
  glDeleteBuffers(1, &VBO1);
257
  glDeleteBuffers(1, &VBO2);
258
  glDeleteProgram(shaderProgram);
259
  glDeleteProgram(shaderProgram2);
260

261
  //15 th task: 退出
262
  glfwTerminate();
263
  return 0;
264
}