|
Graphics: All Articles
Vertex Shader Tesselation |
Real-time Deformable Terrain Rendering |
Optimized Stadium Crowd Rendering |
Geometric Anti-Aliasing Methods |
Practical Elliptical Texture Filtering |
An Approximation to the Chapman Grazing-Incidence Function for Atmospheric Scattering |
Volumetric Real-Time Water and Foam Rendering |
Inexpensive Anti-Aliasing of Simple Objects |
Ray-traced Approximate Reflections Using a Grid of Oriented Splats |
Screen-space Bent Cones: A Practical Approach |
 |  |
Oliver Klehm, Tobias Ritschel, Elmar Eisemann, Hans-Peter Seidel
GPU Pro 3, 2012. |
Real-time Near-Field Global Illumination based on a Voxel Model |
| |
Sinje Thiedemann, Niklas Henrich, Thorsten Grosch, Stefan Mueller
GPU Pro 3, 2012. |
Efficient Online Visibility for Shadow Maps |
| |
Oliver Mattausch, Jiri Bittner, Ari Silvnennoinen, Daniel Scherzer and Michael Wimmer
GPU Pro 3, 2012. |
Depth Rejected Gobo Shadows |
Quaternion-based Rendering Pipeline |
Implementing a Directionally Adaptive Edge AA Filter using DirectX 11 |
Designing a Data-Driven Renderer |
Volumetric transparency with Per-Pixel Fragment Lists |
Practical Binary Surface and Solid Voxelization with Direct3D 11 |
Interactive Ray Tracing Using the Compute Shader in DirectX 11 |
Terrain and Ocean Rendering with Hardware Tesselation |
Practical and Realistic Facial Wrinkles Animation |
 | |
Jorge Jimenez, Jose I. Echevarria, Christopher Oat and Diego Gutierrez
GPU Pro 2, 2011. |
Procedural Content Generation on GPU |
Pre-Integrated Skin Shading |
Implementing Fur in Deferred Shading |
Large-Scale Terrain Rendering for Outdoor Games |
Practical Morphological Anti-Aliasing |
| |
Jorge Jimenez, Belen Masia, Jose I. Echevarria, Fernando Navarro and Diego Gutierrez
GPU Pro 2, 2011. |
Temporal Screen-Space Ambient Occlusion |
Level-of-Detail and Streaming Optimized Irradiance Normal Mapping |
Real-Time One-bounce Indirect Illumination and Indirect Shadows using Ray-Tracing |
Real-Time Approximation of Light Transport in Translucent Homogenous Media |
Real-time diffuse Global Illumination with Temporally Coherent Light Propagation Volumes |
Variance Shadow Maps Light-Bleeding Reduction Tricks |
Fast Soft Shadows via Adaptive Shadow Maps |
Adaptive Volumetric Shadow Maps |
| |
Marco Salvi, Kiril Vidimce, Andrew Lauritzen, Aaron Lefohn, Matt Pharr
GPU Pro 2, 2011. |
Fast Soft Shadows with Temporal Coherence |
MipMapped Screen Space Soft Shadows |
A Shader-Based E-Book Renderer |
Post-Processing Effects on Mobile Devices |
Shader Based Water Effects |
Practical, Dynamic Visibility for Games |
Shader Amortization using Pixel Quad Message Passing |
A Rendering Pipeline for Real-time Crowds |
2D Distance Field Generation with the GPU |
Order-Independent Transparency Using Per-Pixel Linked Lists in DirectX 11 |
Simple and Fast Fluid Flow Simulation on the GPU |
A Fast Poisson Solver for OpenCL using Multigrid Methods |
Visualize Your Shadow Map Techniques |
As Simple as Possible Tessellation for Interactive Applications |
Rule-Based Geometry Synthesis in Real-Time |
GPU-Based NURBS Geometry Evaluation and Rendering |
Polygonal-Functional Hybrids for Computer Animation and Games |
 | |
D. Kravtsov, O. Fryazinov, V. Adzhiev, A. Pasko, and P. Comninos
GPU Pro, 2010. |
Quadtree Displacement Mapping with Height Blending |
NPR Effects Using the Geometry Shader |
Alpha Blending as a Post-Process |
| |
Matthaus G. Chajdas, Christian Eisenacher, Marc Stamminger, and Sylvain Lefebvre
GPU Pro, 2010. |
Fast, Stencil-Based Multiresolution Splatting for Indirect Illumination |
Screen-Space Directional Occlusion |
Real-Time Multi-Bounce Ray-Tracing with Geometry Impostors |
Anisotropic Kuwahara Filtering on the GPU |
Environment Mapping with Floyd-Steinberg Halftoning |
Hierarchical Item Buffers for Granular Occlusion Culling, |
Realistic Depth of Field in Postproduction |
Real-Time Screen Space Cloud Lighting |
Screen-Space Subsurface Scattering |
Migration to OpenGL ES 2.0 |
Touchscreen-Based User Interaction |
iPhone 3GS Graphics Development and Optimization Strategies |
Optimizing a 3D UI Engine for Mobile Devices |
Fast Conventional Shadow Filtering |
Hybrid Min/Max Plane-Based Shadow Maps |
Shadow Mapping for Omnidirectional Light Using Tetrahedron Mapping |
Screen Space Soft Shadows |
Multi-Fragment Effects on the GPU Using Bucket Sort |
Parallelized Light Pre-Pass Rendering with the Cell Broadband Engine |
Porting Code between Direct3D9 and OpenGL 2.0 |
Practical Thread Rendering for DirectX 9 |
Stylized Rendering in Spore |
Rendering Techniques in Call of Juarez: Bound in Blood |
Making it Large, Beautiful, Fast, and Consistent: Lessons Learned Developing Just Cause 2 |
Destructible Volumetric Terrain |
Parallelized Implementation of Universal Visual Computer |
Accelerating Virtual Texturing Using CUDA |
| |
Charles-Frederik Hollemeersch, Bart Pieters, Peter Lambert, and Rik Van de Walle
GPU Pro, 2010. |
Efficient Rendering of Highly Detailed Volumetric Scenes with GigaVoxels |
| |
Cyril Crassin, Fabrice Neyret, Miguel Sainz, and Elmar Eisemann
GPU Pro, 2010. |
Spatial Binning on the GPU |
Real-Time Interaction between Particles and the Dynamic Mesh on the GPU |
Scalar to Polygonal Extracting Isosurfaces Using Geometry Shaders |
Fast Tessellation of Quadrilateral Patches for Dynamic Level of Details |
Dynamic Terrain Rendering on GPU Using Real-Time Tessellation |
Adaptive Re-Meshing for Displacement Mapping |
 | |
