Camera Position (5.6)

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 0 - 180 • 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 • 1 0 0 Tx • 0 1 0 Ty • 0 0 1 Tz • 0 0 0 1 • 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 • 1 0 0 0 • 0 c -s 0 • 0 s c 0 • 0 0 0 1 • 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 0 0 • 0 Sy 0 0 • 0 0 Sz 0 • 0 0 0 1 • 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