Project 1

Project Requirements

1. Describe your project topic in class on Thursday, February 23.  Before class, send me via Blackboard exactly one image similar to what you'd like to build (this can be a screenshot, a mockup, an existing photograph, or composite of these), and be ready to answer questions about how you plan to implement your topic.
   
2. An executable code draft is due Thursday, March 1 on Blackboard.
• The code should compile and run.
• It should basically do what you're trying to do.
• It doesn't have to be pretty, or have all the features working yet.
  
3. A 10-minute in-class presentation on Tuesday, March 27.  Show off your code, talk about your method, and so on.
   
4. The final version of your code is due on Thursday, March 29.  This version should be fully functional, polished, and pretty.

Possible Topics (or pick your own!)

• Polish and improve your solution to any homework problem, either for 481 or 381.
• Add any of these features to a raytracer:
• Build an attractive scene using some sort of textures.
• Add procedural texturing, such as polka dots or Perlin noise (see Ken Perlin's Java version, the same code explained, or a GLSL implementation).
  
• Add soft shadows, blurry reflection or refraction, or antialiasing; you can do this by taking multiple samples per pixel (see presentation or notes), or by alpha blending along the edges of the geometry (see Parker et al paper).
  
• Switch to CPU-side computation, to allow true recursion, or execution on crappy graphics cards.  I heartily recommend porting our existing GLSL raytracer to C++ using my C++ vec3 and mat4 classes (osl/vec4.h in any of the example programs).  A really really fast CPU raytracer will still take several seconds per frame, so interactive use is unlikely.
  
• Build any raytracer acceleration structure, such as a graph or grid through space.
• Implement any interesting surface shader on the graphics card.  "Interesting" here could mean an anisotropic (e.g., velvet) shader, a fur shader, a nonphotorealistic (e.g., cartoon) shader, or a subsurface scattering shader.
• Implement or fake any form of global illumination: Radiosity, Jensen's Photon Maps, Precomputed Radiance Transfer, "Radiance"-style raytracing, or make up your own.  See Ray Tracey's Blog for current state of the art examples.
  
• Implement display-time Constructive Solid Geometry (CSG) on the graphics hardware using backface culling and the Z buffer.  You must use CSG to build and display at least one interesting (possibly hardcoded) object containing: at least one intersection or subtraction, and at least one union.  This actually isn't as hard as it sounds as long as the primitive shapes are convex. (Google, Goldfeather's Algorithm Paper).
• Implement reaction-diffusion textures (of any type), on the graphics card or off.
• Implement any type of cellular automata (e.g., Conway's Game of Life).  These are fun to write on the graphics card using a pixel shader!
• Do anything interesting with textures.  For example, make up a 3D texture for some real surface, like tree bark.  Write up a new and nice interface to read a 2D texture from a file.  Blend 2D textures on the CPU or GPU to create new textures.
• Implement a walkthrough of a city model of reasonable size.  Must include at least textured ground, several multistory buildings, and some freestanding foliage.
• Draw a cool scene of your choice.  For example, a volume-rendered smoking volcano, a particle-system fireworks show, an animating "bullet-time" shot.
  
• Draw a pretty tree or other foliage or interesting 3D shape.
• Do something cool on the powerwall.  For example, build a way to tile large images in memory for fast display, or figure out how to hook the powerwall up to a dozen mice, etc.
  
• Do anything interesting with 3D models.  For example, read in a 3D model from a text file, squish the center of a 3D model by doing a nonlinear calculation on its coordinates, etc.
• Implement any mesh simplification, subdivision, modification, or smoothing method, including Garland's Quadric Mesh Simplification, Lindstrom's Terrain Simplification, Taubin Smoothing, or any of the various subdivision schemes.  You can also find and call a library to do any of these, but be aware that this is often harder than just implementing the method yourself!