Rafael P. Torchelsen, Carlos A. Dietrich, Lu�s Fernando, M. S. Silva, Rui Bastos, and Jo�o L. D. Comba
ShaderX7, 2009. |
Fast Tessellation of Quadrilateral Patches for Dynamic Level of Details |
Simplified High Quality Anti-aliased Lines |
An Efficient and Physically Plausible Real Time Shading Model |
Graphics Techniques in Crackdown |
Deferred Rendering Transparency |
Deferred Shading with Multisampling Anti-Aliasing in DirectX 10 |
Light Indexed Deferred Rendering |
Efficient Post-processing with Importance Sampling |
Efficient Real-Time Motion Blur for Multiple Rigid Objects |
Real-time Flow-based Image Abstraction |
Practical Cascaded Shadow Maps |
A Hybrid Method for Interactive Shadows in Homogeneous Media |
Real-time Dynamic Shadows for Image-based Lighting |
Facetted Shadow Mapping for Large Dynamic Game Environments |
Interactive Hydraulic Erosion on the GPU |
Advanced Geometry for Complex Sky Representation |
Screen Space Ambient Occlusion |
Image-Space Horizon-Based Ambient Occlusion |
Deferred Occlusion from Analytic Surfaces |
| |
Jeremy Shopf, Joshua Barczak, Thorsten Scheuermann, Christopher Oat
ShaderX7, 2009. |
Fast Fake Global Illumination |
Real-Time Subsurface Scattering using Shadow Maps |
Instant Radiosity with GPU Photon Tracing and Approximate Indirect Shadows |
Variance Methods for Screen-Space Ambient Occlusion |
Per-Pixel Ambient Occlusion using Geometry Shaders |
Optimizing your first OpenGL ES Applications |
Optimised Shaders for Advanced Graphical User Interfaces |
Facial Animation for Mobile GPUs |
Augmented Reality on Mobile Phones |
Cross Platform Rendering Thread: Design and Implementation |
Advanced GUI System for Games |
Automatic Load Balancing Shader Framework |
Game Engine Friendly Occlusion Culling |
Designing a Renderer for Multiple Lights - The Light Pre-Pass Renderer |
Using LUV color space with the Light Pre-Pass Renderer |
Sliced Grid: A Memory and Computationally Efficient Data Structure for Particle-based Simulation on the GPU |
Free-Viewpoint Video on the GPU |
A Volume Shader for Quantum Voronoi Diagrams inside the 3D Bloch Ball |
Packing Arbitrary Bit Fields into 16-bit Floating-point Render Targets in DirectX 10 |
Interactive Image Morphing Using Thin-Plate Spline |
| |
Xiaopei Liu, Liang Wan, Xuemiao Xu, Tien-Tsin Wong, Chi-Sing Leung
ShaderX7, 2009. |
Fast Evaluation of Subdivision Surfaces on Direct3D 10 Graphics Hardware |
Improved Appearance Variety for Geometry Instancing |
Implementing Real-Time Mesh Simplification Using Programmable Geometry Pipeline on GPU |
Care and Feeding of Normal Vectors |
Computing Per-Pixel Object Thickness in a Single Render Pass |
Parallax Occlusion Mapping Special Feature Rendering |
Uniform Cubemap for Dynamic Environments |
Isocube A Cubemap with Uniformly Distributed and Equally Important Texels |
Practical Geometry Clipmaps for Rendering Terrains in Computer Games |
Efficient and Practical TileTrees |
GPU-Based Active Contours for Real-Time Object Tracking |
Post-Tonemapping Resolve for High Quality HDR Antialiasing in D3D10 |
A Fast, Small-Radius GPU Median Filter |
Per-pixel Motion Blur for Wheels |
Deferred Rendering using a Stencil Routed K-Buffer |
HDR Meets Black & White 2 |
Robust Order-Independent Transparency via Reverse Depth Peeling in DirectX 10 |
Stable Rendering of Cascaded Shadow maps |
Approximate Cumulative Distribution Function Shadow Mapping |
Rendering Filtered Shadows with Exponential Shadow Maps |
Fitted Virtual Shadow Maps and Shadow Fog |
Removing Shadow Volume Artifacts by Spatial Adjustment |
Rendering Realistic Ice Objects |
Sunlight with Volumetric Light Rays |
Practical Methods for a PRT-based Shader Using Spherical Harmonics |
Incremental Instant Radiosity |
 | |
Hannu Saransaari, Samuli Laine, Janne Kontkanen, Jaakko Lehtinen and Timo Aila
ShaderX6, 2008. |
Real Time Photon Mapping Approximation on the GPU |
Interactive Global Illumination with Precomputed Radiance Maps |
Shaders Gone Mobile Porting from Direct3D 9.0 to Open GL ES 2.0 |
Efficiently Using Tile-Based GPUs on Mobile Phones |
Maximal Performance and Image Quality with Minimal Precision |
Implementing Graphical Benchmark in OpenGL ES 2.0 |
Every Cycle Counts Level of Detail Shaders |
Shadow Techniques for OpenGL ES 2.0 |
A Flexible Material System in Design |
3D Engine Tools with C++ CLI |
Efficient HDR Texture Compression |
An Interactive Tour of Voronoi Diagrams on the GPU |
AMD DirectX 10 Performance Tools and Techniques |
Real-Time Audio Processing on the GPU |
n-Body Simulations on the GPU |
Generating Complex Procedural Terrains Using the GPU |
DirectX 10 Blend Shapes: Breaking the Limits |
Next-Generation SpeedTree Rendering |
 | |
