An Off Topic

• More complex objects need to be specified in terms of the simpler objects.
• Frequently such objects are specified in terms of a
  • A vertex list, or the points in the object
  • An edge list, or a list of edges in the object, sometimes this is omitted.
  • A polygon list
  • There may be attributes associated with each level
• This is done to save duplication of data.
• For example, the linetest from before
  • You probably stored the corrdinate 0,0 once for each line in the radial hub.
  • This becomes more of a problem as objects grow in size.
• Consider this scheme:
  • Define the storage:

    struct Vertex{
       GLfloat position[2];
       GLfloat color[3];
    };
    ...
    
    std::vector points;
    std::vectorindex;
    

  • Then create the structure

        v.position[0] = 0;
        v.position[1] = 0;
        v.color[0] = 0;
        v.color[0] = 0;
        v.color[0] = 0;
        points.push_back(v);
    
        theta = 0;
        for(i=0;i<num;i++) {
           v.position[0] = 0.9 * cos(theta);
           v.position[1] = 0.9 * sin(theta);
           theta += dTheta ;
    
           v.color[0] = rand()/float(RAND_MAX);
           v.color[1] = rand()/float(RAND_MAX);
           v.color[2] = rand()/float(RAND_MAX);
    
           points.push_back(v);
    
           index.push_back(0);
           index.push_back(ushort(points.size()-1));
        }
    }
    
    

  • I only store each coordinate once.
  • We do end up storing index 0 a bunch of times.
  • But this is probably better than storing the 2 piont and three color values repeatedly.
• Such objects require two VBOs
  • One to hold the vertices
  • One to hold the "edge list".

      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferIDs[0]);
      glBufferData(GL_ELEMENT_ARRAY_BUFFER, index.size()*sizeof(int),
            index.data(), GL_STATIC_DRAW);
    
      glBindBuffer(GL_ARRAY_BUFFER, bufferIDs[1]);
      glBufferData(GL_ARRAY_BUFFER, points.size()*sizeof(Vertex),
            points.data(), GL_STATIC_DRAW);
    

  • This is in the init routine for my new Lines object.
  • Note that the new VBO is a GL_ELEMENT_ARRAY_BUFFER
  • it is bound to the index vector from above.
  • The first buffer has no attributes but the second does.
• This is drawn with glDrawElements
• void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices);
  • The mode is as before (GL_POINTS, GL_LINES, ...)
  • The count is the size of the vertex list.
    • The description says the number of elements, but this is not right.
  • The type must be GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT
  • indices is a pointer to the base address of the array holding the data.
  • So the Display routine becomes

    void Lines::Display() {
    
      if (display) {
          glEnable(GL_LINE_SMOOTH);
          glUniform1f(tsLoc, timeStep);
    
          glBindVertexArray(VAONumber);
          glDrawElements(GL_LINES, index.size(), GL_UNSIGNED_SHORT, NULL);
    
          glBindVertexArray(0);
          glDisable(GL_LINE_SMOOTH);
      }
    
      return;
    }
    

• A new demo, demo6 illustrates this.