几张图看明白VAO、VBO、EBO的关系和代码顺序

0.详细教程可看https://learnopengl-cn.github.io/01%20Getting%20started/04%20Hello%20Triangle/

1.可以简单地认为VAO的作用是这样的：

由于每渲染一次物体就要用一个VBO，而每次绑定一次VBO就要设置各个的顶点的属性，启动各个属性，代码十分复杂，复用性很差，因为每个物体的属性个数什么的都不一样（也就是说不是同构的），循环根本解决不了。所以就抽象出一层VAO来解决这个问题，相当于复用代码，使之简介快速。只在一开始将所有的VBO绑定对应的VAO就OK了，之后渲染的时候完全就可以绑定VAO，然后你就循环处理同构的VAO就好了。

2.其实EBO的作用也可以简单地理解为复用跟减少冗余，貌似还可以节约内存跟缓存：

否则的话VBO中储存大量的数据

3.VAO中存储着VBO的信息和EBO的信息

所以正确的绑定顺序是VAO、VBO、EBO,将后两者的信息也绑定进VAO中去啊

如果不适用VAO的话，那么最后一部分每次渲染都要设置第四部分的顶点属性，要好多行好多行，而用了VAO就一行绑定VAO就OK了啊，嘻嘻

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

 #include <glad/glad.h>
 #include <GLFW/glfw3.h>

 #include <iostream>

 void framebuffer_size_callback(GLFWwindow* window, int width, int height);
 void processInput(GLFWwindow *window);

 // settings
 const unsigned int SCR_WIDTH = ;
 const unsigned int SCR_HEIGHT = ;

 const char *vertexShaderSource = "#version 330 core\n"
     "layout (location = 0) in vec3 aPos;\n"
     "void main()\n"
     "{\n"
     "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
     "}\0";
 const char *fragmentShaderSource = "#version 330 core\n"
     "out vec4 FragColor;\n"
     "void main()\n"
     "{\n"
     "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
     "}\n\0";

 int main()
 {
     // glfw: initialize and configure
     // ------------------------------
     glfwInit();
     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, );
     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, );
     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

 #ifdef __APPLE__
     glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X
 #endif

     // glfw window creation
     // --------------------
     GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
     if (window == NULL)
     {
         std::cout << "Failed to create GLFW window" << std::endl;
         glfwTerminate();
         return -;
     }
     glfwMakeContextCurrent(window);
     glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

     // glad: load all OpenGL function pointers
     // ---------------------------------------
     if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
     {
         std::cout << "Failed to initialize GLAD" << std::endl;
         return -;
     }

     // build and compile our shader program
     // ------------------------------------
     // vertex shader
     int vertexShader = glCreateShader(GL_VERTEX_SHADER);
     glShaderSource(vertexShader, , &vertexShaderSource, NULL);
     glCompileShader(vertexShader);
     // check for shader compile errors
     int success;
     char infoLog[];
     glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
     if (!success)
     {
         glGetShaderInfoLog(vertexShader, , NULL, infoLog);
         std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
     }
     // fragment shader
     int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
     glShaderSource(fragmentShader, , &fragmentShaderSource, NULL);
     glCompileShader(fragmentShader);
     // check for shader compile errors
     glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
     if (!success)
     {
         glGetShaderInfoLog(fragmentShader, , NULL, infoLog);
         std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
     }
     // link shaders
     int shaderProgram = glCreateProgram();
     glAttachShader(shaderProgram, vertexShader);
     glAttachShader(shaderProgram, fragmentShader);
     glLinkProgram(shaderProgram);
     // check for linking errors
     glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
     if (!success) {
         glGetProgramInfoLog(shaderProgram, , NULL, infoLog);
         std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
     }
     glDeleteShader(vertexShader);
     glDeleteShader(fragmentShader);

     // set up vertex data (and buffer(s)) and configure vertex attributes
     // ------------------------------------------------------------------
     float firstTriangle[] = {
         -0.9f, -0.5f, 0.0f,  // left
         -0.0f, -0.5f, 0.0f,  // right
         -0.45f, 0.5f, 0.0f,  // top
     };
     float secondTriangle[] = {
         0.0f, -0.5f, 0.0f,  // left
         0.9f, -0.5f, 0.0f,  // right
         0.45f, 0.5f, 0.0f   // top
     };
     unsigned int VBOs[], VAOs[];
     glGenVertexArrays(, VAOs); // we can also generate multiple VAOs or buffers at the same time
     glGenBuffers(, VBOs);
     // first triangle setup
     // --------------------
     glBindVertexArray(VAOs[]);
     glBindBuffer(GL_ARRAY_BUFFER, VBOs[]);
     glBufferData(GL_ARRAY_BUFFER, sizeof(firstTriangle), firstTriangle, GL_STATIC_DRAW);
     glVertexAttribPointer(, , GL_FLOAT, GL_FALSE,  * sizeof(float), (void*));    // Vertex attributes stay the same
     glEnableVertexAttribArray();
     // glBindVertexArray(0); // no need to unbind at all as we directly bind a different VAO the next few lines
     // second triangle setup
     // ---------------------
     glBindVertexArray(VAOs[]);    // note that we bind to a different VAO now
     glBindBuffer(GL_ARRAY_BUFFER, VBOs[]);    // and a different VBO
     glBufferData(GL_ARRAY_BUFFER, sizeof(secondTriangle), secondTriangle, GL_STATIC_DRAW);
     glVertexAttribPointer(, , GL_FLOAT, GL_FALSE, , (void*)); // because the vertex data is tightly packed we can also specify 0 as the vertex attribute's stride to let OpenGL figure it out
     glEnableVertexAttribArray();
     // glBindVertexArray(0); // not really necessary as well, but beware of calls that could affect VAOs while this one is bound (like binding element buffer objects, or enabling/disabling vertex attributes)

     // uncomment this call to draw in wireframe polygons.
     //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

     // render loop
     // -----------
     while (!glfwWindowShouldClose(window))
     {
         // input
         // -----
         processInput(window);

         // render
         // ------
         glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
         glClear(GL_COLOR_BUFFER_BIT);

         glUseProgram(shaderProgram);
         // draw first triangle using the data from the first VAO
         glBindVertexArray(VAOs[]);
         glDrawArrays(GL_TRIANGLES, , );
         // then we draw the second triangle using the data from the second VAO
         glBindVertexArray(VAOs[]);
         glDrawArrays(GL_TRIANGLES, , );

         // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
         // -------------------------------------------------------------------------------
         glfwSwapBuffers(window);
         glfwPollEvents();
     }

     // optional: de-allocate all resources once they've outlived their purpose:
     // ------------------------------------------------------------------------
     glDeleteVertexArrays(, VAOs);
     glDeleteBuffers(, VBOs);

     // glfw: terminate, clearing all previously allocated GLFW resources.
     // ------------------------------------------------------------------
     glfwTerminate();
     return ;
 }

 // process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
 // ---------------------------------------------------------------------------------------------------------
 void processInput(GLFWwindow *window)
 {
     if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
         glfwSetWindowShouldClose(window, true);
 }

 // glfw: whenever the window size changed (by OS or user resize) this callback function executes
 // ---------------------------------------------------------------------------------------------
 void framebuffer_size_callback(GLFWwindow* window, int width, int height)
 {
     // make sure the viewport matches the new window dimensions; note that width and
     // height will be significantly larger than specified on retina displays.
     glViewport(, , width, height);
 }