Alexander Kharlamov, Iain Cantlay, Yury Stepanenko (NVIDIA Corporation)
GPU Gems 3, 2007. |
Generic Adaptive Mesh Refinement |
GPU-Generated Procedural Wind Animations for Trees |
Point-Based Visualization of Metaballs on a GPU |
| |
Kees van Kooten, Gino van den Bergen (Playlogic Game Factory), Alex Telea (Eindhoven University of Technology)
GPU Gems 3, 2007. |
Summed-Area Variance Shadow Maps |
Interactive Cinematic Relighting with Global Illumination |
| |
Fabio Pellacini (Dartmouth College), Milos Hasan, Kavita Bala (Cornell University)
GPU Gems 3, 2007. |
Parallel-Split Shadow Maps on Programmable GPUs |
| |
Fan Zhang, Hanqiu Sun (The Chinese University of Hong Kong), Oskari Nyman (Helsinki University of Technology)
GPU Gems 3, 2007. |
Efficient and Robust Shadow Volumes Using Hierarchical Occlusion Culling and Geometry Shaders |
| |
Martin Stich (Mental Images), Carsten W�chter, Alexander Keller (Ulm University)
GPU Gems 3, 2007. |
High-Quality Ambient Occlusion |
| |
Jared Hoberock, Yuntao Jia (University of Illinois at Urbana-Champaign)
GPU Gems 3, 2007. |
Volumetric Light Scattering as a Post-Process |
Advanced Techniques for Realistic Real-Time Skin Rendering |
Playable Universal Capture |
| |
George Borshukov, Jefferson Montgomery, John Hable (Electronic Arts)
GPU Gems 3, 2007. |
Vegetation Procedural Animation and Shading in Crysis |
Robust Multiple Specular Reflections and Refractions |
| |
Tam�s Umenhoffer, BL�szl?Szirmay-Kalos (Budapest University of Technology and Economics), Gustavo Patow (University of Girona)
GPU Gems 3, 2007. |
Relaxed Cone Stepping for Relief Mapping |
| |
Fabio Policarpo (Perpetual Entertainment), Manuel M. Oliveira (Instituto de Inform�tica-UFRGS)
GPU Gems 3, 2007. |
Deferred Shading in Tabula Rasa |
GPU-Based Importance Sampling |
| |
Mark Colbert (University of Central Florida), Jaroslav Kr�iv�nek (Czech Technical University in Prague)
GPU Gems 3, 2007. |
Baking Normal Maps on the GPU |
High-Speed, Off-Screen Particles |
The Importance of Being Linear |
Rendering Vector Art on the GPU |
Object Detection by Color: Using the GPU for Real-Time Video Image Processing |
Motion Blur as a Post-Processing Effect |
Practical Post-Process Depth of Field |
Real-Time Rigid Body Simulation on GPUs |
Real-Time Simulation and Rendering of 3D Fluids |
| |
Keenan Crane (University of Illinois at Urbana-Champaign), Ignacio Llamas, Sarah Tariq (NVIDIA Corporation)
GPU Gems 3, 2007. |
Fast N-Body Simulation with CUDA |
| |
Lars Nyland, Mark Harris (NVIDIA Corporation), Jan Prins (University of North Carolina at Chapel Hill)
GPU Gems 3, 2007. |
Broad-Phase Collision Detection with CUDA |
LCP Algorithms for Collision Detection Using CUDA |
Signed Distance Fields Using Single-Pass GPU Scan Conversion of Tetrahedra |
| |
Kenny Erleben (University of Copenhagen), Henrik Dohlmann (3Dfacto R&D)
GPU Gems 3, 2007. |
Fast Virus Signature Matching on the GPU |
AES Encryption and Decryption on the GPU |
Efficient Random Number Generation and Application Using CUDA |
Imaging Earth's Subsurface Using CUDA |
Parallel Prefix Sum (Scan) with CUDA |
Incremental Computation of the Gaussian |
Using the Geometry Shader for Compact and Variable-Length GPU Feedback |
Dynamic Wrinkle Patterns and Hatching on Animated Meshes |
A Simple Area Light Model for GPUs |
Alpha-to-Coverage in Depth |
Practical Parallax Occlusion Mapping with Approximate Soft Shadows for Detailed Surface Rendering |
Preprocessing of Complex, Static Scenes for Fast Real-time Graphics |
Overcoming Deferred Shading Drawbacks |
Normal Mapping without Precomputed Tangents |
Animating Vegetation Using GPU Programs |
Real-time Depth-of-Field Implemented with a Postprocessing-Only Technique |
Jump Flooding: An Efficient and Effective Communication Pattern for Use on GPUs |
Multisampling Extension for Gradient Shadow Maps |
Alias-Free Hard Shadows with Geometry Maps |
Edge Masking and Per-Texel Depth Extent Propagation For Computation Culling During Shadow Mapping |
Queried Virtual Shadow Maps |
Real-time Soft Shadows with Shadow Accumulation |
Spherical Billboards for Rendering Volumetric Data |
Per-Pixel Lit, Light Scattering Smoke |
Volumetric Clouds and Mega-Particles |
Rendering Multiple Layers of Rain with a Postprocessing Composite Effect |
Animation and Rendering of Underwater God Rays |
Irradiance Volumes for Real-time Rendering |
Indirect Diffuse and Glossy Illumination on the GPU |
Interactive Refractions and Caustics Using Image-Space Techniques |
Splatting of Diffuse and Glossy Indirect Illumination |
OpenGL ES 2.0: Shaders for Mobile Devices |
Developing a 3D Engine for OpenGL ES v2.0 and OpenGL v2.0 |
OpenGL ES 2.0 Performance Recommendations for Mobile Devices |
Real-time Tile-Based Texture Synthesis Using Nonregular Grids |
Cartoon Fire Effects Using OpenGL ES 2.0 |
Postprocessing Effects in Design |
Transparent Shader Data Binding |
Designing Plug-in Shaders with HLSL |
Shader System Integration: Nebula2 and 3ds Max |
Large Crowds of Autonomous Animated Characters Using Fragment Shaders and Level of Detail |
Interactive Image Segmentation Based on GPU Cellular Automata |
Real-time Cellular Texturing |
Collision Detection Shader Using Cube-Maps |
A GPU Panorama Viewer for Generic Camera Models |
Explicit Early-Z Culling for Efficient Fluid Flow Simulation |
Storing and Accessing Topology on the GPU: A Case Study on Mass-Spring Systems |
Implementing High-Quality PRNG on GPUs |
Print Shader for Debugging Pixel Shaders |
Better Geometry Batching Using Light Buffers |
Practical Cloth Simulation on Modern GPUs |
Shader Implementation of Discrete Wavelet Transform |
Morph Target Animation Using DirectXMorph |
Real-Time Character Animation on the GPU |
Triangle Mesh Tangent Space Calculation |
Hardware-Based Ambient Occlusion |
Rendering Surface Details in Games with Relief Mapping Using a Minimally Invasive Approach |
Real-Time Obscurances with Color Bleeding |
 | |
Alex M�ndez-Feliu, Mateu Sbert, Jordi Cat? Nicolau Sunyer, and Sergi Funtan?br>ShaderX4, 2006. |
Dynamic Global Illumination Using Tetrahedron Environment Mapping |
Real-Time Rendering and Simulation of the Airbrush Medium for Metallic Appearance |
Dynamic Glossy Environment Reflections Using Summed-Area Tables |
Real-Time Caustics by GPU |
Dot-Product for Efficient Detail Texture Mapping |
Real-Time Environment Mapping with Equal Solid-Angle Spherical Quad-Map |
I3: Interactive Indirect Illumination |
Texture Compression with Coefficient Domain Shaders |
Motion Blurring Environment Maps |
Simulating the Visual Effects of a Video Recording System |
Eliminate Surface Acne with Gradient Shadow Mapping |
Real-Time Soft Shadows Using the PDSM Technique |
| |
Jean-Fran�ois St. Amour, Eric Paquette, Pierre Poulin, Philippe Beaudoin
ShaderX4, 2006. |
Robust Shadow Mapping with Light-Space Perspective Shadow Maps |
Making Shadow Buffers Robust Using Multiple Dynamic Frustums |
Tips and Tricks for D3DX Effects Based Renderer |
Post-Processing Effects Scripting |
Case Study: Designing a Shader Subsystem for a Next-Gen Graphics Engine |
Real-Time Damage Deformation Methods |
Ray Tracing Effects without Tracing Rays |
Implementing Ray Tracing on the GPU |
GPU-Powered Pathfinding Using Preprocessed Navigation Mesh Approach |
Cached Procedural Textures for Terrain Rendering |
True-to-Life Real-Time Animation of Shallow Water on Today�s GPUs |
Implementing Radiosity for a Light Map Precomputation Tool |
Dynamic Branching on Non-PS3.0 Hardware |
GLSL Shader Debugging with GLIntercept |
GPU Performance of DirectX 9 Per-Fragment Operations Revisited |
Preprocessed Pathfinding Using the GPU |
Abstract: This article proposes GPU-based implementations for two popular algorithms used to solve the all-pairs shortest paths problem: Dijkstra's algorithm, and the Floyd-Warshall algorithm. These algorithms are used to preprocess navigation mesh data for fast pathfinding. This approach can offload pathfinding-related CPU computations to the GPU at the expense of latency. However, once the solution table is generated, this approach minimizes the latency time for a specific path search, thus giving the game a better sense of interactivity. The biggest benefit of this approach is gained in systems with multiple agents simultaneously requesting paths in the same search space. Although the article describes a GPU-specific implementation for a navigation mesh, any other multi-processor environment or discrete search space representation can be used.
Fast and Accurate Gesture Recognition for Character Control |  |
Abstract: This article describes a simple, yet fast and accurate, way of gesture recognition that we have used in Punch'n'Crunch, a gesture-based fun-boxing game. The presented system is a very interesting way to control characters, but can also be used to recognize letters, numbers, and other arbitrary symbols. Gestures allow a more natural way for triggering a multitude of different commands.
GPU Computation in Projective Space Using Homogeneous Coordinates |
Synthesis of Realistic Idle Motion for Interactive Characters |
Spatial Partitioning Using an Adaptive Binary Tree |
Enhanced Object Culling with (Almost) Oriented Bounding Boxes |
Skin Splitting for Optimal Rendering |
Interactive Fluid Dynamics and Rendering on the GPU |
Fast Per-Pixel Lighting with Many Lights |
Rendering Road Signs Sharply |
Practical Sky Rendering for Games |
High Dynamic Range Rendering Using OpenGL Frame Buffer Objects |
Realistic Cloud Rendering on Modern GPUs |
Let It Snow, Let It Snow, Let It Snow (and Rain) |
Widgets: Rendering Fast and Persistent Foliage |
2.5 Dimensional Impostors for Realistic Trees and Forrests |
Gridless Controllable Fire |
Powerful Explosion Effects Using Billboard Particles |
A Simple Method for Rendering Gemstones |
Volumetric Post-Processing |
Procedural Level Generation |
Towards Photorealism in Virtual Botany |
Terrain Rendering using GPU-Based Geometry Clipmaps |
Inside Geometry Instancing |
Optimizing Resource Management with Multi-Streaming |
Hardware Occlusion Queries Made Useful |
Adaptive Tessellation of Subdivision Surfaces with Displacement Mapping |
Per-Pixel Displacement Mapping with Distance Functions |
Deferred Shading in STALKER |
Real-Time Computation of Dynamic Irradiance Environment Maps |
Approximate Bidirectional Texture Functions |
Tile-Based Texture Mapping |
Implementing the Mental Images Phenomena Renderer on the GPU |
Dynamic Ambient Occlusion and Indirect Lighting |
Blueprint Rendering and "Sketchy Drawings" |
Accurate Atmospheric Scattering |
Efficient Soft-Edged Shadows Using Pixel Shader Branching |
Using Vertex Texture Displacement for Realistic Water Rendering |
Generic Refraction Simulation |
Fast Third-Order Texture Filtering |
 | |
