Programming Assignment P4:
Ray Tracing

For this assignment, extend the ray caster you wrote in 15-462 to simulate specular reflection and transmission with refraction, fog, soft shadows, and antialiasing. Use this program to make some attractive animation that shows off most of these effects (details below).

Recall that in that assignment, most of you took your OpenGL program to draw a generalized cylinder from asst2/3, and modified it slightly to call our library DL, which emulates OpenGL but creates a display list of triangles and spheres, rather than drawing them. We supplied the framework of a ray tracer and you wrote the guts of it (the ray-triangle and ray-sphere intersection routines, in particular). Together, these components allowed you to do simple ray casting. We strongly suggest you skim the 15-462 asst4 web page to make sure you're up to speed. To check that you have the latest version of the support code, compare yours to src/p4/{raytrace,libdl,raymain}. A couple of you wrote your own ray casters from scratch (that is also an option, but not recommended).

We suggest that the surfaces that you animate and ray trace be either the generalized cylinders you created in 462, or the subdivision surfaces you created in 463 P3, but if you're itching to model some new objects, that it OK.

• Simulate specular reflection and specular transmission with refraction by tracing additional rays. Unless their coefficients are zero, compute the directions of these rays, trace them recursively, and add in their appropriately weighted radiances into the radiance (color) that will be returned for the current ray. A few of you implemented this in 15-462. If so, you've got a head start. There should be a maximum ray depth controllable on the command line or in some convenient way to prevent infinite recursion. Trace to a depth of at least 3 (meaning that photons bouncing three times or fewer should be accounted for).
• Simulate fog. "Fog" is the generic name for volume scattering phenomena. It can be used to make air, water, and glass look more realistic. To simulate it, there's no need to trace additional rays, but you'll need to compute how far rays pass through transparent materials and blend between the radiance at the far end of the ray and the material's fog color.
• Simulate soft shadows. Soft shadows with an umbra and penumbra are caused by area light sources. To simulate these, put some light-emitting spheres in your scene (see tips below) and treat these as area light sources in addition to or instead of the point light sources. You need not implement emissive triangles.
• adaptive antialiasing. Do antialiasing by tracing up to n rays per pixel. To make this efficient, shoot just one ray per pixel initially and then, where the returned radiances of neighboring pixels differ above some threshold, trace n rays per pixel and average those.
• Source code. Leave your code in subdirectories of classdir/students/yourid/p4. We will look at your source during the demo.
• Demo on Apr. 27: Demo your program during the class time on Tuesday, 27 Apr. Show us pictures that demonstrate the required effects above. Since testing refraction is a bit tricky, for this particular feature, compile raymain/glass.cc and link into your ray tracer code, generate a picture, and show us this during your demo.
• Generate animation by May 4: that demonstrates the following effects: texture mapping, specular reflection and/or transmission, fog, shadows (hard or soft), and antialiasing. Note that the animation is not due at the time of the demo. You can change your code after the demo, but most of your grade for this assignment is determined at the demo. Note that you need not do transmission and soft shadows in your animation (these can be slow).

  Frame files should be 640x480 pixel 24 bit tiffs, with filenames of the form ###.tiff, i.e. 000.tiff, 001.tiff, 002.tiff, ... We'll assume that you want your animation recorded at 15 frames per second, unless you tell us otherwise (we can accomodate 30/k fps for any integer k). Please use a 4/3 aspect ratio (width/height in pixels).

  Email andrewb@cs when your animation is done, telling him how many frames, where they are if not in the standard place, and what frame rate (e.g. 30|15|7.5 per second), and anything we should know about glitches. If your animation will be late, the sooner you can tell us how long it will be and when we can expect it, the better. Low resolution (e.g. 320x240), animation without the listed effects, and late animations will be accepted, but penalized.

• Make sure your code for ray-sphere intersection testing is returning the right root in all cases. Return the smallest root with t>epsilon, where epsilon=1e-6 or so. For transparent spheres, if the ray is originating on or inside the surface of the sphere, you want to return the second root. This detail of your code was probably not exercised in 462's asst4.
• To help debug refraction, antialiasing, soft shadows, and other features, see the pictures in pub/pix/p4.
• DL has extra (not in OpenGL) mechanisms for setting the RGB coefficients of specular transmission, the index of refraction, and fog color. See the code (libdl/dlState.cc).
• To create spherical area light sources, call dlMaterialfv(...DL_EMISSION...) and dlSphere(). These will show up as Sphere's in the Scene's primitive list in the ray tracer. We recommend that before the octree is constructed, you make a linked list of emissive primitives by copying them and inserting them in a linked list (see list.hh). You can test if a primitive emits light by testing (prim->mat->emission != Color(0,0,0)).
• When tracing a shadow ray to an area light source, stochastically generate a ray shooting somewhere within the silhouette of the spherical light source.
• To determine the relative index of refraction as you enter a material, you'll need to keep some concept of the current material. The easiest way to do this is set the "enter" flag carefully in your Tri::intersect and Sphere::intersect routines carefully, and then consult this bit to determine if you're entering the solid or exiting the solid. You can assume that transparent solids never intersect. If enter=1 then you're entering the solid (e.g. air into glass) and if enter=0 then you're exiting (e.g. glass into air), and you can set the ratio of indices of refraction accordingly.
• To do fog, use f=exp(-fog_density*distance) and radiance=f*surface_color + (1-f)*fog_color formulas. The fog density and fog color should be associated with the material the ray is currently passing through.
• For antialiasing, we recommend two pass rendering. On the first pass, trace one ray per pixel and save the returned radiances in a 2-D array of RGB colors. On the second pass, revisit each pixel, and if it differs from its four neighbors by more than a threshold, supersample the pixel n times. A reasonable value for n is 16 (e.g. jittered in a 4x4 grid within the square pixel area). The threshold should be settable on the command line. This will allow you to turn the feature off for debugging, by setting the threshold very high. For pixels that are supersampled, average the returned radiances to compute the pixel's color to be written to the picture file.
• In real life, lights attenuate as 1/r^2 with distance, but we don't require you to implement this.

Grading Criteria

• 75%: functioning program during demo
• 25%: nice animation (we expect more than glass balls!)

15-463, Computer Graphics 2
Paul Heckbert