Project2Fall12

Project 2: Interactive Viewing

This project has four parts, but only the first three are mandatory to get full credit (100 points). The number of points you get for each part is indicated below. In the first part you will need to implement camera and view frustum specifications. In the second part you will build a virtual trackball to rotate 3D objects with the mouse. In the third part you will use code that we provide to load triangle meshes from a file into your viewer.

The fourth part is optional. We make suggestions for how to extend your solution with additional features. You can get extra credit for completing those.

This assignment is due on Friday, October 10. It will be introduced by TA Sid on Monday, October 8th at 2:30pm in lab 260.

1. Camera and View Frustum

1a. Camera (10 points)

Create a camera class Camera with member variables for a center of projection e, a look at point d, and an up vector up, each of type Vector3, as in the lecture slides (4 points). The class should have an internal camera matrix of type Matrix4, derived from e, d and up (4 points). Add get and set access methods to the Camera class (1 point each).

1b. View Frustum (10 points)

Create a class Frustum which defines a projection matrix of type Matrix4. Create a class method to generate the projection matrix from a near plane near, far plane far, aspect ratio aspect, and a vertical field of view fov (6 points). This matrix is referred to in the lecture slides by the name Ppersp. Add a method to set OpenGL's projection matrix GL_PROJECTION from the class internal projection matrix (4 points).

Note: Do not use gluPerspective or glFrustum to implement the projection matrix, but use the equations from the lecture slides instead, and load projection matrix into OpenGL with glMatrixMode(GL_PROJECTION); glLoadMatrixd(Persp);.

1c. Testing (10 points)

We provide source code to generate a simple scene to test your implementation. Set the object transformation matrix (model matrix) to the identity matrix and render two images of the scene using these two sets of parameters:

• Image 1:
  • Aspect ratio: 1
  • Vertical field of view: 60 degrees
  • Near, far clip planes: 1, 100
  • Center of projection: 0, 0, 40
  • Look at point: 0, 0, 0
  • Up vector 0, 1, 0
• Image 2:
  • Aspect ratio: 1
  • Vertical field of view: 60 degrees
  • Near, far clip planes: 1, 100
  • Center of projection: -10, 40, 40
  • Look at point: -5, 0, 0
  • Up vector 0, 1, 0

Compare your implementation to the test images shown below (5 points for each image). Note that the images below were rendered with lighting off (glDisable(GL_LIGHTING)).

2. Virtual Trackball (50 points)

Implement a virtual trackball' which allows a user to rotate an object interactively with the mouse. Your solution should translate clicking and dragging of the mouse into a rotation matrix, which you then use to rotate the scene. Rotations around all three coordinate axes should be supported. A sample executable demonstrating the trackball functionality is available for Windows and Linux. If the executable does not work on your computer, here is a video of it. To access mouse coordinates, you will need to use GLUT's callback functions glutMouseFunc() and glutMotionFunc(). Note that successive trackball rotations must build on previous ones; at no point should the model snap back to a previous or default position.

The figure below illustrates how to translate mouse movement into a rotation axis and angle. m0 and m1 are consecutive 2D mouse positions. These positions define two locations v and w on a 3D virtual sphere that fills the rendering window. Use their cross product as the rotation axis a = v x w, and the angle between v and w as the rotation angle.

Horizontal mouse movement in the middle of the window should result in a rotation around the y-axis. Vertical mouse movement in the middle of the window should result in a rotation around the x-axis. Mouse movements along the boundary (horizontal and vertical) should result in rotations at least partially around the z-axis. Here you will find a more detailed description of the implementation of a virtual trackball.

You will notice that you can either rotate the camera around a static object space, or the object space with respect to a stationary camera. We recommended (but not required) using a stationary camera and rotating the object space.

You get points for the following accomplishments:

• The object space rotates about its origin (20 points).
• The trackball rotates correctly with regards to mouse movement (e.g., mouse to the right -> object rotates to the right) (25 points).
• Clicking and dragging anywhere in the window, including close to the edge or corners of the window, does not crash the application (5 points).

3. Displaying Triangle Meshes from Files (20 points)

The .obj file format is a very simple ASCII text based file format for triangle meshes. In its basic form, an .obj file contains a list of triangle vertices indicated by the letter v, and an array of indices to form triangles indicated by the letter f. We provide a C++ class that reads .obj files. You should add this code to your rendering engine. The .zip file also contains a code sample that demonstrates the use of this class. You have to add the routines to create OpenGL geometry out of the 3D data structure (4 points). Add support for a command line parameter to specify the name of the .obj file to load (1 point).

One problem is that you don't know the extent of the object stored in the file. The stored triangle coordinates may be too small or too large for your rendering window. To fix this, calculate the minimum and maximum coordinates in all three dimensions (5 points), and find out what size objects your rendering window allows. Based on these values you need to create a translation matrix (5 points) and a uniform scale matrix (5 points) which, together, transform the object so that it fills the rendering window.

Here are a few sample .obj files for testing. Make sure they all work, because you will be asked to show some of them during homework grading.

• Sphere
• Teapot
• Bunny
• Dragon
• Buddha

4. Optional Project: Height Map (10 points)

Generate and display a 3D mesh out of a 2D height map image. Wikipedia has a great description of this topic. Allow the user to interactively fly over the height map, similar to a simple flight simulator, using keyboard or mouse. You can use the height map image from the Wikipedia page, which you will also find below, or create your own with a paint program or another method of your choice.

Height map image from Wikipedia

To get full credit you need to implement the following features:

• Load the height map image and create a 3D mesh out of it (4 points). You can either read the Wikipedia PNG file with your own reader, or read this PGM file with this piece of C code.

• Use a color gradient from blue (water) to yellow (sand), green (grass), grey (rock) and white (snow) to color the terrain polygons, depending on their height (2 points).

• Create a separate navigation mode apart from that of the trackball, in which the user can navigate by steering left/right, up/down, and change the velocity of the flight (3 points). Scale the terrain up to a size appropriate for a flight simulator scenario (1 point).

If you use the Wikipedia height map, the result should look similar to this, except that the terrain needs to be colored as described above:

3D terrain generated from height map