Elements of Computer Graphics CS 174, Spring 2002: Assignment 3

Name: ______________________________________

Student ID: _________________________________

Due date: May 29, 2002 at 4:00pm.

Weight: 15 %.

Collaboration: None. If you discuss this assignment with others you should submit their names along with the assignment material.

Instructions: Submit your assignment at SEASNET. Make sure you submit all the necessary files and a readme.txt that explains your project. Document any shortcuts you took, for example if you didn’t implement shadows. Failure to do so may result in loss of marks. Do NOT Submit a printed version of your code.

Start working on it early. You will not have time to do it at the last minute.

1. Visibility [6 marks]
a. [3 marks] Create a BSP tree for the following scene using the algorithm presented in the lecture notes. Chose the roots randomly. Make sure you label polygons properly and show how the algorithm works, that is show each stage.

b. [3 marks] Given the BSP you just created, show how the algorithm will draw the polygons for an eye position of your choice. Make sure you indicate clearly where the eye is.

2. Ray tracing [24 marks]
Implement a ray tracer.
A good implementation should include the following features:

Several kinds of primitives (generic objects). These include polygons, spheres, and cubes.
A way to transform generic objects to give them a general position, orientation and size.
Several point light sources, with associated colours.
Matte objects with intrinsic colours (diffuse and Phong specular).
Shiny objects that reflect and refract light.
Shadows.

Beware! Ray tracing uses lots of CPU. Keep your recursion depth low (max 2 or 3) and your images tiny (200x200) while testing.

You can display your image on the screen or you can save it as a PPM file (see assmt2 code).

Instructions:
For this project, no skeleton code is provided, but the implementation should be relatively straightforward. Some code is provided at www.cs.ucla.edu/~pfal/courses/cs174/2002s/coursework/

Here are some suggestions on organizing your code:

Use object-oriented (C++) programming.
Each kind of object in the scene should probably be a class. It should include a method to do intersection with a ray and it should keep track of the following information:

object material (colour)
object's transformation matrix.
object's properties (matte, opaque, transparent, etc).

Intersection tests will return a hitpoint, a class which needs associated information such as:

the ray parameter "t" of the hitpoint.
the surface normal (for lighting, refraction and reflection).
a pointer to the object, for other queries.

The scene will keep track of objects and lights, and will need methods to add objects to it. These methods may be invoked through a parser that reads a scene description from a file (if you feel very energetic), or may be invoked from a hard-coded initialization function.
Ray-tracing does not handle diffuse reflection efficiently. To properly handle matte surfaces would require enormous numbers of secondary rays per hit. Hence, follow this heuristic:

If the surface is mirror-like or glass-like, spawn secondary rays in the reflected and/or refracted directions.
If the surface is matte, do a global illumination calculation, and return the ray's colour. Shadow rays are used here.

In other words, don't keep following rays hoping to hit a light. It will happen with zero probability (ie never), for point lights.

Here's a little hard-to-understand gotcha! that you will probably run into: when a ray hits a surface, you obtain a hit point. If you cast a secondary ray, it will start from the hit point, and test all objects for intersection. Due to numerical errors, the hitpoint may be slightly INSIDE the object, so the math may yield an intersection with the same object again! Hence, discard hits that are very close to the original hit point.