The new OpenGL method

The philosophy for OpenGL 3.0 and later is to store the data on the server side.
This involves a bit more setup
But with static data, the display routine is MUCH easier
We also need to load shader code.
Here are the steps
Initialize the shaders
- Angel has supplied us with to do this.
- It is code which reads in code written in a shader language.
- It makes a number of gl calls to load, compile and use this code.
- We will probably not look at these commands this semester.
- But we will look at vertex and fragment shaders at least in some level of detail.
- But not yet ...
Vertex Array Objects (VAO)
- Create a vertex array object.
  - void glGenVertexArrays (GLsizei n, GLuint *arrays);
  - ```
  GLuint vao;
  glGenVertexArrays( 1, &vao );
  	       
```
- This generates a name for a set of vertex objects.
- It seems to be returning sequential integers.
- I suspect this is the an index into a predefined table
- You are allocated n entries with this call, they are placed in the array of integers.
- But no memory is set aside yet, you are just given the names.
- void glBindVertexArray(GLuint array);
  - Creates a new VAO (allocates memory), if it is the first call with this name.
  - Makes the VAO pointed to by name active.
  - If name is 0, it unbinds the current VAO.
- The names can be checked with GLboolean glIsVertexArray(GLuint array);
  - Returns GL_TRUE if the name has been bound to a vertex array
  - Returns GL_FALSE otherwise
- A vertex array object can be freed with void glDeleteVertexArrays(GLsizei n, const GLuint * arrays);
- You will call Gen once
- You may call Bind many times.
Now A data buffer
- void glGenBuffers(GLsizei n,GLuint * buffers)
  - As with VAO, this allocates space for n buffer objects.
  - ```
  GLuint buffer;
  glGenBuffers(1, &buffer);
  	  
```
- void glDeleteBuffers(GLsizei n, const GLuint * buffers);
- GLboolean glIsBuffer(GLuint buffer)
- There are several buffer types
  - GL_ARRAY_BUFFER: an array of data, this is the one we will use
  - GL_COPY_READ_BUFFER
  - GL_COPY_WRITE_BUFFER
  - GL_DRAW_INDIRECT_BUFFER:
  - GL_DISPATCH_INDIRECT_BUFFER
  - GL_ELEMENT_ARRAY_BUFFER
  - GL_PIXEL_PACK_BUFFER
  - GL_PIXEL_UNPACK_BUFFER
  - GL_QUERY_BUFFER
  - GL_SHADER_STORAGE_BUFFER
  - GL_TEXTURE_BUFFER
  - GL_TRANSFORM_FEEDBACK_BUFFER
  - GL_UNIFORM_BUFFER
  - GL_ATOMIC_COUNTER_BUFFER
- void glBindBuffer( GLenum target, GLuint buffer);
  - Binds a buffer to a buffer type
  - If it is already bound, the previous binding is broken.
  - There are many special cases for the different types of buffers.
  - But the ARRAY_BUFFER is straight forward
  - ```
  glBindBuffer(GL_ARRAY_BUFFER, buffer);
  	  
```
- void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
  - target is the name of a buffer which has been allocated and bound
  - size is the size, in bytes of the data to be transferred
  - data is a pointer to the data to be copied, or NULL
  - usage describes how the data will be used.
  - ```
  glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(vec2)
                                  , data.data() , GL_STATIC_DRAW);
  	    
```
- Note, for vectors, the data() method returns a pointer to the memory used internally by the vector.
- Usage constants:
  - GL_
  - nature
    - STATIC: data is sent once and used many times.
    - DYNAMIC: data will be modified, but used many times.
    - STREAM: data is sent many times and used a few times after each transfer
  - use
    - DRAW: used for drawing
    - READ: getting data back from openGL, for a query
    - COPY: Read internal data, then use for something else
  - GL_STATIC_DRAW, GL_DYNAMIC_DRAW, ...
- Setting these values incorrectly will result in poor performance.
- They tell the library how to handle the data.
- The command
  - allocates a buffer of sufficient size to hold the data
  - If it was pointing to other data, this is deallocated.
  - If data is not null, the data is copied to the buffer.
  - The library decides how best, and where to store this data.
  - And it may rearrange the data to work better if it needs to.
  - We will use this command to initially populate our data buffers
  - We will use it to repopulate our data buffers if our data changes.
  - (See page 104, for example)
Let's talk about vertex shaders
- The vertex shader is called for each vertex which will be displayed
- It is called for each instance of a vertex
- But I bet it may be called in parallel for many verticies
- A vertex shader is REQUIRED for this type of openGL program
- It is minimally responsible for passing along those verticies
- But it may perform other tasks
  - Transformation
  - Pre-coloring
- The call to GlDrawArrays() will invoke the vertex shader
- As will other calls.
- They are written in a the OpenGL Shading Language
  - This is a C++ or Java like language
  - Each shader will have a main
    - But the main returns nothing, (void) not an int.
  - // is a comment
  - # is a directive
  - Variables are available
    - And follow the C syntax
    - Except _ can not be first character.
    - And __ (double underscore) can not be used in a name.
    - And must be declared before they can be used.
    - float, double, int, uint, bool
    - global variables are available to future shaders
    - Other C++ scope rules apply
    - they can be initialized as declared (int foo=3,bar;
  - There are aggregate types
    - [diub ]vec[234]
    - vec4 - a vector of four floats
    - dvec2 - a vector of two doubles
    - uvec3 - a vector of three unsigned ints
    - [ d]mat[234[x234]]
    - mat2: a 2x2 matrix of floats
    - dmat4x2: a 4x2 matrix of doubles.
  - Structs and arrays are available too, but we will save that for later.
  - Storage Qualifiers
    - we know const
    - in specifies that this will be an input variable
    - out specifies that this will be an output variable
    - There are others, but ....
    - in vec4 vPosition;
  - Predefined outputs
    - vec[4] gl_Position: The output position of the current vertex
    - float gl_PointSize: The pixel width/height (only for points)
      - Only used if glEnable(GL_PROGRAM_POINT_SIZE) has been called at least once and after any calls to glDisable(GL_PROGRAM_POINT_SIZE)
    - float gl_ClipDistance[]: The distance to the clip plane
      - Positive is behind the clip plane (in view)
      - Negative is in front of the clip plain (out of view)
    - Oh, and there are directives which state what version of OpenGL we expect
      - #version 150
        Specifies GSGL version 1.50, or OpenGL version 3.2
  - So our shader:
```
in vec4 vPosition;

void main() {
    gl_Position = vPosition;
}
       
```
  - Should make some sense.
The next thing to do is tie in the vertex shader
- GLint glGetAttribLocation(GLuint program, const GLchar *name);
  - ```
   GLuint loc = glGetAttribLocation( program, "vPosition" );
```
- Find the location of the Attribute vPosition in the shader
  - (Sometimes, it appears that the attribute is given a location variable when defined, and this step is skipped)
  - layout (location=0) in vec4 vPosition; from the red book.
  - In this case, he does not query for it, he just uses 0.
- This gives us a location of a variable in the shader.
- void glEnableVertexAttribArray(GLuint index);
- void glDisableVertexAttribArray(GLuint index);
  - Enables, or disables the use of the vertex attribute array specified.
- void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
  - Parameters
    - index: a AttributeArrayIndex, from above
    - size: The number of components at each vertex
    - type: The type of component at each vertex
    - normalized: Does the data need to be normalized
    - stride Distance, in bytes, between data.
    - pointer Beginning location of the data.
  - This ties the buffer (the currently active one) to the variable in the fragment shader.
  - We may pack multiple bits of data into an array
  - We might want to pack other data into the array.
The code: