Project2Fall11

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 project is due on Friday October 7, 2011. The assignment will be introduced by TA Jorge on Monday, October 3rd at 3pm 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 (see lecture slides) (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.

1c. Testing (10 points)

We provide source code you should use 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).

<img class="alignleft" src="%ATTACHURLPATH%/house1.jpg" width="300" height="300">	<img class="alignleft" src="%ATTACHURLPATH%/house2.jpg" width="300" height="300">
Image 1	Image 2

2. Virtual Trackball (50 points)

Implement a _virtual trackball_ that allows a user to rotate an object interactively using the mouse. Your solution should translate clicking and dragging of the mouse into a rotation matrix, which you then use to transform the scene. Rotations around all three coordinate axes should be supported. A sample executable which demonstrates 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 the mouse coordinates, you will need to use GLUT's callback functions [[1][glutMouseFunc()]] and [[2][glutMotionFunc()]].

The figure below illustrates how to translate a mouse movement into a rotation axis and angle. %$m_0$% and %$m_1$% are consecutive 2D mouse positions. These positions define two locations %$\mathbf{v}$% and %$\mathbf{w}$% on a 3D virtual sphere that fills the rendering window. Use their cross product as the rotation axis %$\mathbf{a}=\mathbf{v}\times\mathbf{w}$%, and the angle between %$\mathbf{v}$% and %$\mathbf{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. [[3]] 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 the object space, or the object space with respect to a stationary camera. It is recommended (but not required) to use a stationary camera and rotate the object space.

You get points for the following accomplishments:

• The object space has to rotate about its origin (20 points).
• The trackball has to rotate correctly with regards to the mouse movement (e.g., mouse to the right -> object rotates to the right) (20 points).
• Clicking and dragging _anywhere_ in the window, including close the the edge or corners of the window, should rotate the object (10 points).

<img src="%ATTACHURLPATH%/trackball.jpg" alt="trackball.jpg" width='800' height='414' />

3. Loading 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, which you can download here. 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 triangle coordinates may not be suitable for your viewing configuration. To make sure that there is a well defined bounding box for the object, write a utility function =normalize()= that uniformly scales and translates all coordinates of the object such that it fills the OpenGL window. This should be achieved by finding the minimum and maximum _x_, _y_, and _z_ coordinates of the object (*5 points*). Based on these values you need to create a translation matrix (5 points) and a uniform scale matrix (*5 points*) that, together, transform the object so that it fills the rendering window. This may also require a modification to your projection matrix.

Here are a few sample .obj files for testing:

  * [[4][Sphere]]
  * [[5][Teapot]]
  * [[6][Bunny]]
  * [[7][Dragon]]
  * [[8][Buddha]]

4. Optional Feature: Heightmap (10 points)

Generate and display a 3D mesh out of a 2D heightmap image. Wikipedia has a [[9][description of this topic]]. Allow the user to interactively fly over it, similar to a flight simulator, using keyboard or mouse. As a heightmap image you can use the one from the Wikipedia page, which you will also find below, along with the resulting 3D terrain. To get full credit you need to implement the following features:

  * Load the heightmap image and create a 3D mesh out of it (4 points).

  * Use a color gradient from blue (water) over yellow (sand) to green (grass), brown (dirt) 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 (4 points). 

<img src="%ATTACHURLPATH%/Heightmap.png" alt="Heightmap.png" height='304' /> <img src="%ATTACHURLPATH%/Heightmap_rendered.png" alt="Heightmap_rendered.png" height='304' />

To read the heightmap image, you can either read the PNG file with your own reader, or read this PGM file with this piece of C++ code .