CS 651-4/551-3: Real-Time Rendering
Assignment #3

Synopsis: Experiment with Cg and do something interesting with particle systems, optionally using the capabilities of the NV30 emulator.

Due:

    Sun Nov 10, 11:59 PM - Checkpoint: do the Cg tutorials.
    Sat Nov 16, 11:59 PM - Final assignment due.

Details: The goal of this assignment is to get you to experiment with writing shaders in the Cg language.  Ideally, you will be able to integrate Cg into your rendering engine; this will let you use not only your own shaders but the many other shaders available at http://developer.nvidia.com/cg and http://cgshaders.org.  However, for the purpose of this assignment you may simply demonstrate your shader on whatever codebase you like.  For example, you may wish to simply build on the Visual Studio projects that come with the tutorials.

Your first task is simply to run through the tutorials (we did the first one in class)  These are quite simple; the main point is to give you an infrastructure for compiling Cg and programs that use the Cg runtime for shaders.  Modifying these shaders and the Visual Studio workspace containing the tutorials should give you an easy way to experiment with your own shaders.  You don't need to turn in anything for this checkpoint, except to send me e-mail announcing that you successfully used Cg and did the tutorials (since the solution is included, this should be hard).  Plus, if you want to do something besides a particle system for the final assignment (see below), you must propose it in your checkpoint e-mail.

Your next task is to build a particle system using vertex programs.  Since vertex programs can calculate the vertex position as a function of time, they can be used to implement simple physical or non-physical particle systems.  For example, a vertex shader can compute the effects of gravity and wind on falling sparks.  Games use this technique frequently to implement explosions, fire, water, grass blowing in the wind, hair, "swarming points of light" magic effects, and yes, splashing blood.  You will probably want to combine such particle systems with the NV_POINT_SPRITE extension, which allows you to draw each vertex as a screen-aligned quadrilateral with a (possibly animated) texture applied.  You may optionally use fragment programs and/or the NV30 Cg profile as well.  Where will you get ideas for this?  Look over the sample shaders in the Cg users guide and at the above web sites, read the book, search the web, ponder the capabilities of the NV30 hardware (your shaders need not use the NV30 emulator, but it will be a lot easier to write interesting shaders using NV30, especially fragment shaders). 

I want to leave open the possibility of doing something else interesting with the exciting capabilities of Cg and the NV30 architecture, so if you would prefer to implement something besides a particle system, you may propose your idea(s) to me at the checkpoint and I will (quickly) give you feedback on their feasibility, on possible approaches, and on useful resources you may wish to consult.  Here are some example ideas to get you thinking:

• Shadow maps: yes, there are sample shaders implementing shadow maps, but you can also figure out how to implement them on your own.  It's not very hard and there is plenty of good info in the textbook and on the web.
• Shadow volumes: A different technique for generating shadows, ideally suited to vertex programs.  Again, there's info in the book and on the web.  You may want to check out the two-sided stencil extension present in NV30.
• Fur: there are multiple techniques for implementing furry objects
• Non-Photorealistic Rendering: The NV30 architecture is perfect for NPR!  Lots of interesting algorithms you could do here: cross-hatching, Dr. Seuss-style rendering, variations on toon shading, painterly rendering.  Tell me what you want to do and convince me that you've read up on the subject (all of these examples are treated in one or more papers).

Once you commit to working on a particular effect, you are committed: no changing your mind at the eleventh hour and trying to whip out a mediocre particle system.  I will work with you to make sure that you don't bite off more than you can chew.

Resources:

•  
Cg:
• You will need the latest version of the NVIDIA Detonator driver (40.72 when I last looked).
• You will want to download the Cg Browser, the Cg Compiler, and the Cg Toolkit document.
• If you use NV30, you will need the NVEmulate.exe program.  This brings up a dialog box allowing you to switch the driver to emulate mode, where OpenGL commands are processed by the CPU (slow) as if they were running on NV30 hardware.  The emulator is only available on Windows
• The Cg Toolkit (which includes all the above) is available for Linux, download the Cg-Beta-2.1.6.i386.rpm package.
• The Cg tutorials are only available on Windows, as far as I can tell.  You can install them using the Cg_Labs_Setup.exe program.
• Everything mentioned above has been installed on the lab machines in 002a, both under windows and linux
• If you want to download and install the files on your own machine, see http://www.cs.virginia.edu/~gfx/Courses/2002/RealTime.fall.02/Cg.
• There is a very simple CgShader class (cgshader.{cpp,h}) in the same directory, written by Nolan Goodnight.  This provides a somewhat simpler interface for writing shaders and binding them at run time.  See cgshader.h for an example.
• 3DSMax is installed on the machines in 002a, and a 5000-object collection of textured LOD'd models is available on the windows share \\eirene.cs.virginia.edu\3dEnc2000. You can browse the models in the collection at www.3Dshort.com.  I particularly like the cow.
• http://developer.nvidia.com/Cg and http://www.cgshaders.org contain helpful info, sample code, and discussion forums.
• Chris Hecker has some good web pages on physical simulation applicable to particle systems.  See:
• http://www.d6.com/users/checker/pdfs/gdmphys1.pdf
• http://www.d6.com/users/checker/pdfs/gdmphys2.pdf
• http://www.d6.com/users/checker/pdfs/gdmphys3.pdf
• http://www.d6.com/users/checker/pdfs/gdmphys4.pdf
• There are also books and Game Programming Gems on game physics that contain some helpful hints about particle systems.

Policy on code reuse: The usual.  You may use your own code or code from outside sources as long as you attribute exactly what you used and where you found it, and share any particularly valuable finds with the rest of the class.  Obviously if you reuse a significant amount of code that raises the bar for the assignment, and you will be expected to do additional work to get the same grade that you would get if you did all the coding yourself.  As always, if you have any questions about code reuse or attribution, please ask me.

Platform: As before, I expect that your code will compile and run on the machines in 002a, either in Windows or Linux.

Turning in the assignment: Put all your code and models in a folder, along with a detailed README.txt file that describes what you did, what code you wrote and what code you used from elsewhere, and how to run your assignment.  Zip up the file and e-mail it to me, or put it somewhere I can download it.  Be sure to include workspace and project files so that I can compile your code.  I will read (and grade you on) your source code, so follow good programming practices.  Naming convention: for (my) convenience, please name the zip file and the enclosing folder of your project with just your last name, e.g. "luebke.zip". 

Advice: Start with a simple Cg shader that implements sinusoidal motion: given a starting position of the vertex (varying parameter) and the current time (uniform parameter), calculate the current position.  Then implement initial velocity (varying parameter) and gravity, for firework-like effects.  Make it pretty by using NV_POINT_SPRITE and fancy textures.  Then go crazy.