|
Graphics: All Articles
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é
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®9.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 scr
|
