Tag Archives: I3D 2010

I3D 2010 Report

From Mauricio Vives, our first guess blogger; I thank him for this valuable detailed report.

Written February 26, 2010.

This past weekend I attended the 2010 Symposium on Interactive 3D Graphics and Games, known more simply as “I3D.” It is sponsored by ACM SIGGRAPH, and was held this year in Bethesda, Maryland, just outside Washington. Disclaimer: I work for Autodesk, so much of this report comes from the perspective of a design software developer, but any opinions expressed are my own.

Overview

I3D is a small conference of about 100 people that covers computer graphics and interaction research, principally as it applies to games. I also attended the conference in 2008 near San Francisco, when it was co-chaired by my colleague at Autodesk, Eric Haines.

About half of the attendees are students or professors from universities all over the world, and the rest are from industry, typically game developers. As far as I could tell, I was the only attendee from the design software industry. NVIDIA was well represented both in attendees and presentations, and the other company with significant representation was Firaxis, a local game developer most well known for the Civilization series.

The program has a single track, with all presentations given in the same room. Unlike SIGGRAPH, this means that you can literally see everything the conference has to offer, though it is necessarily more focused. As you will see below, I was impressed with the quality and quantity of material presented.

Since this conference is mostly about games, all of the presented research has a focus on a real-time implementation, often for games running at 60 frames per second. Games have a very low tolerance for low frame rates, but they often have static environments and constrained movement which allows for precomputation and hence high performance and convincing results. Conversely, customers of design software like Autodesk’s products produce arbitrary and changing data, and want the most accurate possible results, so precomputation and approximations are less useful, though a frame rate as low as 5 or 10 fps is often tolerable.

However, an emerging trend in graphics research for games is to remove limitations while maintaining performance, and that was very evident at I3D. The papers and posters generally made a point to remove limitations, in particular so that geometry, lighting, and viewpoints can be fully dynamic, without lengthy precomputation. This is great news for leveraging these techniques beyond games.

In terms of technology, this is almost all about doing work on GPUs, preferably with parallel algorithms. NVIDIA’s CUDA was very well-represented for “GPGPU” techniques that could not use the normal graphics pipeline. With the wide availability of CUDA, a theme in problem-solving is to express as much as possible with uniform grids and throw a lot of threads at it! As far as I could tell, Larrabee was entirely absent from the conference. Direct3D 11 was mentioned only in passing; almost all of the papers used D3D9, D3D10, or OpenGL for rendering.

And a random statistic: a bit more than half of the conference budget was spent on food!

Links

The conference web site, which includes a list of papers and posters, is here.

The Real-Time Rendering blog has a recent post by Naty Hoffman that discusses many of the papers and has links to the relevant author web sites.

Photos from the conference are available at Flickr here. I also took photos at I3D 2008, held at the Redwood City campus of Electronic Arts, which you can find here.

Papers

The bulk of the conference program consisted of paper presentations, divided into a few sessions with particular themes. I have some comments on each paper below, with more on the ones of greater personal interest.

Physics Simulation

Fast Continuous Collision Detection using Deforming Non-Penetration Filters

There is discrete collision detection, where CD is evaluated at various time intervals, and continuous CD, where an exact, analytic result is computed. This paper is about quickly computing continuous CD using some simple expressions that vastly reduce the number of tests between primitives.

Interactive Fluid-Particle Simulation using Translating Eulerian Grids

This was authored by NVIDIA researchers. The goal is a fluid simulation that looks better as processors get more and faster cores, i.e., scalable physics. This is actually a combination of techniques implemented primarily with CUDA, and rendered with a particle system. It allows for very dense and detailed results, and uses a simple trick to have the results continue outside the simulation “box.”

Character Animation

Here there was definitely a theme of making it easier for artists to prepare and animate characters.

Learning Skeletons for Shape and Pose

This is about creating skeletons (bones and weights) automatically from a few starting poses and shapes. The author noted that this was likely the only paper developed almost entirely with MATLAB (!).

Frankenrigs: Building Character Rigs From Multiple Sources

This paper has a similar goal: use existing artist-created character rigs to automatically create rigs for new characters, with some artist control to adjust the results. This relies on a database of rigged parts that an art team probably already has, thus it is a data-driven solution for the time-consuming tasks in character rigging.

Synthesis and Editing of Personalized Stylistic Human Motion

