Project 1 Intro and Topic
CS 481/681 2010, Dr. Lawlor
Project RequirementsThere are four deliverables for this project: project topic, code
draft, presentation, and final code. Everything should be turned in
electronically via Blackboard (links to be provided from the main page).
- Describe your project topic in class on Tuesday, March 4.
Slides or pictures are not needed, but have about a paragraph-long
description ready, and be ready to answer questions about how you plan
to implement your topic!
- An executable code draft is due Tuesday, March 16.
A 10-minute in-class presentation on Tuesday, March 23. Show off your code, talk about your method, and so on.
- 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.
The final version of your code is due on Tuesday, March 30. This version should be polished and pretty.This project can be done individually, or as part of a group. Note
that 681 students will be expected to complete more sophisticated
Possible Topics (or pick your own!)
Choose any one of these topics, or make up your own topic. Remember
you've got under a month to finish your rough code draft, so keep it
simple! If these
seem too big, feel free to simplify them in your "topic" paper.
- Polish and improve your solution to any homework problem.
- 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 blurring 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/mat4.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.
- Instead of a fixed hardcoded "reflect" parameter, use the Fresnel equations to adjust the reflectivity depending on both material properties and incidence angle.
- 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.
a walkthrough of a city model of reasonable size. Must include at
least textured ground, several multistory buildings, and some
- 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.
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!
- 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.
or fake any form of global illumination: Radiosity, Jensen's Photon
Maps, Precomputed Radiance Transfer, "Radiance"-style raytracing, or make up your own.
- Implement display-time Constructive Solid Geometry (CSG) on
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 any flavor of quality shadows for a moving (possibly
hardcoded) object. We'll be looking at both shadow maps and
shadow volumes, so those would be good choices. Note that painfully fake shadows (e.g., the really easy shadows that are
only cast onto a flat floor) are not acceptable.