This paper by Govindaraju et al. describes an approach for collision detection between multiple deformable and breakable objects in a large environment using graphics hardware. The algorithm uses a two-pass rendering scheme to compute a potentially colliding set (PCS) in linear time using visibility queries with no precomputation or frame buffer read back. ( CULLIDE: Interactive Collision Detection Between Complex Models in Large Environments Using Graphics Hardware. Naga Govindaraju, Stephane Redon, Ming C. Lin and Dinesh Manocha. To appear in Proceedings of Graphics Hardware 2003)

This paper by Purcell et al. presents a photon mapping algorithm that runs entirely on the GPU. The paper presents details for tracing photons, building the photon map, and computing the radiance estimate at each pixel using a k-nearest neighbor search.(Photon Mapping on Programmable Graphics Hardware. Timothy J. Purcell, Craig Donner, Mike Cammarano, Henrik Wann Jensen, and Pat Hanrahan. Proceedings of Graphics Hardware 2003, July 2003.)

This paper by Carr et al. describes a method for computing subsurface scattering on the GPU. They use a multi-resolution meshed atlas and modern GPU programmability to devise a real-time GPU algorithm that can render semi-transparent objects with diffuse subsurface-scattered illumination under dynamic lighting and viewing conditions. (GPU Algorithms for Radiosity and Subsurface Scattering. Nathan A. Carr, Jesse D. Hall, and John C. Hart. Proceedings of Graphics Hardware 2003, July 2003.)

This paper by Bill Mark et. al describes the Cg high-level graphics hardware programming language and the associated run-time system. The paper details the rationale behind the decisions made in the design of the language. (Cg: A system for programming graphics hardware in a C-like language. Bill Mark, R. Steven Glanville, Kurt Akeley, and Mark J. Kilgard. To appear in the proceedings of SIGGRAPH 2003.)

This paper by Harris et al. at UNC Chapel Hill describes a physically-based, visually-realistic interactive cloud simulation implemented on programmable GPUs. The simulation uses “flat 3D textures” – 3D data laid out as slices tiled in a 2D texture – to implement efficient 3D simulations on the GPU. The work required to simulate a single time step is automatically spread over many frames while the user views the results of the previous time step at high frame rates. (Simulation of Cloud Dynamics on Graphics Hardware. Mark J. Harris, William V. Baxter III, Thorsten Scheuermann and Anselmo Lastra. To appear in Proceedings of Graphics Hardware 2003.)

This paper by Theodore Kim and Ming Lin describes a physically-based technique for simulating ice crystal growth. The most expensive part of the simulation pipeline, the phase and temperature field calculations, can be mapped to graphics hardware. The resulting implementation experiences up to a 9x speedup. (Visual Simulation of Ice Crystal Growth. Theodore Kim and Ming Lin. To appear in the proceedings of ACM SIGGRAPH / Eurographics Symposium on Computer Animation 2003.)

This SIGGRAPH 2003 paper by Karl Hillesland, Sergey Molinov, and Radek Grzeszczuk casts nonlinear optimization as a data streaming process for computation on GPUs. The authors apply this approach to two distinct image-based modeling problems: light field mapping approximation and fitting the Lafortune model to spatial BRDFs. (Nonlinear Optimization Framework for Image-Based Modeling on Programmable Graphics Hardware. Karl E. Hillesland, Sergey Molinov, and Radek Grzeszczuk. To appear in the proceedings of SIGGRAPH 2003.)

This paper by Bolz et al. of Cal Tech shows two basic, broadly useful, computational kernels implemented on GPUs: a sparse matrix conjugate gradient solver, and a regular-grid multigrid solver. The paper demonstrates a prototype implementation on NVIDIA’s GeForce FX, using geometric flow (cube smoothing movie, 3D photography scan denoising movie) and fluid simulation (particle advection movie) as application examples. (Sparse Matrix Solvers on the GPU: Conjugate Gradients and Multigrid. Jeff Bolz, Ian Farmer, Eitan Grinspun and Peter Schröder. To appear in the proceedings of SIGGRAPH 2003.)

This Graphics Architecture course taught by John Owens at the University of California, Davis, includes content on traditional graphics architecture, as well as programmable shading, stream processing, and general purpose computation. (UC Davis EEC 289P, Graphics Architecture, Spring 2003.)

This demo by Simon Green of NVIDIA demonstrates Verlet cloth simulation implemented on the GPU using fragment programs and floating point buffers. It uses the GL_NV_pixel_data_range OpenGL extension to implement “render to vertex array” in order to render the cloth as a mesh. (Cloth Simulation Demo)