This is about taking a walk animation for a single character, and using that to generate new walk animations for the same character, or transfer them to new characters.

Fast Rendering Representations

Real-Time Multi-Agent Path Planning on Arbitrary Surfaces

Path finding in games is a huge problem, but it is normally constrained to a planar surface. This paper implements path planning on any surface, and does it interactively on both the CPU and GPU using CUDA.

Efficient Sparse Voxel Octrees

Is it time for voxel rendering to make a comeback? These researchers at NVIDIA think so. Here they want to represent a 3D scene similar using voxels with as little memory as possible, and render it efficiently with ray casting. In this case, the voxels contain slabs (they call them contours) that better define the surface. Ray casting through the generated octree is done with using special coordinates and simple bit manipulation. LOD is pretty easy: voxels that are too small are skipped, or the smallest level is constrained, similar to MIP biasing.

This paper certainly had some of the most impressive results from the conference. The demo has a lot of detail, even for large environments, where you think voxels wouldn’t work that well. One of the statistics about storage was that the system uses 5-8 bytes per voxel, which means an area the size of a basketball court could be covered with 1 mm resolution on a high-end NVIDIA GPU. This comprises a lot of techniques that could be useful in other domains, like point cloud rendering. Anyway, I recommend looking at the demo video and if you want to know more, see the web site, which has code and the compiled demo.

On-the-Fly Decompression and Rendering of Multiresolution Terrain

This paper targets GIS and sci-vis applications that want lossless compression, instead of more-common lossy compression. The technique offers variable rate compression, with 3-12x compression in practice. The decoding is done entirely on the GPU, which means no bus bottleneck, and there are no conditionals on decoding, so it can be very parallel. Also of interest is that decoding is done right in the rendering path, in the geometry shader (not in a separate CUDA kernel), and it is thus simple to perform lighting with dynamically generated normals. This is another paper that has useful ideas, even if you aren’t necessarily dealing with terrain.

GPU Architectures & Techniques

A Programmable, Parallel Rendering Architecture for Efficient Multi-Fragment Effects

The problem here is rendering effects that require access to multiple fragments, especially order-independent transparency, which the current hardware graphics pipeline does not handle well. The solution is impressive: build a entirely new rendering pipeline using CUDA, including transforms, culling, clipping, rasterization, etc. (This is the sort of thing Larrabee has promised as well, except the system described here runs on available hardware.)

This pipeline is used to implement a multi-layer depth buffer and color buffer (A-buffer), both fixed size, where fragments are inserted in depth-sorted order. Compared to depth peeling, this method saves on rendering passes, so is much faster and has very similar results. The downside is that it is a slower than the normal pipeline for opaque rendering, and sorting is not efficient for scenes with high depth complexity. Overall, it is fast: the paper quoted frame rates in the several hundreds, but really they should be getting their benchmark conditions complex enough to measure below 100 fps, in order to make the results relevant.

Parallel Banding Algorithm to Compute Exact Distance Transform with the GPU

The distance transform, used to build distance maps like Voronoi diagrams, is useful for a number of image processing and modeling tasks. This has already been computed approximately on GPUs, and exactly on CPUs. This claims to the first exact solution that runs entirely on GPUs. The big idea, as you might expect, is to implement all phases of the solution in a parallel way, so that it uses all available GPU threads. This uses CUDA, and the results are quite fast, even faster than the existing approximate algorithms.

Spatio-Temporal Upsampling on the GPU

The results of this paper are almost like magic, at least to my eyes. Upsampling is about rendering at a smaller resolution or fewer frames, and interpolating the in-between results somehow, because the original data is not available or slow to obtain. Commonly available 120 Hz / 240 Hz TVs now do this in the temporal space. There is a lot of existing research on leveraging temporal or spatial coherence, but this work uses both at once. It takes advantage of geometry correlation within images, e.g. using normals and depths, to generate the new useful information.

I didn’t follow all of the details, but the results were surprisingly free of artifacts, at least for the scenes demonstrated. This could be useful any place where you might want progressive rendering, real-time ray tracing, because rendering full-resolution is very expensive. This technique or some of the ones it references (like this one) could offer much better results than just rendering at a lower resolution and doing simple filtering like is often done for progressive rendering.

Scattering and Light Propagation

Cascaded Light Propagation Volumes for Real-Time Indirect Illumination

