SIGGRAPH 2004 Report
by Dave Astle

SIGGRAPH 2004 was held August 8-12 in the Los Angeles Convention Center. Since this was my second SIGGRAPH, I had a better idea of what to expect and how to get the most out of it.

I'm posting this a little later than expected due to travel and some family issues that came up, so I apologize for the delay.

I spent most of my time attending sessions, and very little time on the expo floor. SIGGRAPH, of course, covers the gamut of graphics-related topics, from film, to simulation, to interfaces, and more. I naturally chose to focus on topics related to game development, in particular real-time rendering. I was pleased to discover that I was able to fill almost five solid days with relevant presentations, which was an improvement over last year. I even had to skip a few courses covering real time collision detection and animation techniques due to scheduling conflicts.

Course/Paper/Sketch Summaries

As much as I'd like to, it's impossible for me to completely convey the information gleaned from the presentations I attended. Instead, I'll provide a high-level overview, and where possible I'll provide links to the presenters' websites where you can read more if you're interested. Also, the ACM sells DVDs containing the presentations, as well as video of many of the courses. You can order these from the SIGGRAPH website, though at the time of this writing, the DVDs from this year aren't online yet.

Real-Time Shading (course)

The conference kicked off (for me at least) with the full-day real-time shading course, which I also attended last year. This year, the focus was more on shading languages/technologies than specific techniques being done using shaders.

One of the most interesting parts of this course was the presentation of Sh. Sh is a high-level metaprogramming language for GPUs. It's built on top of C++, and is intended to allow you to write shaders that are more easily portable using a familiar syntax. It also manages textures as well as shaders. Whether or not Sh will see wide adoption remains to be seen, but a subsequent presentation of it at ATI's booth on the expo floor was completely packed. You can find out more about Sh at libsh.org.

Rather than attempting to cover the rest of the course, I'll instead point you to course organizer Marc Olano's homepage, where all of the presentations are included.

Performance OpenGL (course)

I'd been told in the past that this course was really basic, so I didn't bother attending last year. I caught about an hour of it this year though, and what I saw was pretty useful, though there were a few things that seemed really obvious (and I was pretty surprised at one point to have one of the presenters spend time explaining what triangle strips are and why they're more efficient, after asking if there was anyone in the room not familiar with triangle strips and seeing not a single hand raised).

Of what I saw, the most interesting was regarding the use of occlusion queries. I haven't worked with them much myself, but I've gotten the impression that they're not that useful in improving performance. The presenters' results disagree with that, however.

They recommended sorting your geometry coarsely and cheaply, drawing near to far, drawing bounding objects using occlusion queries (batching them in groups of about 10% of the total load and doing other things while the queries execute), and then rendering non-occluded objects. In the test applications they used, the performance improvements were dramatic, though admittedly they were comparing it against a brute force approach. They also stated that occlusion queries could be used to efficiently determine LOD, as well as for frustum culling.

You may want to check out the slides from this course at performanceopengl.com. At the time of this writing, they haven't been posted yet, but they should be up soon, and in the meantime, presentations from past years are available.

I've Seen Fire and I've Seen Rain (Sketch)

This sketch covered fire, rain, snow, and ice rendering techniques. The first covered a really nice looking physically based ice modeling technique, which unfortunately isn't doable in real-time. The third covered the creation of atmospheric effects in Van Helsing, and the fourth covered image-based flame rendering, neither of which offer anything useful for games.

That leaves the second sketch, given by a former Microsoft Games employee, who described how they simulated rain and snow in Microsoft Flight Simulator.

The goal for the technique was to create realistic-looking snow and rain that doesn't degrade performance as the number of snowflakes or raindrops increase. Their solution was to use 4 texture planes, each with smaller drops/flakes moving slower than the last layer, for a sort of parallax effect. The rain textures are stretched to simulate the motion blur that happens with rainfall. These textures are applied to a double cone centered on the camera. As the camera speed changes, the cones tilt to simulate the rain/snow moving more quickly toward the viewer.

The results of this are pretty impressive and are very inexpensive. You can read more about the technique at http://ofb.net/~niniane/rainsnow/.

Real-Time Shadowing Techniques (course)

This was an all-day course on day 3. Unfortunately, I had other things that prevented me from attending the entire course, but I was able to attend about half of it. The course focused on coverage of the two main approaches to rendering shadows in real time: shadow maps and shadow volumes. If you're not familiar with either technique, check out our shadowing articles here, or any of the other abundant resources covering them.

Shadow maps have been around for a long time, produce good results, allow for self shadowing and soft shadows, and are relatively inexpensive (especially since they're now widely supported in hardware). Two major challenges with them are that they don't work well with omnidirectional point lights, and they have major aliasing problems, even with high-resolution textures. The former problem will be solved once hardware supports shadow cube maps, but the aliasing problem remains a challenge.

A solution to the aliasing problem presented during the course introduces the concept of silhouette maps. As the name implies, these maps capture data along the silhouette edges of shadow casters. This additional detail can then be used in conjunction with a shadow map in the fragment shader to more accurately decide whether or not a pixel is in shadow. The resulting images look as good as shadow volumes, at about half the cost (at least in the test cases used in developing the technique). Details can be found here.

The following links are for other presentations (or as close as I could find) included in this course:

Rendering Fake Soft Shadows with Smoothies
Perspective Shadow Maps
Linear Light Sources
Soft Shadow Volumes
Radiance Transfer Shadows

GPU 1 & 2 (sketch)

These sketches covered using programmable GPUs in non-conventional ways. Four of the sketches were noteworthy for games, though all were interesting.

One covered UberFlow, a particle engine very similar in concept to the method described in a recent article on Gamasutra (in turn, taken from the GDC). The basic idea is to make particle system rendering more efficient by greatly reducing bandwidth consumption. This is done by storing particle attributes in textures. Attribute data can either be used statically, requiring only that the current time be updated every frame, or dynamically, rendering values to the textures as they change. As the title from the Gamasutra article suggest, this allows for much more efficient rendering, allowing many more particles to be used, resulting in better particle effects. The downside is that reading from textures in the vertex shader requires Vertex Shader 3.0 compliant hardware, which won't be widespread for quite some time.

You can read more about UberFlow from ATI.

CC Shadow Volumes presented a method of speeding up shadow volumes by culling shadow casters that are completely shadowed (thereby reducing the number of volumes rendered) and clamping the volumes to only include the objects being shadowed.

Finally, there were two sketches covering techniques used for the hair and skin in ATI's Ruby demo.

Textures (sketch)

I attended this for the PACKMAN texture compression scheme for mobile devices, which I imagine most people won't be interested in unless they're developing mobile graphics hardware. If that's you, you can read more at http://graphics.cs.lth.se/research/mobile/.

I also stuck around for Tile-Based Texture Mapping on Graphics Hardware which essentially allows you to fake having really large textures for things like terrain rendering.