Episode IV.... A New Demo

• Chapter 3 discusses drawing with opengl.
• We have seen many of the early concepts.
  • Read it over.
• They begin a more in-depth look at VAOs and VBOs
  • On page 93, they present a table discussing the different types of buffer objects.
    • Right now we are using GL_ARRAY_BUFFER
    • But we will soon start using GL_ELEMENT_ARRAY_BUFFER
• A side note on vectors
  • The STL of C++ contains a vector object.
  • Think of these as dynamic arrays.
  • Declared vector< type > identifier
  • elements can be added with .push_back()
  • size is determined with .size()
  • can be indexed with [i] for 0 ≤ i < vector.size()
  • the data is available at .data
• glBufferData
  • the last parameter is the usage
    • GL_{STATIC, DYNAMIC, STREAM}_{DRAW, READ, COPY}
  • It is important for performance that you get this right.
  • OpenGL might spend time "fixing" it so it is fast to use the data based on this description.
  • The first choice:
    • Static: write once, read many
    • Static is for data that will probably never be rewritten
    • Dynamic: multipl writes, but even more reads
    • Dynamic is for data that will change occasionally, but will be used many times per write.
    • Stream: written once and used a few times per write.
    • Stream is for constantly changing data.
    • The book says that stream data might not even be given space on the gpu.
  • The second choice
    • DRAW: the data will be used to darw the image.
    • READ: Data will be returned to the application
    • COPY: OpenGL will generate the data, and this will be used for future drawing commands.
• A note on C/C++ structures
  • #define offsetof(type, member)
    • This will compute how far from the base address of a structure or class the corresponding data field is stored.
    • This offset is in bytes.
  • void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
    • The target as before. (GL_ARRAY_BUFFER for now)
    • the size is specified in bytes.
      • I assume that at the bottom of this is a call to memcpy
    • The data parameter is the base address of the data array
    • Usage is as above.

    glBufferData(GL_ARRAY_BUFFER, points.size()*sizeof(Vertex), points.data(), GL_STATIC_DRAW);
           

  • note the use of the vector .data() function
• Vertex Attributes
  • Remeber, these describe how to use the data in the buffer.
  • They do something I am not the most happy with.
    • Apparently the id of the attribute lines up with the order in wich attribute variables are declared in the vertex shader.
    • So they have been using 0, since they have only had one variable.
    • You frequently see this.
    • But there is a function to make sure that you get it right.
    • GLint glGetAttribLocation(GLuint program, const GLchar *name);
      • This is just like glGetUniformLocation
      • If you want to be careful, you will check for an error.
  • void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
    • The index is the value from glGetAttribLocation
    • The size is the number of data points in the individual structure (or at a single vertex)
    • This is 2 for current coordinates, 3 for color and 1 for size
    • The type is GL_type
    • Normalized: if true openGL should normalize the data.
      • The book discusses this,
      • But it is most likely not what you want to have happen.
      • You probably want to normalize it by hand.
    • In the end, the data is stored as a flot.
    • stride specifies how much space is between data in bytes.
      • This is the size of our structure.
      • If the data is not interwoven, it is 0.
      • That is what we have been using in the past.
    • The offset is where the data starts.
    • See the example.
    • It is a void * for historic reasons.

        // the poisitions
        attribLoc = glGetAttribLocation(prog, "vPosition");
        glVertexAttribPointer(attribLoc, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                          BUFFER_OFFSET(offsetof(Vertex,position)));
        glEnableVertexAttribArray(attribLoc);
      
      
        // the colors
        attribLoc = glGetAttribLocation(prog, "vColor");
        glVertexAttribPointer(attribLoc, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex)
                         , BUFFER_OFFSET(offsetof(Vertex, color)));
        glEnableVertexAttribArray(attribLoc);
      
      
        // the point size
        attribLoc = glGetAttribLocation(prog, "vSize");
        glVertexAttribPointer(attribLoc, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex)
                         , BUFFER_OFFSET(offsetof(Vertex, size)));
        glEnableVertexAttribArray(attribLoc);
      

• The shader that goes with this

  #version 120
  
  attribute vec4 vColor;
  attribute float vSize;
  attribute vec4 vPosition;
  
  varying vec4   color;
  
  uniform float time = 1;
  
  void main() {
      float scaleDot;
  
      // vSize should be between 0 and 5
      // so scaleDot should be between  0 and 1
      scaleDot = (time + vSize)/3.0;
      
      // now scaleDot will be between -1 and 1
      scaleDot = clamp(scaleDot, 0.0, 2.0)  -1;
      gl_PointSize = 7 +  6*scaleDot;
  
      gl_Position =  vPosition;
      color = vec4(vColor.rgb, 1.0);
  
      return;
  }
  
  

• There are more options for each of these, and more commands as well, but these will do for now.
• The code for this demo is here