This paper almost certainly had the most “street cred” by virtue of being developed by game developer Crytek. Simply put, this is a lattice-based technique for real-time indirect lighting. The most important features are that it is fully dynamic, scalable, and costs around 5 ms per frame. A very quick overview of how it works: render reflective shadow map for each light, initialize the grid with this information to define many secondary light sources, then propagate light through the grid in 30 directions (faces) from each cell into the adjacent 6 cells, approximate the results with spherical harmonics, and render.

To manage performance and storage, this uses cascades (several levels of detail) relative to the viewer, hence the use of the term “cascaded” in the title. The same data and technique can be used to render secondary occlusion, multiple bounces, glossy reflections, participating media using ray marching… just a crazy amount of nice rendering stuff. The use of a lattice has some of its own quality limitations, which they discuss, but nothing too bad for a game. This was a lot to take in, and I did not follow all of the details, but the results were very inspiring. Apparently this will appear in the next version of their game engine, which means consumers will soon come to expect this. Crytek apparently also discussed this at SIGGRAPH last year.

Interactive Volume Caustics in Single-Scattering Media

Caustics is basically “light focusing,” and scattering media is basically “fog / smoke /water,” so this is about rendering them together interactively, e.g. stage lights at a concert with a fog machine, or sunlight under water.  It is fully dynamic, and offers surprisingly good quality under a variety of conditions. It is perhaps too slow for games, but would be fine for design software or a hardware renderer which can take a few seconds to render.

Epipolar Sampling for Shadows and Crepuscular Rays in Participating Media with Single Scattering

This paper has a really long title, but what it is trying to do is simple: render rays of light, a.k.a. “god rays.” Normally this is done with ray marching, but this is still too slow for reasonable images, and simple subsampling doesn’t represent the rays well. The authors observed that radiance along the ray “lines” don’t change much, except for occlusions, which leads to the very clever idea of the paper: construct the (epipolar) lines in 2D around the light source, and sparsely sample along the lines, adding more samples at depth changes. The sampling data is stored as a 2D texture, one row per line, with samples are in columns. It’s fast, and looks great.

NPR and Surface Enhancement

Interactive Painterly Stylization of Images, Videos and 3D Animations

This is another title that direct expresses its goal. Here the “painterly” results are built by a pipeline for stroke generation, with many thousands of strokes per image, which also leverages temporal coherence for animations. It can be used on videos or 3D models, and runs entirely on the GPU. If you are working with NPR, you should definitely look at their site, the demo video, and the referenced papers.

Simple Data-Driven Modeling of Brushes

A lot of drawing programs have 2D brushes, but real 3D brushes can represent and replace a large number of 2D brushes. However, geometrically modeling the brush directly can lead to bending extremes that you (as an artist) usually want to avoid. In this paper from Microsoft Research, the modeling is data-driven, based on measuring how real brushes deform in two key directions. The brush is geometrically modeled with only a few spines having a variable number of segments as bones.

This has some offline precomputation, but most of the implementation is computed at run time. This was one of the few papers with a live demo, using a Wacom tablet, and it was made available for attendees to play with. See an example from an attendee at the Flickr gallery here.

Radiance Scaling for Versatile Surface Enhancement

This is about rendering geometry in such a way the surface contours are not obscured by shading. This is the problem that techniques like the “Gooch” style try to solve. However, the technique in this paper does it without changing the perceived material, sort of like an advanced sharpening filter for 3D models.

It describes a scaling function based on curvature, reflectance, and some user controls, which is then trivially multiplied with the normally rendered image. The curvature part is from a previous paper by the authors, and reflectance is based on BRDF, where you can enhance BRDF components independently. You should definitely have a quick look at the results here.

Shadows and Transparency

Volumetric Obscurance

This is yet-another screen-space ambient occlusion (SSAO) technique. Instead of point sampling, it samples lines (or beams of area) to estimate the volume of sample spheres that are obscured by surrounding geometry. It claims to get smoother results than point sampling, without requiring expensive blurring, and with the performance (or even better) of point sampling. You can see some results at the author’s site here. While it has a few interesting ideas, this may or may not be much better than an existing SSAO implementation you may already have. I found the AO technique in one of the posters (see below) more compelling.

Stochastic Transparency