Christian Sigg (ETH Zurich) and Markus Hadwiger (VRVis Research Center)
GPU Gems 2, 2005. |
High Quality Antialiased Rasterization |
Hair Animation and Rendering in the Nalu Demo |
Using Lookup Tables to Accelerate Color Transformations |
GPU Image Processing in Apple's Motion |
Implementing Improved Perlin Noise |
Advanced High-Quality Filtering |
Streaming Architectures and Technology Trends |
The GeForce 6 Series GPU Architecture |
Mapping Computational Concepts to GPUs |
GPU Computation Strategies and Tips |
Implementing Efficient Parallel Data Structures on GPUs |
| |
Aaron Lefohn (University of California, Davis), Joe Kniss (University of Utah), John Owens (University of California, Davis)
GPU Gems 2, 2005. |
Stream Reduction Operations for GPGPU Applications |
Octree Textures on the GPU |
| |
Sylvain Lefebvre, Samuel Hornus, and Fabrice Neyret (GRAVIR/IMAG - INRIA)
GPU Gems 2, 2005. |
High-Quality Global Illumination Rendering Using Rasterization |
Global Illumination using Progressive Refinement Radiosity |
| |
Greg Coombe (University of North Carolina at Chapel Hill) and Mark Harris (NVIDIA Corporation)
GPU Gems 2, 2005. |
Computer Vision on the GPU |
Deferred Filtering: Rendering from Difficult Data Formats |
| |
Joe Kniss (University of Utah), Aaron Lefohn, and Nathaniel Fout (University of California, Davis)
GPU Gems 2, 2005. |
Conservative Rasterization |
| |
Jon Hasselgren, Tomas Akenine-M�ller, and Lennart Ohlsson (Lund University)
GPU Gems 2, 2005. |
GPU Computing for Protein Structure Prediction |
A GPU Framework for Solving Systems of Linear Equations |
Options Pricing on the GPU |
| |
Peter Kipfer and R�diger Westermann (Technische Universit�t M�nchen)
GPU Gems 2, 2005. |
Flow Simulation with Complex Boundaries |
| |
Wei Li (Siemens Corporate Research), Zhe Fan, Xiaoming Wei, and Arie Kaufman (Stony Brook University)
GPU Gems 2, 2005. |
Medical Image Reconstruction with the FFT |
| |
Thilaka Sumanaweera and Donald Liu (Siemens Medical Solutions USA, Inc.)
GPU Gems 2, 2005. |
Batching 4EVA (GDC2005 D3D Tutorial) |
Direct3D API Issues: Instancing and Floating-Point Specials (GDC2005 D3D Tutorial) |
Special Effects in Direct3D (GDC2005 D3D Tutorial) |
The OpenGL Framebuffer Object Extension |
Image Processing Tricks in OpenGL |
OpenGL 2.0 and New Extensions |
Programming for SLI in OpenGL |
GPGPU: General-Purpose Computation on GPUs |
Volume Rendering for Games |
Percentage-Closer Soft Shadows |
Introduction to Wireless Media Processors (WMPs) |
Coming to a Pixel Near You: Mobile 3D Graphics on the GoForce WMP |
The NVIDIA Performance Analysis Tools |
Pipeline Integration with FX Composer |
Creating Real Shaders with FX Composer |
GPU Gems 2 Showcase: Per-Pixel Displacement Mapping Pixel Displacement Mapping with Distance Functions with Distance Functions (GPU Gems 2) |
GPU Gems 2 Showcase: Terrain Rendering Using GPU-Based Geometry Clipmaps (GPU Gems 2) |
GPU Gems 2 Showcase: Dynamic Ambient Occlusion and Indirect Lighting (GPU Gems 2) |
OpenGL Performance Tuning: OpenGL Performance in a Shader-Centric World |
3.0 Shaders (GDC2005 D3D Tutorial) |
Optimizing DirectX Graphics (GDC2005 D3D Tutorial) |
Advanced in Real-Time Skin Rendering (GDC2005 D3D Tutorial) |
Making Pretty Pictures with D3D (GDC2005 D3D Tutorial) |
Far Cry and DirectX (GDC2005 D3D Tutorial) |
Bringing Hollywood to Real Time |
Cubemap Filtering with Filtering with CubeMapGen |
Dynamic Image-Space Per-Pixel Displacement Mapping with Silhouette Antialiasing via Parallax Occlusion Mapping |
Irradiance Volumes for Games |
Ruby: Dangerous Curves - Effects Breakdown: How'd they do that? |
Summed-Area Tables and Their Application to Dynamic Glossy Environment Reflections |
ASHLI - Multipass for Lower Precision Targets |
Real-Time Skin Rendering on Graphics Hardware |
Practical Real-Time Hair Rendering and Shading |
RenderMonkey: An Effective Environment for Shader Prototyping and Development |
The Making of Ruby: The DoubleCross |
Applications of Explicit Early-Z Culling |
UberFlow: A GPU-Based Particle Engine |
Abstract: We present a system for real-time animation and rendering of large particle sets using GPU computation and memory objects in OpenGL. Memory objects can be used both as containers for geometry data stored on the graphics card and as render targets, providing an effective means for the manipulation and rendering of particle data on the GPU. To fully take advantage of this mechanism, ef.cient GPU realizations of algorithms used to perform particle manipulation are essential. Our system implements a versatile particle engine, including inter-particle collisions and visibility sorting. By combining memory objects with .oating-point fragment programs, we have implemented a particle engine that entirely avoids the transfer of particle data at run-time. Our system can be seen as a forerunner of a new class of graphics algorithms, exploiting memory objects or similar concepts on upcoming graphics hardware to avoid bus bandwidth becoming the major performance bottleneck.
The OpenGL Shading Language |
OpenGL Performance Tuning |
Custom Component Development with the RenderMonkey SDK |
New RenderMonkey features for DirectX and OpenGL Shader Development |
Adding Spherical Harmonic Lighting to the Sushi Engine |
Procedural Shaders: A Feature Animation Perspective |
Direct3D Shader Models (GDC2004 D3D Tutorial) |
Direct3D Optimizations (GDC2004 D3D Tutorial) |
Deferred Shading (GDC2004 D3D Tutorial) |
Optimizations and Star Wars Galaxies (GDC2004 D3D Tutorial) |
Real Time Skin Rendering (GDC2004 D3D Tutorial) |
Half-Life 2 / Valve Source Shading (GDC2004 D3D Tutorial) |
Save the Nanosecond! PC Graphics Performance for the next 3 years |
Light Shafts: Rendering Shadows in Participating Media |
Hair Rendering and Shading |
Phat Lewt: Drawing a Diamond |
All About Antialiasing (GDC2004 D3D Tutorial) |
Optimization for DirectX9 Graphics (GDC2004 D3D Tutorial) |
GPU-Assisted Rendering Techniques (GDC2004 D3D Tutorial) |
The OpenGL Shading Language on NVIDIA Hardware (GDC2004 OpenGL Tutorial) |
OpenGL 2.0 Update (GDC2004 OpenGL Tutorial) |
New NVIDIA OpenGL Extensions (GDC2004 OpenGL Tutorial) |
Cinematic Effects II: The Revenge |
Next-Gen Special Effects Showcase: How to Render a Real Rainbow |
Next-Gen Special Effects Showcase: BloodShader - Real-Time Adaptive Animation |
GPU Water Simulation with PS 3.0 |
Practical Performance Analysis and Tuning |
GPU Gems Showcase: Image-Based Lighting (GPU Gems) |
GPU Gems Showcase: Perspective Shadow Mapping (GPU Gems) |
GPU Gems Showcase: Ambient Occlusion (GPU Gems) |
Real-Time Animated Translucency |
Poster Quality Screenshots |
GPU Shadow Volume Construction for Nonclosed Meshes |
Combined Depth and ID-Based Shadow Buffers |
Carving Static Shadows into Geometry |
Adjusting Real-Time Lighting for Shadow Volumes and Optimized Meshes |
Real-Time Halftoning: Fast and Simple Stylized Shading |
Techniques to Apply Team Colors to 3D Models |
Fast Sepia Tone Conversion |
Dynamic Gamma Using Sampled Scene Luminance |
Heat and Haze Post-Processing Effects |
Hardware Skinning with Quaternions |
Motion Capture Data Compression |
Fast Collision Detection for 3D Bones-Based Articulated Characters |
Terrain Occlusion Culling with Horizons |
Effective Water Simulation from Physical Models |
 | |
