OpenGL Initialization

• A Vertex Array Object (or VAO) is an object that describes how the vertex attributes are stored in a Vertex Buffer Object (or VBO). This means that the VAO is not the actual object storing the vertex data, but the descriptor of the vertex data.
  • We need a VAO for each unique "object" we plan to draw.
  • Think of this a defining our own primitive.
  • Look at triangles.C:

    // declarations
        enum VAO_IDs {Triangles, NumVAOs};
        GLuint VAOs[NumVAOs];
    
    // in init()
        glGenVertexArrays(NumVAOs, VAOs);
        glBindVertexArray(VAOs[Triangles]);
    
    // in display()
        glBindVertexArray(VAOs[Triangles]);
    

  • The declarations
    • Remember, C++ associates an int with each enum, so
      • Triangles = 0
      • NumVAOS = 1.
    • The next line will declare an array of unsigned ints the size of the enumerated list above.
    • This is sort of a strange solution, I'm not sure I would use it long term.
  • The init routine
    • void glGenVertexArrays(GLsizei n, GLuint *arrays);
      • The size is the number of VAOs you want.
      • *arrays is an array to store the VAO names.
      • This is the array of unsigned ints from above.
    • Essentially this returns an array of pointers.
      • In OpenGL they are called "object names"
      • They are not guaranteed to be sequential.
      • But they will be unique.
    • I think these are probably an index into an array of structure pointers.
      • This is a handle to memory on the GPU.
    • void glBindVertexArray(GLuint array);
      • The first call allocates memory in the GPU for the VAO
      • It also makes the VAO active.
      • This makes the array the active array.
    • Can be freed with glDeleteVertexArrays
      • Probably not important in our programs
      • Because we will run, build all of the objects and then exit
      • But in the case of a larger system, we will need to manage things better.
  • Finally in the display routine
    • A call to glBindVertexArray() for each array we will draw.
    • This does not allocate new memory, but makes the VAO active.
    • All drawing occurs using this array (and associated data).
• A Vertex Buffer Object (VBO) is an OpenGL feature that provides methods for uploading vertex data (position, normal vector, color, etc.) to the video device for non-immediate-mode rendering.
  • Like VAO's (memory on the GPU)

    
    // in init
        glGenBuffers(NumBuffers, Buffers);
        glBindBuffer(GL_ARRAY_BUFFER, Buffers[ArrayBuffer]);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    

  • void glGenBuffers(GLsizei n, GLuint * buffers);
    • Same as for VAOS
    • glDeleteBuffers
  • void glBindBuffer(GLenum target, GLuint buffer);
    • There are a number of different buffers we may want.
    • But for now we want a GL_ARRAY_BUFFER
  • void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
    • The target is as before, GL_ARRAY_BUFFER
    • The next argument is the size of the data we will transfer.
    • The next argument is a pointer to the base address of the data.
    • The last is how we will use the data.
    • Again for now use : GL_STATIC_DRAW
• Connecting the data in memory to the data in the shader

      glVertexAttribPointer(vPosition, 2, GL_FLOAT,
               GL_FALSE, 0, BUFFER_OFFSET(0));
      glEnableVertexAttribArray(vPosition);
  

  • void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
  • We will do more with this later.
    • Index tells the shader which variable we are using.
    • Size specifies the number of components (2)
    • type specifies the data type passed to it.
    • normalized tells it to normalize the data or not.
    • stride tells it how much data to skip. (ie colors and vertexes mixed in the same array)
    • Pointer is null for now.
  • Finally enable the vertex attrib array.
• I did a class based example is here