This was selected as the best paper of the conference. Like one of the earlier papers, this tries to deal with order-independent transparency, but it does it very differently. The author described it as “using random numbers to approximate order-independent transparency.” It has a nice overview of existing techniques (sorting, depth peeling, A-buffer). The new technique does away with any kind of sorting, is fast, and requires fixed memory, but is only approximate. It was demonstrated interactively on some very challenging scenes, e.g. thousands of transparent strands of hair and blades of grass.

The idea is to collect rough statistics about pixels, similar to variance shadow maps, using a combination of screen-door transparency, multisampling (MSAA), and random masks per fragment (with D3D 10.1). This can generate a lot of noise, so much of the presentation was devoted to mitigating that, such as using per-primitive random number seeding to look OK in motion. This is also extended to shadow maps for transparent shadows. Since this takes advantage of MSAA and is parallel, quality and performance will increase with normal trends in hardware. It was described as not quite fast enough for games (yet), but (again) it might be fast enough for other applications.

Fourier Opacity Mapping

The goal of this work is to add self-shadowing to smoke effects, but it needs to be simple to integrate, scalable, and execute in just a few milliseconds. The technique is based on opacity shadow mapping (2001), which stores a transmittance function per texel, but has significant visual artifacts. Here a Fourier basis is used to encode the function, and you can adjust the number of coefficients (samples) to determine the quality / performance tradeoff. Using just a few coefficients results in “ringing” of the function, but it turns out that OK for smoke and hair. The technique was apparently implemented successfully in last year’s Batman: Arkham Asylum.

Normals and Textures

Assisted Texture Assignment

This paper is about making it much easier and faster for artists to assign textures to game environments (levels). It is an ambiguous problem, with limited input to make decisions. The solution relies on adjacency and shape similarities, e.g. two surfaces that are parallel are likely to have the same texture. The artist picks a surface, and related surfaces are automatically chosen. After a few textures are assigned, the system produces a list of candidate textures based on previous choices. There is some preprocessing that has to be performed, but once ready, the system seems to work great. Ultimately this is not about textures; rather, this is an advanced selection system.

LEAN Mapping

“LEAN” is a long acronym for what is essentially antialiasing of bump maps. Without proper filtering, minified bump maps provide incorrect specular highlights: the highlights change intensity and shape as the bump maps gets small in screen space. The paper implements a technique for filtering bump maps using some additional data on the distribution of bumped normals, that can be filtered like color textures. The math to derive this is not trivial, but the implementation is simple and inexpensive.

The results look great in motion, at glancing angles, minified, magnified, and with layered maps. It also has the distinctive property of turning grooves into anisotropy under minification, something I have never seen before.

Efficient Irradiance Normal Mapping

There are a few well-known techniques in games for combining light mapping and normal mapping, but they are very rough approximations of the “ground truth” results. This paper introduces an extension based on spherical harmonics, but only over a hemisphere, that significantly improves the quality of irradiance normal mapping. Strangely, no mention was made of performance, so I would have to assume that it runs as fast as the existing techniques, just with different math.

Posters

The posters session was preceded by a brief “fast forward” presentation with each author having a minute to describe their work. There were about 20 posters total, and I have comments on a few of them.

Ambient Occlusion Volumes (link)

This is a geometric solution to the problem of rendering convincing ambient occlusion, compared to the screen-space (SSAO) techniques which are faster, but less accurate. The results are very close to ray-traced results, and while it appears to be too slow for games right now (about 30 ms to render), that will change with faster hardware.

Real Time Ray Tracing of Point-based Models (link)

The title says it all. I didn’t look into this too much, but I wanted to highlight it because it is getting cheaper to get point cloud data, and it would be great to be able to render that data with better materials and lighting.

Asynchronous Rendering

This poster has an awfully generic name, but it is really about splitting rendering work between a server and a low-spec client, like a mobile phone. In this case, the author demonstrated precomputed radiance transfer (PRT) for high-quality global illumination, where the heavy processing was done on the server, while still allowing the client (here it was an iPhone) to render the results and allow for interactive lighting adjustments. For me the idea alone was interesting: instead of just having the server or client do all the work, split it in a way that leverages the strengths of each.

Speakers

A few academic and industry speakers were invited to give 90-minute presentations.

Biomechanical and Artificial Life Simulation of Humans for Computer Animation and Games

