Introduction

On Monday, we started a review of what we were supposed to have remembered from a first graphics class.
We gave the four stages of the graphics pipeline: Vertex Processing, Clipping and assembly, Rasterization, Fragment Processing
We recalled vector spaces, affine space, affine frame, coordinates, affine transformations.
We discussed some commonly used frames in computer graphics: the world frame, the object frame, and the eye frame.
We said a matrix stack could be helpful in drawing objects into a scene with respect to the eye frame.

Computing vertex coordinates in the Eye Frame

In OpenGL, our vertices will be stored in vertex buffer objects.
For the part of an object in question we want to get into the eye frame, we compute a matrix which maps it first into the world frame, then we multiply this by the matrix which gets us from the world frame to the eye frame. This whole matrix is called the model view matrix.
A second matrix called the normal model view matrix is also calculated which says how the normals to each of our triangles should be transformed.
We send both of these objects to the vertex shader. This runs on the GPU (graphics processing unit) and can act on several vertices simultaneously
The shader multiplies the matrix against a vertex in object coordinates to compute its position in eye coordinates.
The book's website had a complete code example of this called Hello World 3D.

Setting up shaders.

Shaders can be constructed with calls like:

GLuint vs=glCreateShader(GL_VERTEX_SHADER);
GLuint fs=glCreateShader(GL_FRAGMENT_SHADER);

The commands to load a string into OpenGL to be used as a shader and then compile it are:

glShaderSource(vs, 1, ptrs, lens); 
/* ptrs is char pointer to the shader code
   lens is its length
 */
glCompileShader(vs);
// now check if compiled
GLint compiled = 0;
glGetShaderiv(vs, GL_COMPILE_STATUS, &compiled);
if (!compiled)
  throw runtime_error("fails to compile GL shader");

Similar code could be used to set up the fragment shader.

A minimal shader program gets us completely through the graphics pipeline so needs both a vertex and fragment shader which we link together with code:

GlProgram programHandle;
glAttachShader(programHandle, vs);
glAttachShader(programHandle, fs);

glLinkProgram(programHandle);

glDetachShader(programHandle, vs);
glDetachShader(programHandle, fs);

GLint linked = 0;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linked);
if (!linked)
  throw runtime_error("fails to link shaders");

To say that we want to use a particular shader program, in the next thing we draw, we use the call:
```
glUseProgram(programHandle);
```

Code to Send Matrices to a Shader

Shaders have slots to receive values which will be fixed regardless of which vertex it happens to be working with. These are called uniform variables.
The model view and normal model view matrices for a given object are examples of these.

We can set up a handle from our C++ program to one of these slots, via a call like:

h_uModelViewMatrix = glGetUniformLocation(
    programHandle, "uModelViewMatrix");
//h_uModelViewMatrix is now a handle to the shader 
//    variable uModelViewMatrix.
// The book's code uses the call 
// safe_glGetUniformLocation which is a thin wrapper
// to avoid null pointer issues.

We can view a 4x4 matrix for the model view matrix as an array of 16 elements. We can set up such an array and send it to the shader with code:

GLfloat glmatrix[16];
// set up matrix for MVM = invEyeRbt * groundRbt;
glUniformMatrix4fv(h_uModelViewMatrix, glmatrix); 
//or use the book safe_ version

Other uniform variables can be sent in a similar fashion, but where we might use a different type than Matrix4fv.

Example Vertex Shader

#version 130

uniform mat4 uProjMatrix;
uniform mat4 uModelViewMatrix;
uniform mat4 uNormalMatrix;

in vec3 aPosition;
in vec3 aNormal;

out vec3 vNormal;
out vec3 vPosition;

void main() {
  vNormal = vec3(uNormalMatrix * vec4(aNormal, 0.0));

  // send position (eye coordinates) to fragment shader
  vec4 tPosition = uModelViewMatrix * vec4(aPosition, 1.0);
  vPosition = vec3(tPosition);
  gl_Position = uProjMatrix * tPosition;
}

The variables of type in would come from a particular vertex buffer that was bound to Open GL at the moment.
The variables of type out and the built-in variable gl_Position go on the fragment shader.
Notice we compute out positions and normals after applying both our MVMs and NMVMs as well as a projection matrix -- we'll get back to the latter in a little bit.

In C++ land, we can have handles to the in variables, using a call like:

h_aPosition = glGetAttribLocation(programHandle, "aPosition");
h_aNormal = glGetAttribLocation(programHandle, "aNormal");

Setting up a Vertex Buffer

In the above, we have left out how we set up a vertex buffer for a particular object.

To declare a buffer object we might use code like:

GLuint vbo;
glGenBuffers(1, &vbo);
GLuint ibo;
glGenBuffers(1, &ibo);
int vboLen, iboLen;

Suppose we had a struct or class VertexPN which holds three floats for x,y,z coordinates of some vertex in an object (in object coordinates) and three floats for the x,y,z coordinates of the normals. Let *vtx be a pointer to an array of such objects.
We also make use of a second array pointed to by *idx, which corresponds to indexes in the first array. The element in idx list out the vertices that make up successive triangles in the final object. We also have int's for the length of these arrays.

Then to set up our vertex buffers we could do:

glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER,
    sizeof(VertexPN) * vboLen, vtx, GL_STATIC_DRAW);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 
    sizeof(unsigned short) * iboLen, idx, GL_STATIC_DRAW);

Drawing a Vertex Buffer

Let's assume now we have set up our vbo's, ibo's (index buffer object's), and our have compiled and linked our shader program and called glUseProgram.

We first set-up which in variables we will use:

glEnableVertexAttribArray(h_aPosition);
glEnableVertexAttribArray(h_aNormal);

Then say which vertex buffer to use:

glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(h_aPosition, 3, GL_FLOAT, GL_FALSE,
    sizeof(VertexPN), FIELD_OFFSET(VertexPN, p));
glVertexAttribPointer(h_aNormal, 3, GL_FLOAT, GL_FALSE, 
    sizeof(VertexPN), FIELD_OFFSET(VertexPN, n));

sizeof(VertexPN) will be 6 floats since a VertexPN and points and normals. FILED_OFFSET is a macro to say where a point and where a normal within those size begins.

Then we say which index buffer we want and draw:

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glDrawElements(GL_TRIANGLES, iboLen, GL_UNSIGNED_SHORT, 0);

Lastly, we clean up:

glDisableVertexAttribArray(h_aPosition);
glDisableVertexAttribArray(h_aNormal);

Next day, we will complete our review and begin talking about textures.

More of the Graphics Pipeline