Juan Guardado (NVIDIA) and Daniel S�nchez-Crespo (Universitat Pompeu Fabra / Novarama Technology)
GPU Gems, 2004. |
Animation in the "Dawn" Demo |
Implementing Improved Perlin Noise |
Fire in the "Vulcan" Demo |
Rendering Countless Blades of Waving Grass |
Efficient Shadow Volume Rendering |
| |
Michael Bunnell (NVIDIA) and Fabio Pellacini (Pixar Animation Studios)
GPU Gems, 2004. |
Omnidirectional Shadow Mapping |
Generating Soft Shadows Using Occlusion Interval Maps |
| |
William Donnelly (University of Waterloo) and Joe Demers (NVIDIA)
GPU Gems, 2004. |
Perspective Shadow Maps: Care and Feeding |
Managing Visibility for Per-Pixel Lighting |
Real-Time Approximations to Subsurface Scattering |
Finite-Radius Sphere Environment Mapping |
Depth of Field: A Survey of Techniques |
Fast Filter Width Estimates with Texture Maps |
| |
Florian Kainz, Rod Bogart, and Drew Hess (Industrial Light & Magic)
GPU Gems, 2004. |
A Framework for Image Processing |
Graphics Pipeline Performance |
Efficient Occlusion Culling |
The Design of FX Composer |
An Introduction to Shader Interfaces |
Converting Production RenderMan Shaders to Real-Time |
Integrating Hardware Shading into Cinema 4D |
Leveraging High-Quality Software Rendering Effects in Real-Time Applications |
Integrating Shaders into Applications |
A Toolkit for Computation on GPUs |
Fast Fluid Dynamics Simulation on the GPU |
Volume Rendering Techniques |
| |
Milan Ikits (University of Utah), Joe Kniss (University of Utah), Aaron Lefohn (University of California, Davis), and Charles Hansen (University of Utah)
GPU Gems, 2004. |
Applying Real-Time Shading to 3D Ultrasound Visualization |
Accessing and Modifying Topology on the GPU |
Rendering of Complex Formulas |
Deforming of Mesh Objects Using HLSL |
Morphing Between Two Different Objects |
Silhouette Geometry Shaders |
GLSL Real-Time Shader Development |
Deferred Lighting on PS 3.0 with High Dynamic Range |
Reflections from Bumpy Surfaces |
Massively Parallel Particle Systems on the GPU |
Parallax Occlusion Mapping: Self-Shadowing, Perspective-Correct Bump Mapping Using Reverse Height Map Tracing |
Improved Batching via Texture Atlases |
A Simulation of Thermal Imaging |
Real-Time Texture-Space Skin Rendering |
Hardware-Accelerated Charcoal Rendering |
Detail Texture Motion Blur |
Animation and Display of Water |
Rendering Semitransparent Layered Media |
Hair Rendering and Shading |
Reduction of Lighting Calculations Using Spherical Harmonics |
Optimizing Dx9 Vertex Shaders for Software Vertex Processing |
Software Shaders and DirectX DLL Implementation |
Tactical Path-Finding Using Stochastic Maps on the GPU |
FX Composer 1.5-Standardization |
A Steerable Streak Filter |
Improved Depth-of-Field Rendering |
Lighting Precomputation Using the Relighting Map |
Shaderey-NPR Style Rendering |
Fractional-Disk Soft Shadows |
Fake Soft Shadows Using Precomputed Visibility Distance Functions |
Efficient Omnidirectional Shadow Maps |
An Extensible Direct3D Resource Management System |
Integrating Shaders into the Vision Rendering Engine |
Effect Parameters Manipulation Framework |
Shader Visualization Systems for the Art Pipeline |
In-Depth Performance Analyses of DirectX9 Shading Hardware Concerning Pixel Shader and Texture Performance |
Generating Shaders from HLSL Fragments |
A Practical Analytic Model for Daylight with Shaders |
Simulating and Rendering Particle Systems |
Real-Time Animation of Trees |
Real-Time Multiresolution Dynamics of Deeply Hierarchical Bodies |
Scripted Bodies and Spline-Driven Animation |
Collision Detection of Deformable Volumetric Meshes |
Building an Advanced Facial Expression System |
Inverse Dynamic Displacement Constraints in Real-Time Cloth and Soft-Body Models |
Resolution of the Inverse Kinematic of an Articulated Structure Using the Jacobian Pseudo-Inverse |
Automatic Parameterizations on the Cube |
Filling Texture Holes Using the Euclidean Distance Map |
A Fast All-Interger Ellipse Discretization Algorithm |
 | |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of G�vle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