The keynote address was given by Demetri Terzopoulos of UCLA. I was not previously familiar with his work, but apparently he has a very long resume of work in computer graphics, including one of the most cited papers ever. The talk was an overview of his research from the last 15 years on modeling human geometry, motion, and behavior. He started with the face, then the neck, and then the entire body, each modeled in extensive detail. His most recent model has 75 bones, 846 muscles, and 354,000 soft tissue elements.

The more recent work is in developing intelligent agents in urban settings, each with a set of social behaviors and goals, though with necessarily simple physical models. The eventual and very long-term goal is to have a full-detail physical model coupled with convincing and fully autonomous behavior.

Interactive Realism: A Call to Arms

The dinner talk was given by Peter Shirley of NVIDIA. This was the “motivational” talk, with his intended goal of having computer graphics that are both pleasing and predictive. Some may think that we have already reached the point of graphics that are “good enough,” but he disagrees. He referenced recent games and research to point out the areas that he feels needs the most work. From his slides, these are:

  • Volume lighting / shadowing
  • Indoor-outdoor algorithms
  • Coarse / fine lighting
  • Artist / designer-in-the-loop
  • Motion blur and defocus blur
  • Material models
  • Polarization
  • Tone mapping

He concluded with some action items for the attendees, which includes reforming the way computer graphics research is done, and lobbying for more funding. From the talk and subsequent Q&A, it looks like a lot of people are not happy with the way SIGGRAPH handles papers, a world I know very little about.

The Evolution of Precomputed Lighting for Games

The capstone address was given by Peter-Pike Sloan of Disney Interactive Studios. He presented essentially a history of precomputed lighting for games from Quake, to Halo 3, and beyond. Such lighting trades off flexibility for quality and performance, i.e. you can get very convincing and fast lighting with some important restrictions. This turned out to be a surprisingly large topic, split mostly between techniques for static and dynamic elements, like environments and characters, respectively.

You may wonder why this is relevant beyond a history lesson, the trend in research being for techniques to not require precomputation, and that includes lighting. But precomputed lighting is still relevant for low-end hardware, like mobile devices, and cases where artist control is more important than automated results.

Wrap It Up!

Thanks for making it this far. As you can see, it was a very busy weekend! Like the 2008 conference, this was a great opportunity to see the state-of-the-art in computer graphics and interaction research in a more intimate setting. I hope this was useful, and please reply here if you have any comments.

Cascaded Light Propagation Volumes for Indirect Illumination

This I3D 2010 paper by Anton Kaplanyan (Crytek) and Carsten Daschbacher (University of Stuttgart) is now online on Crytek’s publications page, with video and talk slides.  The paper extends and describes in more detail the real-time global illumination technique Anton presented at SIGGRAPH 2009.  The most significant extension over the SIGGRAPH 2009 presentation is the addition of coarse occlusion for indirect bounce light.

Although there have been many recent papers on “real-time” global illumination, this technique is the only one so far that is at all feasible for current-generation consoles.  Crytek’s new CryEngine 3 has implementations of it on XBox 360 and Playstation 3, and the technique will presumably be used in the upcoming Crysis 2 game as well.

Efficient Sparse Voxel Octrees

I mentioned this I3D 2010 paper in a blog post a while ago, but there was no preprint for it at the time.  Now the floodgates of information have been opened with the preprint, a video, and an extended paper all available on the first author’s website.  The source code has also been open-sourced with the Apache 2.0 license and posted on Google Code.

I’m not that familiar with previous work in the area, so I don’t know how it stacks up against e.g. Gigavoxels; if anyone has any insight please let me know.  One interesting detail from the paper was the way they enhance each cubical voxel with a pair of bounding planes, which they call contours.

They show that the data structure enables casting rays significantly faster than against a triangle model of equivalent complexity.  Unfortunately, it appears to still be slower than rendering the triangles the “old-fashioned way”.  The technique also requires post-filtering since it does not allow for filtering of color and normal information (which is effectively point-sampled).  Finally, building the data structure takes a fair bit of time, making this not particularly well-suited for dynamic scenes.

I3D 2010 Papers

The Symposium on Interactive 3D Graphics and Games (I3D) has been a great little conference since its genesis in the mid-80s, featuring many influential papers over this period.  You can think of it as a much smaller SIGGRAPH, focused on topics of interest to readers of this blog.  This year, the I3D papers program is especially strong.

