1. Camera Position (5.6)
we specify the position and orientation of the camera to determine what will be seen.
use gluLookAt (eye x, y, z, at x, y, z, up x, y, z)
Up vector determines head tilt. It is most often (0, 1, 0). Be aware if you are looking down on the scene then the up vector must be different!
this command modifies the ModelView matrix and should generally be done first after setting the matrix to identity
glMatrixMode (GL_MODELVIEW);
glLoadIdentity();
gluLookAt (5, 5, 5, 0, 0, 0, 0, 1, 0);
This has the effect of transforming all vertices from the camera frame to the world frame with the camera at the origin facing the negative Z direction.

2. Projection
There are many different ways to draw 3D objects in drafting and freehand drawing. Computer graphics uses only two of them. Think of each projection as a different kind of lens on the camera.
Viewing Volume
Determines what will be seen. Objects (or portions of objects) not within the view volume will be clipped.
Parallel Projection / Orthographic
Preserves correct length even when objects are far away. This is an artificial projection but is useful for architects and engineers.
The viewing volume is a 3D box.
glMatrixMode (GL_PROJECTION);
glLoadIdentity();
glOrtho (left, right, bottom, top, near, far);

3. Perspective Perspective Projection
Creates foreshortening, the appearance that objects farther away are smaller. This is more realistic.
The viewing volume is a truncated pyramid called a frustum.
glMatrixMode (GL_PROJECTION);
glLoadIdentity();
gluPerspective (view angle, aspect, near, far);
view angle is defined in degrees and can be considered a zoom lens
aspect ration is width divided by height (1.0)
near and far should always be positive with respect to camera

4. Affine Transformations (5.3)
Skim 5.2 for background material on 2D transformations
Homogeneous Coordinates
3D points are represented in 4D to make calculations easier
p(x, y, z, w) w is usually set to 1
vector (x, y, z, w) w is usually set to 0
Affine Transformations
convert one point into another
p’ = f(p)
different functions are used for different transformations
straight lines are maintained
rotation, scaling, and translation
apply to each point of an object
4x4 matrices help to make the process more efficient
p’ = Mp
this is post multiplication
the book refers to points as a column [x y z w]T
Group Activity
P1 = (3, 5, 7, 1)
P2 = Identity * P1;

5. Translation displaces a point a fixed amount in x, y, and z
shape and size remain the same
p’ = p + displacement
Translation matrix Tx Ty Tz
Group Activity
Tx = 3, y = 4, Tz = 5
P1 = (1, 2, 3, 1);
P2 = Mt * P1;

6. Rotation about an axis by a number of degrees
shape and size remain the same
positive rotation goes counter clockwise
parameters must be in radians
x’ = x cos(O) - y sin(O)
y’ = x sin (O) + y cos(O)
Rotate about X axis
0 c -s 0
0 s c 0
Different matrices for rotation about Y or Z

7. Scaling generally about the origin
non uniform stretching along one or more axes
about a fixed point
if S > 1 then object gets bigger
Scaling matrix Sx
0 Sy
Sz 0
Group Activity
Sx = 1.5, Sy = 2.5, Sz = 0
P1 = (2, 2, 2, 1);
P2 = M * P1;
Shear
We will not cover the shear transformation

8. Composing Transformations (5.3.2)
Concatenating matrices has the effect of applying one at a time
M = S Rx Ry Rz T
Note that matrices are multiplied in reverse order (right to left)
Warning! The order of concatenation makes a difference
Rotating about X and then Y is not the same as the inverse
A series of transformations is applied with concatenation
newObj = T * R * S * Obj
An alternative is to multiply the matrices only once to be more efficient
M = T * R * S
newObj = M * Obj
Rotation about a spcecific point instead of the origin
M = T R (-T)

9. Viewing Pipeline (5.6)
Several parameters must be provided to determine the final image: camera position, projection style and viewing volume.
Transformation pipeline
Keep in mind the transformations that all vertices go through and the order that it occurs.
display <-- projection <-- view <-- model <-- vertex
OpenGL has two built in transformation matrices: projection and modelview. Notice that the view and model matrices are combined into one. It is therefore critical to apply the view transformations BEFORE the model transformations.

10. Viewing Pipeline
objects re defined in modeling coordiates or object space (centered about the origin)
vertices are multiplied by the Model portion of the matrix to position the object in world space
vertices are then multiplied by the View portion of the matrix based on the position of the camera and converted to viewing space
vertices are multiplied by the projection matrix to create image space

11. OpenGL matrix operations
OpenGL maintains two global matrices
Projection - for projection paramters
Modelview - for transformation
All vertices are transformed before drawn. They are multipled by both matrices
Post multiplication is used, therefore you must perform the transformation in opposite order that you would expect
TRSp
Operations
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glLoadMatrixf(M)
resets top matrix
glPushMatrix()
copy the top stack and place the copy on top
glPopMatrix()
replace the top matrix with the previous one
Concatenation
glMultMatrixf(M)
multiplies current Matrix times M

12. OpenGL Transformations glTranslatef(x,y,z)
multiplies current matrix to cause a translation
MV = MV * M
glRotatef(degrees, x, y, z)
multiplies current matrix to cause a rotation of the specified degrees about the specified axis.
glScalef(x, y, z)
multiplies current matrix to cause scaling about the X, Y, and Z axes

13. Small uisGL Example // look at ~grissom/367uisGL.h uisObject cube;
uisMatrix M, S, T;
// initialize structure from external object file
infile.open(“cube.obj”);
infile >> cube;
// set transformation matrix from scene description file
S.setScaling(x,y,z);
T.setTranslation(x,y,z);
M= T * S;
cube.setTransformation(M);
// transform all points at the beginning
cube = M * cube;
// render the object face by face

14. Hidden Surface Removal 5.5
Backface Removal
You do not see the back side of an object.
Decision must be made on a face by face case with respect to the viewer position.
Hidden Surface Removal
the elimination of parts of objects that are obscured by other objects
Rotating Cube example from Ch 5.6
Object Space algorithms attempt to dispaly objects in an appropriate order. (painters algorithm)
Image Space algorithms work on a pixel by pixel basis to determine which to display. The ordering of the objects is not important. (z-buffer)

15. Backface removal Not covered in the book or by OpenGL
Identify which objects are facing towards the viewing
Calculate normal vector to face
Calculate vector from face to eye
Calculate the angle between the two
if greater than 90 then not visible
Use dot product, if <= 0 then not visible
uisGL Code
uisObject Obj;
uisFace F;
uisVertex P1, P2, P3;
uisVector V1, V2, N;
V1 = P2 - P1;
V2 = P3 - P1;
N = V1 | V2;
V1 = Eye - P1;
if (V1 * N) <= 0
not visible

16. Z buffer algorithm Image space algorithm
maintain the z value for each pixel as a face is rasterized
only replace the current pixel with one that is closer to the viewer
this takes alot of memory called a Z -buffer
OpenGL does this for us
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH);
glEnable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
We will use this method but it does not help in wireframe mode

17. Walking Thru A Scene
Notice the subtle difference between rotating the object compared to moving the viewer
run cubeview.c
Rotate cube with mouse
Move viewer with key presses x, X, y, Y, z, Z