A Fast and Simple All-Interger Parametric Line |
| |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of G�vle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
An Easy-to-Code Smoothing Algorithm for 3D Reconstructed Surfaces |
Higher-Order Surfaces Using Curved Point-Normal (PN) Triangles |
Building a Flexible Terrain Engine for the Future |
Visible Terrain Grid Determination Using the Frustum |
Real-Time Generation and Rendering of 3D Planets |
k-D Tree Face Portals with Solid Geometry |
A Framework for Rapid 3D Level Design Using MAXScript Code Generation |
A Modified Phong-Blinn Light Model for Shadowed Areas |
| |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of G�vle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
Stochastic Iteration for Nondiffuse Global Illumination |
Metropolis Sampling in Random Walk Global Illumination Algorithms |
Metropolis Density Estimation |
Rendering with Adaptive Integration |
Illumination-Based Occlusion Culling |
Antialiasing for Bump Maps and a Fast Normalization Trick |
| |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of G�vle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
Fast Setup for Bilinear and Biquadratic Interpolation over Triangles |
| |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of G�vle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
An Effective Implementation of the k-D Trees |
Pixel Shader Optimizations for Terrain Rendering |
Real-Time Light-Atmosphere Interactions for Outdoor Scenes |
Quantization of True-Color Images with Opacity Information |
Real-Time Relighting of Compressed Panoramas |
An Optimal Dynamic Surface Caching Algorithm |
Introduction to the DirectX 9 High Level Shading Language |
Introduction to the vs_3_0 and ps_3_0 Shader Models |
Advanced lighting and shading with Direct3D 9 |
Introduction to Different Fog Effects |
Shadow Mapping with Direct3D 9 |
The Theory of Stencil Shadow Volumes |
Shader Development using RenderMonkey |
Tips for Creating Shader-Friendly 3D Models |
Vertex Decompression using Vertex Shaders Part 2 |
Using lookup tables in vertex shaders |
Terrain Geomorphing in the Vertex Shader |
Cloth Animation with Pixel and Vertex Shader 3.0 |
Rendering Objects as Thick Volumes |
Screen-aligned Particles with Minimal Vertex Buffer Locking |
Hemisphere Lighting With Radiosity Maps |
Fragment Level Phong Illumination |
Specular Bump mapping on pre-ps_1_4 Hardware |
Rendering Voxel Objects with ps_3_0 |
Simulating Blending Operations on Floating Point Render Targets |
Rendering Volumes in a Vertex & Pixel Program by Ray Tracing |
Drops of Water - and Texture Sprites |
Efficient Evaluation of Irradiance Environment Maps |
Practical Precomputed Radiance Transfer |
Advanced Sky Dome Rendering |
Deferred Shading with Multiple Render Targets |
Meshuggah's Effects explained |
Motion Blur Using Geometry and Shading Distortion |
 | |
