Vertex Arrays

• If we have a compilex shape to draw we have a few choices
  • Generate and Draw with CPU each time

    • glBegin() 
         for (x=0; x< points; x++) {
             y = f(x)
             glVertex*(x,y)
         }
      glEnd()
      	  

    • If the points change every time, this might be a reasonable approch.
    • But we may spend a considerable amount of time regerating points each time we display the scene.
    • And it really doesn't make sense to do this just to move sometihg about in the plane.
  • Pregenerate and Draw with CPU

    • glBegin() 
          for(i=0;i<points; i++) {
             glVertex(vector[i].x,vector[i].y)
          }
      glEnd()
      	  

  • The CPU still has to "touch" each point every time we draw.
  • But we can save time with point generation.
• These two methods are immediate mode
• In retained mode the data is handed to the library

  • setup() 
        data = generateData()
        SendDataToOpenGL(data)
    
    display()
        RenderStoredData();
                  

  • The library must allocate memory to store the data
  • But the CPU need only send a message to have the data rendered.
  • This and place considerably less burdon on the CPU
  • Especially if the GPU is capable of storing data.
    • My, reasonably old, GPU has 1GB main memory
• In OpenGL immediate mode has been deprecated.
• Vertex Arrays
  • He coveres these in the first section.
  • They are from OpenGL2
  • And not as efficient as the newer methods. (VertexBufferObjects)
  • But we should look at them quickly.
  • In a vertex array the data is stored in RAM (on the CPU side)
  • And the driver transfers the data each time it is displayed
  • BUT this frees the CPU for other tasks.
  • glEnableClientState()
    • Tells OpenGL that we will be using a given type of VertexArray storage
      • GL_VERTEX_ARRAY: vertex data
      • GL_COLOR_ARRAY: color data
      • normals, texture, and other values are allowed.
    • glDisableClientState() disables this action.
    • glEnableClientState(GL_VERTEX_ARRAY);
  • Next we need the points stored in an array so that we can send the entire thing to a storage location.
    • This is just a array of points.
    • glVertexPointer(3, GL_FLOAT ,0, Points);
      • First parameter 2-4, data per point
      • Type of the data
      • Stride
        • You can pack more than just point data into this array, but for now we will only do point data.
        • Stride tells us how much "extra data" is between each point.
        • 0 means densly packed
      • Pointer to the array
  • We then need to tell it to draw the points
    • glDrawElements(GL_TRIANGLE_FAN, Verticies[i].size, GL_UNSIGNED_INT, Verticies[i].verticies);
    • The shape we want to draw, note this is restricted from GL_BEGIN
      • GL_PONTS
      • GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_LINE_STRIP_ADJACENCY, GL_LINES_ADJACENCY,
      • GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_TRIANGLE_STRIP_ADJACENCY, GL_TRIANGLES_ADJACENCY
      • GL_PATCHES
    • The number of verticies we will be drawing
    • The type of the verticies, note this is restricted
      • GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT.
    • A pointer to the list of verticies.