A full 3D Environment

The camera:
- Remember we use a pinhole camera model.
- The camera is specified using three different vectors and a position.
- The position is specified in modeling coordinates.
- From the position we need a vector which defines what we are looking at.
  - This is called the look at point
  - This is also specified in world coordinates.
  - It is where the camera is pointing.
  - From this point, we construct a lookAt vector
  - lookAt = eye - at
  - And then we normalize it.
  - vec4 n = normalize(eye - at);
  - This then defines the vector indicating the direction of the camera.
  - Or the z axis.
- The third thing we need to specify (at and eye) is an up vector
  - This is equivalent to declaring the y axis.
  - It does not need to be 100% accurate, but it should be semi-normal to the lookAt vector computed.
  - In the process we will fix it.
- For the task of defining the camera we need the positive x axis.
  - To do this, we cross the up and the look at vectors.
  - vec4 u = normalize(cross(up,n));
- We now have a lookAt (n) and a right (u) vector which are orthogonal.
- We can compute the real up vector by crossing the two of these.
  - vec4 v = normalize(cross(n,u));
- These three vectors are all orthogonal and form a basis or definition for a vector space.
- The world coordinate system is also a basis (1,0,0), (0,1,0), (0,0,1)
- Moving from one system to another is a Change of Basis
- And the representation of the new system in terms of the old is the transformation matrix required to move from one coordinate system to another.
```
mat4 LookAt( const vec4& eye, const vec4& at, const vec4& up )
{
    vec4 n = normalize(eye - at);
    vec4 u = normalize(cross(up,n));
    vec4 v = normalize(cross(n,u));
    vec4 t = vec4(0.0, 0.0, 0.0, 1.0);
    mat4 c = mat4(u, v, n, t);
    return c * Translate( -eye );
}
	
```
To accomplish this I have made a few changes in demo8
- The vertex shader
- I have added a camera class
  - It has key like callbacks to handle user interaction
  - It has a function to return the current eye position.
  - It has a display function,
    - This uses LookAt to set the camera transformation matrix.
  - And a result function.
  - The internal data is
    - A current position. (eye)
    - A lookAt vector
    - An up vector.
    - An angle of travel
    - The distance ahead of where I am looking
  - Move is a function that that changes the eye position and the lookAt position, eventually stepping along the vector.
  - RepositioCenter is a function that allows a rotation.
The second thing that is needed is to warp the view frustum to NDC
- There are two functions which can accomplish this
  - Ortho is essentially the transformation from a window to a viewport that we did six weeks ago.
    - There is no scaling in the Z direction.
  - Frustum does a projection.
To take advantage of these
- I added a variable to change which projection we are using.
- And a DoProjection function.
- This uses the projectionM in the shader.
I have changed the Object class
- It now destroys the two vectors after the data has been moved to the shader.
- It also stores a transformation matrix to transform the object.
  - I use this to initially align the objects
- It makes calls to glCullFace()
  - glEnable(GL_CULL_FACE);
  - This just checks to see if the normal is pointing in the negative z direction.
  - glFrontFace can be used to set the mode.
A reset function.
glutResizeFunc()
A land generating class. (Land.C, h)
Double buffering.