Natalya Tatarchuk, Chris Brennan, John Isidoro, Alex Vlachos
ShaderX2, 2003. |
Simulation of Iridescence and Translucency on Thin Surfaces |
Stereoscopic Rendering in Hardware using Shaders |
Hatching, Stroke Styles & Pointillism |
Linear Algebra on the GPU |
Software Vertex Shader Processing |
x86 Shaders - ps_2_0 Shaders in Software |
SoftD3D - A software only implementation of Microsoft's Direct3D API |
Named Constants in Shader Development |
Advanced Image Processing with DirectX 9 Pixel Shaders |
Night Vision - Frame Buffer Post-Processing with ps_1_1 Hardware |
Non-Photorealistic Postprocessing Filters in MotoGP 2 |
Image Effects with DirectX 9 Pixel Shaders |
Using Pixel Shaders to Implement a Mosaic Effect using Character Glyphs |
Real-Time Depth of Field Simulation |
Reverse Extruded Shadow Volumes |
Post-Process Fun with Effects Buffers |
Shaders under Control (Codecreatures Engine) |
Shader Integration in the Gamebryo Graphics Engine |
Implementing A Fixed Function Shader in HLSL |
Performance Optimization Techniques for ATI Graphics Hardware with DirectX?.0 |
Rendering Outdoor Light Scattering in Real Time |
T-Junction Elimination and Retriangulation |
Abstract: This article describes how to detect possible sources of these seams in complex 3D scenes and how to modify static geometry so that visible artifacts are avoided. Since T-junction elimination adds verticies to existing polygons (that are not necessarily convex), we also discuss a method for triangulating arbitrary concave polygons.
Fast Heightfield Normal Calculation |
Abstract: Heightfields are two-dimensional arrays of height values, commonly used to store terrain or water surface data, and are also commonly used for calculating bump maps. This article will describe how we can take advantage of the special characteristics of heightfield meshes to significantly optimize vertex normal calculation.
Abstract: Surface patches are a memory-efficient way of creating smooth surfaces that can be rendered at many levels of detail. However, having a smooth surface is not as useful if you cannot light it properly. For that, you need the normal vector at each vertex. This article describes how to treat the normal at each control point as a second control mesh, thus quickly approximating the correct surface normal. Although the results are not strictly correct, they can produce superior results by eliminating shading errors due to curve discontinuity introduced during skinning.
Fast and Simple Occlusion Culling |
Abstract: This article describes two occlusion culling algorithms that are practical, effective, and require little preprocessing. The first one is the prioritized-layered projection (PLP) algorithm, which is an approximate algorithm that determines, for a given budget, a set of primitives that is likely to be visible. The second algorithm, cPLP, is a conservative version of PLP that guarantees finding all visible primitives.
Triangle Strip Creation, Optimizations, and Rendering |
Abstract: This article focuses on how to generate triangle strips from arbitrary 3D polygonal models. We will describe and provide source code for developing long triangle strips. After describing the triangle strip algorithm, we will explain the benefits of triangle strips, the possible pitfalls encountered when creating them, and how to submit them to the graphics API. In addition, several other triangle strip creation algorithms will be reviewed and critiqued.
Computing Optimized Shadow Volumes for Complex Data Sets |
Abstract: In this article, we describe a method for computing the exact front cap geometry visible from a given static light source. This is the exact geometry that is visible from the light's point of view, and it is useful for calculating shadow volumes. Previous work has been done on this topic; however, most methods suffer from either infinte recursion (with complex polygonal models) or fail to solve for cyclically overlapping polygons. The method presented here also works for scenes that have intersecting polygons.
Subdivision Surfaces for Character Animation |
Abstract: This article introduces subdivision surfaces as a means of improving the appearance of game characters. First, we will present the different schemes available, focusing on two implementations of subdivision surfaces. Then, we will explore a number of optimization methods based on culling and preprocessing.
Improved Deformation of Bones |
Abstract: This article describes how to avoid joint pinching from typical skinning methods by introducing additional bones at troublesome joints, such as the elbow and knees. By carefully reworking the weighting data to account for these 'links,' we can use the same simple core deformation algorithm and only incur the small additional burden of a few extra bones.
A Framework for Realistic Character Locomotion |
Abstract: This article presents a solution to the foot sliding problem based on adjusting the position of the feet only when they are already in motion. A framework is described for applying this idea to the problem of realistic character animation by using independent modifiers for different parts of a skeleton.
A Programmable Vertex Shader Compiler |
Abstract: This article discusses the implementation of a compiler for programmable vertex shaders. Provided with the article is a full implementation of a simple vertex shader compiler. It also contains documentation on how to create a workspace for building compilers and an example that compiles the OpenGL lighting equation into a DirectX vertex shader. To give a practical foundation for this article, we are focusing on the vertex shader implementation in DirectX8. Future implementations might vary, but the framework and infrastructure we provide should still be applicable.
Abstract: This article shows how to create the illusion of a 3D beam by using two triangles for the endpoints and two triangles for the beam. The details of positioning and texture mapping of the triangles are analyzed in the article.
3D Tricks for Isometric Engines |
Abstract: Isometric engines are one of the last bastions of two-dimensional graphics left in the game industry. While this article proposes some 3D methods to enhance what is essentially a sprite-based display system, it tries to preserve the essence of sprite-based graphics. While you could simply represent a majority of the game objects with 3D models to get the same visual effect, the ideas presented here maintain the use of sprites by adding a few tricks to make them appear as flexible as 3D models. The concepts may also be useful in other 3D engines as a replacement for flat billboard sprites or as a means to represent distant objects at a lower level of detail.
Curvature Simulation Using Normal Maps |
Abstract: This article explains how to perturb the normals on a surface to simulate the curvature of a denser model by using bump mapping. We will enhance the visual quality without losing speed or having to abandon more traditional ways of adding detail.
Methods for Dynamic, Photorealistic Terrain Lighting |
Abstract: This article will present several methods for producing high-quality, physically based lighting solutions for terrain under dynamic lighting conditions. Topics include: Sunlight (Horizon Angles, Shadow Ellipses, and PTMs), Skylight (Radiosity Approximations and Patches), Animated Cloud Shadows, Video-Based Solutions, and Nonterrain Objects.
Cube Map Lighting Techniques |
Abstract: This article will describe some ways to encode different lighting conditions as well as other properties within cube maps. It will give a brief overview of the properties of cube maps and how to index into them. Topics include: Physical Properties of Cube Maps, Getting data to/from a Cube Map, Rendering with the Cube Map, Encoding Cloud Cover, Encoding Lights in a Cube Map, Encoding Diffuse Lighting in a Cube Map, and Encoding a Day/Night Cycle into a Cube Map.
Abstract: The goal of this article is to introduce basic concepts for using procedures to manipulate and synthesize images for games and to give simple guidelines for implementation.
Abstract: This article explores how to use a relatively small number of artist-generated source textures and combine them at runtime using a variety of blends, fractal methods, and random numbers to create the textures required for the scene.
Textures as Lookup Tables for Per-Pixel Lighting Computations |
Abstract: In this article, we show ways to use texture maps as a means to solve functions through a lookup table, focusing on lighting computations. This technique saves precious pixel shader instructions, and in many cases, it is the only way to make certain per-pixel effects possible on the current generation of hardware.
Rendering with Handcrafted Shading Models |
Abstract: This article proposes a simple technique called normal distribution function (NDF) shading. It allows an artist to handcraft shading models, with the shape and color of highlights simply stored in bitmaps. The technique uses per-pixel shading, and can also be used in conjunction with bump mapping. Anisotropic shading models can also be created.
Introduction to Vertex and Pixel Shader Programming |
Basic Shader Development with Shader Studio |
Vertex Decompression using Vertex Shaders |
Shadow Volume Extrusion using a Vertex Shader |
Character Animation with Direct3D Vertex Shaders |
Lighting A Single-Surface Object |
Optimizing Software Vertex Shaders |
Compendium of Vertex Shader Tricks |
Perlin Noise and Returning Results from Shader Programs |
Blending Textures For Terrain |
Image Processing with Pixel Shaders in Direct3D |
Hello World - Font Smoothing with Pixel Shaders |
Disc or Sphere - Emulate Geometry with Shaders - Impostors |
Smooth Lighting with ps.1.4 |
Accurate Environment Mapped Reflections and Refractions by Adjusting for Object Distance |
UV Flipping Technique to Avoid Repetition |
Photo Realistic Faces with Vertex and Pixel Shaders |
Non-Photorealistic Rendering with Pixel and Vertex Shaders |
Animated Grass with Pixel and Vertex Shaders |
Texture Perturbation Effects |
Rippling Refractive and Reflective Water |
Per-pixel Strand Based Anisotropic Lighting |
A Non-Integer Power Function on the Pixel Shader |
Bump Mapped BRDF Rendering |
Real-Time Simulation and Rendering of Particle Flows |
3D Textures and Pixel Shaders |
First Thoughts on Designing a Shader-Driven Game Engine |
Visualization with the Krass?Game-Engine |
Designing a Vertex Shader-Driven 3D Engine for the Quake III level and Shader Format |
Comparison of VIPM Methods |
Abstract: View-Independent Progressive Meshing (VIPM) has moved from the status of an interesting research project, to promising new technology, to sensible addition to all the best engines, and now into the Direct3D graphics API itself. However, in an effort to push the performance of VIPM, and in particular to drive the hardware as efficiently as possible, several new forms have been developed, each with their own tradeoffs and characteristics. This article is intended as a guide to some of the more promising versions, and should help people decide which of the many variants to sue in particular situations.
Simplified Terrain Using Interlocking Tiles |
Abstract: This article proposes a simple method for interlocking tiles that requires a minimal amount of coding. The technique offers the benefits of dynamically adapting detail levels and animation flexibility. It does this while maintaining a data system that is perfectly suited for hardware transform and lighting.
Sphere Trees for Fast Visibility Culling, Ray Tracing, and Range Searching |
Abstract: The article presents an algorithm and demonstration application that manages thousands of objects in motion that are continuously maintained as a collection of hierarchical bounding spheres in a SphereTree. The design goal for this algorithm has been to make the 99-percentile case spend almost no CPU time updating an object in motion within the tree structure. Queries against the SphereTree perform more tests than other data structures, but this is mitigated by the fact that the tree can be maintained using very little CPU time. This data structure is ideally suited for gross culling of massive numbers of moving objects in a large world space. It doesn't matter if the objects are moving at widely disparate speeds, or even if many of them are not in motion at all. It also has a very low cost when objects are inserted and removed from the tree with great frequency.
Compressed Axis-Aligned Bounding Box Trees |
Abstract: The axis-aligned bounding box (AABB) tree structure has proven to be very useful for accelerating intersection queries on sets of geometry. The data structure is easy to implement, the built structure is numerically well conditioned, and like all binary trees, they have O(log n) search time. This article explains several techniques that can be used to lower the overall memory footprint of an AABB tree to 11 bytes per triangle.
Direct Access Quadtree Lookup |
Abstract: This article presents a general-purpose optimization for quadtree access that improves performance in three ways over the traditional implementations: 1) by eliminating node traversal and the unnecessary cache-misses it causes, 2) by requiring fewer instructions and CPU cycles overall vs. a best case traditional approach, and 3) by doing so in a compact amount of time and with minimal memory accesses regardless of what depth in the tree the target node resides in.
Approximating Fish Tank Refractions |
Abstract: This article briefly explains a method for approximating the refraction effect seen when looking through the side of a fish tank. The majority of this article explains how to construct the transformation matrix that will be applied to the geometry inside the tank to simulate the refraction effect.
Rendering Print Resolution Screenshots |
Abstract: This article proposes a solution of breaking the task into rendering several smaller subimages. These subimages can then be pasted together to form a screen shot of arbitrary resolution. This article focuses on the projection matrix tricks required to do this seamlessly.
Applying Decals to Arbitrary Surfaces |
Abstract: This article presents a general method for applying a decal to an arbitrarily shaped surface and concurrently clipping the decal to the surface's boundary.
Rendering Distant Scenery with Skyboxes |
Abstract: Rending distant scenery in 3D can be accomplished with skyboxes. This article explains the principle of skyboxing and describes alternative means for rendering a skyboxed scene.
Self-Shadowing Characters |
Abstract: This article presents a projective texture approach, which enables self-shadowing of convex subsections of characters in real time. After breaking the character into convex subsections, the subsections are rendered into a texture with varying alpha values from teh point of view of the light source. When the character is rendered from the viewer's point-of-view, this texture is projected back onto the convex subsegments of the character, simulating the occlusion of each subsegment with respect to the light source. Being map based rather than stencil-volume based, this technique requires no additional work to be compatible with higher-order surface tessellation techniques.
Classic Super Mario 64 Third-Person Control and Animation |
Abstract: This article will deal with the basic issues of controlling and animating a character from a third-person perspective. While it seems straightforward enough (just copy Super Mario 64), it's not as trivial as it first appears. There are many small nuggets of wisdom that can often take weeks of trial and error to discover.
Cartoon Rendering: Real-time Silhouette Edge Detection and Rendering |
Abstract: Silhouette detection and rendering is a key component for adding a stylized look to 3D cartoon rendering. The basic concept of silhouette edge detection is to find the important edges that depict the outline of a model. Many cartoon animators illustrate these silhouettes by tracing a black outline around the borders of a model. This cartoon rendering article describes several silhouette edge detection techniques: an edge-based detection method, a programmable vertex shader technique, and an advanced texturing technique. The advantages and disadvantages of each technique are highlighted.
Cartoon Rendering Using Texture Mapping and Programmable Vertex Shaders |
Abstract: The techniques described in this article take advantage of modern real-time graphics capabilities, including texture mapping and programmable vertex shading. The basic idea is to simulate a limited color palette using textures. To do this, we modify the standard diffuse shading equation to create a highlight and shadow color, and use these colors to create a small texture map for each material to be used as a lookup table at runtime. Additionaly, these techniques require no additional markup information from the artist - this article describes the creation of the texture maps and texture coordinates for each material.
Dynamic Per-Pixel Lighting Techniques |
Abstract: This article presents several techniques that can be used to perform dynamic lighting effects on a per-pixel basis. These methods have the advantage that they don't require highly tessellated geometry, and can often be performed at little performance cost on multitexturing graphics hardware.
Generating Procedural Clouds Using 3D Hardware |
Abstract: In this article, we'll set out to procedurally generate cloud textures that possess some of the properties that real clouds exhibit. In additon, because textures typically reside in graphics subsystem memory, we'll aim to generate the procedural clouds almost entirely using the graphics hardware. Finally, we'll address some ways to scale the technique's quality and performance requirements in order to accommodate a range of target machines.
Texture Masking for Faster Lens Flare |
Abstract: This article introduces a novel way in which to generate texture information from pixels already rendered to the frame buffer. The technique can be used in several different ways, but is presented here as a solution to the common problem of occluded lens flare. Many games attempt to read back pixels generated in the frame buffer in order to determine exactly what was visible in the final scene. We will present a technique that works without CPU assistance, and does not require reading data from the graphics card. We will also outline the reasons why reading back information from the graphics card can be a costly operation and should be avoided if possible.
Practical Priority Buffer Shadows |
Abstract: This article presents a set of techniques to improve the utility of "priority buffers". Along the way, we will explore other shadow techniques, and close by discussing how to create useful hybrid techniques.
Impostors: Adding Clutter |
Abstract: Impostering is about using sprites in a 3D scene, but instead of an artist drawing or rendering the sprites beforehand, they are updated on the fly. Instead of rendering a high-triangle object every frame, the high-triangle object is occasionally rendered to a texture-usually on the order of once every 5 to 50 frames. This article presents Impostors and describes how to render them, create update heuristics, and use prediction to determine how to orient the impostor each time it is rendered.
Operations for Hardware-Accelerated Procedural Texture Animation |
Abstract: This article covers a few fundamental operations for generating procedural animations, and puts these to use in specific examples that simulate fire, smoke, water, or perform image processing. With today's consumer hardware, we can even run complex cellular automata programs entirely within the rendering of a 3D accelerator and put the resulting animations to use in various effects.
Optimizing Vertex Submission for OpenGL |
Abstract: There are a number of functions available for submitting and rendering vertices in OpenGL, which range from the simple immediate mode functions to more complicated multiple vertex functions and vendor-specific extensions. However, teh performance can vary greatly depending on the functionality used. This article provides insight into the tradeoffs of various techniques.
Tweaking a Vertex's Projected Depth Value |
Abstract: The goal is to find a way to offset a polygon's depth in a scene without changing its projected screen coordinates or altering its texture mapping perspective. Most 3D graphcs libraries contain some kind of polygon offset function to help achieve this goal. However, these solutions generally lack fine control and usually incur a per-vertex performance cost. This article presents an alternative method that modifies the projection matrix to achieve the depth offset effect.
Abstract: The vector camera is a generalized form of the matrix-based camera found in many traditional graphics engines. Matrices are often difficult to read due to the fact that they typically hold several operations concatenated together. The vector camera uses only simple vectors to describe its orientation to the overall graphics pipeline. This article describes the how to construct a vector camera and how to manipulate it.
Camera Control Techniques |
Abstract: This article outlines a few basic techniques that can be used to develop the proper camera model for your game. In addition to basics, a scripted camera traveling on various curves (B-Spline, Catmull-Rom spline) is also discussed along with issues such as zooming, dampening, and the use of quaternions.
A Fast Cylinder-Frustrum Intersection Test |
Abstract: This article presents a quick algorithm for determining whether an arbitrary cylinder potentially intersects the view frustum (and thus whether the object is visible).
Abstract: This article will help lay the groundwork for building an accurate physics simulation by starting with one of the most crucial parts of a real-time physics engine: 3D collision detection. The two basic algorithms this article covers are: Bounding Sphere Collision Detection and Triangle-to-Triangle Collision Detection.
Multi-Resolution Maps for Interaction Detection (Collision Detection) |
Abstract: This article describes a method for reducing the number of proximity tests that must be performed for games with large numbers of game objects of varying sizes.
Computing the Distance into a Sector |
Abstract: This article describes a simple and fast algorithm for determining where a point is between the edges of a 2D quad (or sector). The result is a unit floating point number, where 0 indicates that the point lies on the leading edge, and where 1 indicates that the point lies on the opposite edge. The sector may be any four-sided, 2D convex shape.
Abstract: This article introduces both frustum culling and occlusion culling, along with example code for a simple occlusion culling algorithm.
Never Let 'Em See You Pop - Issues in Geometric Level of Detail Selection |
View-Independent Progressive Meshing |
Interpolated 3D Keyframe Animation |
A Fast and Simple Skinning Technique |
Filling in the Gaps-Advanced Animation Using Stitching and Skinning |
Real-Time Realistic Terrain Generation |
Fractal Terrain Generation - Fault Formation |
Fractal Terrain Generation - Midpoint Displacement |
Fractal Terrain Generation - Particle Deposition |
Abstract: This article shows how to implement an attractive lens flare effect using only a small amount of code and artwork, without needing to know anything about physical optics.
Using 3D Hardware for 2D Sprite Effects |
Abstract: This article sheds some light on how to use 3D hardware to achieve 2D effects. Specifically, we take a look at how to do alpha blending, sprite scaling, and sprite rotation.
Motif-Based Static Lighting |
Simulated Real-Time Lighting Using Vertex Color Interpolation |
Advanced Texturing Using Texture Coordinate Generation |
Real-Time Shadows on Complex Objects |
Improving Environment-Mapped Reflection Using Glossy Prefiltering and the Fresnel Term |
Convincing-Looking Glass for Games |
Refraction Mapping for Liquids in Containers |
|
