15-462 Programming Lab 3: Ray Tracer

Due Tuesday, April 10th, 11:59:59 PM

An Overview

For this project you will implement a ray tracer. Besides the basic scene file parser, you will have to implement everything on your own. We suggest using the libgfx libraries for the mathematical functions that you will need. One way to write pixels to the screen buffer is to first create a large enough buffer in memory, write to it as you perform raytracing, then create a texture map (GL_TEXTURE_RECTANGLE_NV) and fill it by glTexImage2D, then render it to screen or save it to a file.

Scene Format

You can create your own scenes to show off the raytracer in action; however, you will have to implement a simple command-line interface and support a common scene format so that we can test your code. The code to parse the Simple Scene Description Format is provided for you (rt_parse.h/cpp). A simple example can be found here.

Simple Scene Description

The (informal) grammar for the simple scene description format is as follows:

scene :: = background lights materials group

background ::= Background {
  color Vec3f
  ambientLight Vec3f
}

lights ::= Lights { 
  light *
}

light ::= Light {
  position Vec3f
  color Vec3f
  ( attenuation float float float ) ?
}

camera ::= Camera {
  eye Vec3f
  center Vec3f
  up Vec3f
  fovy float
}

materials ::= Materials {
  material *
}

material ::= Material {
  textureFilename string
  diffuseColor Vec3f
  specularColor Vec3f
  shininess float
  ( transparentColor Vec3f )?
  ( reflectiveColor Vec3f )?
  ( indexOfRefraction float )?
}

group ::= Group {
  object *
}


object ::= sphere | triangle | trimesh

sphere ::= Sphere {
  materialIndex int
  center Vec3f
  radius float
}

triangle ::= Triangle {

  vertex0 Vec3f
  normal_vertex0 Vec3f
  materialIndex0 int
  s_t_tex_0 float float

  vertex1 Vec3f
  normal_vertex1 Vec3f
  materialIndex1 int
  s_t_tex_1 float float

  vertex2 Vec3f
  normal_vertex2 Vec3f
  materialIndex2 int
  s_t_tex_2 float float

}

trimesh ::= TriMesh {
  objfile file.obj
  materialIndex int
}

Vec3f ::= float float float

Light attenuation

Spherical Coordinates for Texturing

Command line Parameters

• -f [file-name] - Scene file to open.
• -o [file-name] - File where the resulting image is stored. The program should exit immediately after it is done writing the image.
• -dims [width] [height] - Width and height of the output buffer (and image). You have to have the same aspect ratio of the camera as the image (aspect_ratio = width/height). Therefore tan(FOVX) = aspect_ratio * tan(FOVY).

Required Features [100 points]

Your first step should be to create a backbuffer and setup OpenGL to display it. All other code you write will directly modify this buffer. You must implement the following features:

• Ray Tracing a Sphere [10 points]

Make your ray tracer able to draw a sphere.

• Ray Tracing a Triangle [10 points]

Make your ray tracer able to draw a single triangle.

• Ray Tracing an OBJ File [10 points]

Read a whole bunch of triangles from an OBJ file and ray trace them.

This will be really slow without a hierarchical bounding structure, so I suggest you start out by using a very low resolution model such as this 150 triangle bunny. You can use Qslim to simplify models.

• Texture Mapping OBJ Files [15 points]

Read image files and texture coordinates from OBJ files to add textures to your raytraced OBJ files. Use barycentric coordinates to calculate the texture coordinates at each pixel. You only need to be able to render triangle meshes (don't worry about quads or polygons with more points).

• Phong Shading [15 points]

Support ambient, diffuse, and specular lighting in your renderer. Interpolate the normals of the vertices of the polygons to determine the normals at each pixel to be used for shading.

• Shadows [10 points]

Add shadows by not illuminating surfaces by lights from which they are occluded.

• Recursive Reflection [15 points]

Create a shiny surface and bounce rays off of it. To make sure the raytracer finishes in a reasonable amount of time, clamp the max bounces to 5.

• ReadMe [5 points]

Include a readme.txt file using this template. Make sure to describe any extra features your raytracer implements.

• Code Quality [5 points]

Use reasonably efficient and well-written code that can easily be graded.

• Representative Pictures [5 points]

Save a number of output pictures from the program to a directory labeled images. Include screenshots demonstrating all of the visible features of the ray tracer (so shadows, textures, etc, but not bounding volumes). Also include one of the Simple Scene Description Format files in the main lab3 directory that you used to generate these images (it has to be different from test.ray!).

Ideas for Extra Credit Features [up to 20 points]

• Recursive Refraction
  Allow transparent surfaces that refract rays.
• Distribution Ray Tracing - Soft Shadows, Depth of Field, or Motion blur
  Cast more rays to create soft shadows, depth of field, or motion blur. Each of these individual features counts as an extra credit feature.
• Spatial Partitioning
  Put your OBJ models in an octtree, BSP tree, or spatial hash data structure to accelerate ray tracing them. I highly recommend implementing this feature, since it will speed up your rendering times significantly, and is pretty fun (if you're into that sort of thing).
• Normal Mapping, Specular Mapping
  We discussed normal mapping in class: rather than using barycentric coordinates to interpolate surface normals over a triangle, use them to interpolate image coordinates and read normals from the image. Specular mapping does the same thing with specularity, instead of assuming a constant specularity coefficient over the whole triangle.

Submission

You can find the lab 3 starter code here. The submission guidelines remain the same as the previous labs. Make sure your project can be compiled by just going into the src directory and typing make.

Please include a copy of whatever models and textures you use when handing in your project as it makes life a lot easier to verify your features.