Most of the papers have online preprints (accessible from Ke-Sen Huang’s I3D 2010 paper page), so I can now do a proper survey.  Unfortunately, I was able to read two of the papers only under condition of non-disclosure (Stochastic Transparency and LEAN Mapping).  Both papers are very good; I look forward to being able to discuss them publicly (at the latest, when I3D starts on February 19th).

Other papers of interest:

  • Fourier Opacity Mapping riffs off the basic concept of Variance Shadow Maps, Exponential Shadow Maps (see also here) and Convolution Shadow Maps.  These techniques store a compact statistical depth distribution at each texel of a shadow map; here, the quantity stored is opacity as a function of depth, similarly to the Deep Shadow Maps technique commonly used in film rendering.  This is applied to shadows from volumetric effects (such as smoke), including self-shadowing.  This paper is particularly notable in that the technique it describes has been used in a highly regarded game (Batman: Arkham Asylum).
  • Volumetric Obscurance improves upon the SSAO technique by making better use of each depth buffer sample; instead of treating them as point samples (with a simple binary comparison between the depth buffer and the sampled depth), each sample is treated as a line sample (taking full account of the difference between the two values).  It is similar to a concurrently developed paper (Volumetric Ambient Occlusion); the techniques from either of these papers can be applied to most SSAO implementations to improve quality or increase performance.  The Volumetric Obscurance paper also includes the option to extend the idea further and perform area samples; this can produce a simple crease shading effect with a single sample, but does not scale well to multiple samples.
  • Spatio-Temporal Upsampling on the GPU – games commonly use cross-bilateral filtering to upsample quantities computed at low spatial resolutions.  There have also been several recent papers about temporal reprojection (reprojecting values from previous frames for reuse in the current frame); Gears of War 2 used this technique to improve the quality of its ambient occlusion effects. The paper Spatio-Temporal Upsampling on the GPU combines both of these techniques, filtering samples across both space and time.
  • Efficient Irradiance Normal Mapping – at GDC 2004, Valve introduced their “Irradiance Normal Mapping” technique for combining a low-resolution precomputed lightmap with a higher-resolution normal map.  Similar techniques are now common in games, e.g. spherical harmonics (used in Halo 3), and directional lightmaps (used in Far Cry).  Efficient Irradiance Normal Mapping proposes a new basis, similar to spherical harmonics (SH) but covering the hemisphere rather than the entire sphere.  The authors show that the new basis produces superior results to previous “hemispherical harmonics” work.  Is it better than plain spherical harmonics?  The answer depends on the desired quality level; with four coefficients, both produce similar results.  However, with six coefficients the new basis performs almost as well as quadratic SH (nine coefficients), making it a good choice for high-frequency lighting data.
  • Interactive Volume Caustics in Single-Scattering Media – I see real-time caustics as more of an item to check off a laundry list of optical phenomena than something that games really need, but they may be important for other real-time applications.  This paper handles the even more exotic combination of caustics with participating media (I do think participating media in themselves are important for games).  From a brief scan of the technique, it seems to involve drawing lines in screen space to render the volumetric caustics.  They do show one practical application for caustics in participating media – underwater rendering.  If this case is important to your application, by all means give this paper a read.
  • Parallel Banding Algorithm to Compute Exact Distance Transform with the GPU – I’m a big fan of Valve’s work on using signed distance fields to improve font rendering and alpha testing.  These distance fields are typically computed offline (a process referred to as “computing a distance transform”, sometimes “an Euclidian distance transform”).  For this reason, brute-force methods are commonly employed, though there has been a lot of work on more efficient algorithms.  This paper gives a GPU-accelerated method which could be useful if you are looking to speed up your offline tools (or if you need to compute alpha silhouettes on the fly for some reason).  Distance fields have other uses (e.g. collision detection), so there may very well be other applications for this paper.  Notably, the paper project page includes links to source code.
  • A Programmable, Parallel Rendering Architecture for Efficient Multi-Fragment Effects – one of the touted advantages of  Larrabee was the promise of flexible graphics pipelines supporting stuff like multi-fragment effects (A-buffer-like things like order independent transparency and rendering to deep shadow maps).  Despite a massive software engineering effort (and an instruction set tailored to help), Larrabee has not yet been able to demonstrate software rasterization and blending running at speeds comparable to dedicated hardware.  The authors of this paper attempt to do the same on off-the-shelf NVIDIA hardware using CUDA – a very aggressive target!  Do they succeed?  it’s hard to say.  They do show performance which is pretty close to the same scene rendering through OpenGL on the same hardware, but until I have time to read the paper more carefully (with an eye on caveats and limitations) I reserve judgment.  I’d be curious to hear what other people have to say on this one.
  • On-the-Fly Decompression and Rendering of Multiresolution Terrain (link is to an earlier version of the paper) – the title pretty much says it all.  They get compression ratios between 3:1 and 12:1, which isn’t bad for on-the-fly GPU decompression.  A lot of water has gone under the terrain rendering bridge since I last worked on one, so it’s hard for me to judge how it compares to previous work; if you’re into terrain rendering give it a read.
  • Radiance Scaling for Versatile Surface Enhancement – this could be thought of as an NPR technique, but it’s a lot more subtle than painterly techniques.  It’s more like a “hyper-real” or “enhanced reality” technique, like ambient occlusion (which darkens creases a lot more than a correct global illumination solution, but often looks better; 3D Unsharp Masking achieves a more extreme version of this look).  Radiance Scaling for Versatile Surface Enhancement is a follow-on to a similar paper by the same authors, Light Warping for Enhanced Surface Depiction.  Light warping changes illumination directions based on curvature, while radiance scaling scales the illumination instead, which enables cheaper implementations and increased flexibility.  With some simplifications and optimizations, the technique should be fast enough for most games, making this paper useful to game developers trying to give their game a slightly stylized or “hyper-real” look.
  • Cascaded Light Propagation Volumes for Real-time Indirect Illumination – this appears to be an updated (and hopefully extended) version of the CryEngine 3 technique presented by Crytek at a SIGGRAPH 2009 course (see slides and course notes).  This technique, which computes dynamic approximate global illumination by propagating spherical harmonics coefficients through a 3D grid, was very well-received, and I look forward to reading the paper when it is available.
  • Efficient Sparse Voxel Octrees – there has been a lot of excited speculation around raycasting sparse voxel octrees since John Carmack first hinted that the next version of id software‘s rendering engine might be based on this technology.  A SIGGRAPH 2008 presentation by Jon Olick (then at id) raised the excitement further (demo video with unfortunate soundtrack here).  The Gigavoxels paper is another example of recent work in this area.  Efficient Sparse Voxel Octrees promises to extend this work in interesting directions (according to the abstract – no preprint yet unfortunately).
  • Assisted Texture Assignment – the highly labor-intensive (and thus expensive) nature of art asset creation is one of the primary problems facing game development.  According to its abstract (no preprint yet), this paper proposes a solution to part of this problem – assigning textures to surfaces.  There is also a teaser posted by one of the authors, which looks promising.
  • Epipolar Sampling for Shadows and Crepuscular Rays in Participating Media with Single Scattering – volumetric effects such as smoke, shafts of light (also called “god rays” or crepuscular rays) and volumetric shadows are important in film rendering, but usually missing (or coarsely approximated) in games.  Unfortunately, nothing is known about this paper except its title and the identities of its authors.  I’ll read it (and pass judgement on whether the technique seems practical) when a preprint becomes available (hopefully soon).

The remaining papers are outside my area of expertise, so it’s hard for me to judge their usefulness:

I3D 2010 Registration Open

I3D 2010 is located just north of Washington, DC this year, during the weekend of February 19-21 (Friday through Sunday). It will be at the Bethesda Hyatt Regency, which is conveniently located right on the Metro Red Line.

The early registration deadline for I3D itself is January 20th; hotel registration at the conference discount rate of $115 is available until January 19th.

Ke-Sen Huang has added a few paper links since we last mentioned his page, though the majority are still not available from authors’ pages. Somewhat surprising, given that December 14 was the camera-ready deadline, but perhaps some people are still returning back to their universities & colleges and haven’t gotten around to putting theirs up. That said, conferences like I3D are only partly about the papers and posters themselves. They also offer a unique and wonderful opportunity to meet and talk with leading and up-and-coming researchers and practitioners. It’s a fantastic feeling to be in an area for a few days where just about everyone there is working on ideas that are of interest to you. Anyone you meet knows something you don’t, and vice versa, and most people talk freely about what works and what doesn’t. Energizing and useful. Plus, they’re just fun people to be around, at least for this nerd.