book

GPU Gems: Programming Techniques, Tips and Tricks for Real-Time Graphics

Name: GPU Gems: Programming Techniques, Tips and Tricks for Real-Time Graphics
Author: Randima Fernando
ISBN: 9780321545404

by Randima Fernando

March 2004

Intermediate to advanced

816 pages

16h 56m

English

Addison-Wesley Professional

Read now

Unlock full access

Copyright
Dedication
Foreword
Preface
Our Intended AudienceTrying the ExamplesAcknowledgments
Contributors
I. Natural Effects
1. Effective Water Simulation from Physical Models
1.1. Goals and Scope1.2. The Sum of Sines Approximation1.2.1. Selecting the Waves1.2.2. Normals and Tangents1.2.3. Geometric WavesDirectional or CircularGerstner WavesWavelength and SpeedAmplitudeDirection1.2.4. Texture WavesWavelength and SpeedAmplitude and PrecisionDirection and Tiling1.3. Authoring1.3.1. Using Depth1.3.2. Overrides1.3.3. Edge-Length Filtering1.3.4. Texture Coordinates1.4. Runtime Processing1.4.1. Bump-Environment Mapping ParametersTangent-Space Basis VectorsEye Vector1.4.2. Vertex and Pixel Processing1.5. Conclusion1.6. References
2. Rendering Water Caustics
2.1. Introduction2.2. Computing Caustics2.3. Our Approach2.4. Implementation Using OpenGL2.5. Implementation Using a High-Level Shading Language2.6. Conclusion2.7. References
3. Skin in the “Dawn” Demo
3.1. Introduction3.2. Skin Shading3.3. Lighting the Scene3.3.1. A High-Dynamic-Range Environment3.3.2. The Occlusion Term3.4. How Skin Responds to Light3.5. Implementation3.5.1. The Vertex Shader3.5.2. The Fragment Shader3.6. Conclusion3.7. References

4. Animation in the “Dawn” Demo
4.1. Introduction4.2. Mesh Animation4.3. Morph Targets4.3.1. Morph Targets in a High-Level Language4.3.2. Morph Target Implementation4.4. Skinning4.4.1. Accumulated Matrix Skinning4.5. Conclusion4.6. References
5. Implementing Improved Perlin Noise
5.1. The Noise Function5.2. The Original Implementation5.3. Deficiencies of the Original Implementation5.4. Improvements to Noise5.5. How to Make Good Fake Noise in Pixel Shaders5.6. Making Bumps Without Looking at Neighboring Vertices5.7. Conclusion5.8. References
6. Fire in the “Vulcan” Demo
6.1. Creating Realistic Flames6.2. Implementing Animated Sprites6.2.1. Animating Flames and SmokeCustom Smoke Generator6.2.2. Adding Variety to the Flames6.2.3. Storing the Animation6.2.4. Blending Flames and Smoke6.3. Particle Motion6.4. Performance6.4.1. Layer Composition6.4.2. Custom Sprites6.5. Post-Rendering Effects6.5.1. Glow6.5.2. Heat Shimmer6.5.3. Grain6.5.4. The Final Program6.6. Conclusion
7. Rendering Countless Blades of Waving Grass
7.1. Introduction7.2. Overview7.3. Preparation of the Grass Objects7.3.1. Grass Texture7.3.2. Grass Objects7.4. Animation7.4.1. The General Idea7.4.2. Animation per Cluster of Grass ObjectsProsConsAlgorithm7.4.3. Animation per VertexProsConsAlgorithm7.4.4. Animation per Grass ObjectProsConsAlgorithm7.5. Conclusion7.6. Further Reading
8. Simulating Diffraction
8.1. What Is Diffraction?8.1.1. The Wave Theory of Light8.1.2. The Physics of Diffraction8.2. Implementation8.3. Results8.4. Conclusion8.5. References
II. Lighting and Shadows
9. Efficient Shadow Volume Rendering
9.1. Introduction9.1.1. Where to Use Shadow Volumes9.2. Program Structure9.2.1. Multipass Rendering9.2.2. Vertex Buffer Structure9.2.3. Working at Infinity9.3. Detailed Discussion9.3.1. The Math9.3.2. The Code9.3.3. The markShadows Method9.3.4. The findBackfaces Method9.3.5. Light and Dark Caps9.3.6. Sides9.4. Debugging9.5. Geometry Optimizations9.5.1. Directional Lights9.5.2. Point Lights and Spotlights9.5.3. Culling Shadow Volumes9.5.4. Uncapped Performance9.6. Fill-Rate Optimizations9.6.1. Finite Volumes9.6.2. XY Clipping9.6.3. Z-Bounds9.7. Future Shadows9.8. References
10. Cinematic Lighting
10.1. Introduction10.2. A Direct Lighting Illumination Model10.2.1. Selection10.2.2. Color10.2.3. Shaping10.2.4. ShadowingDarknessHueReflectionShadow MapsShadow Blurring10.2.5. Texturing10.2.6. Results10.3. The Uberlight Shader10.4. Performance Concerns10.4.1. Speed10.4.2. Expense10.4.3. Optimization10.5. Conclusion10.6. References
11. Shadow Map Antialiasing
11.1. Introduction11.2. Percentage-Closer Filtering11.3. A Brute-Force Implementation11.4. Using Fewer Samples11.5. Why It Works11.6. Conclusion11.7. References
12. Omnidirectional Shadow Mapping
12.1. Introduction12.1.1. Stencil Shadows12.1.2. Shadow Mapping12.2. The Shadow-Mapping Algorithm12.2.1. Conditions12.2.2. The Algorithm12.2.3. Texture Format12.2.4. The Size of the Shadow Map12.2.5. The Range of Values for Geometry12.3. Implementation12.3.1. System Requirements12.3.2. Resource Creation12.3.3. Rendering Phase 1: Rendering into the Shadow MapThe Vertex ShaderThe Pixel Shader12.3.4. Rendering Phase 2: Base Rendering12.3.5. The Lighting Calculation12.3.6. The Shadow Calculation12.3.7. Tips and Tricks12.3.8. Finalizing the Shading Pass (Lighting × Shadow)12.4. Adding Soft Shadows12.5. Conclusion12.6. References
13. Generating Soft Shadows Using Occlusion Interval Maps
13.1. The Gas Station13.2. The Algorithm13.3. Creating the Maps13.4. Rendering13.5. Limitations13.6. Conclusion13.7. References
14. Perspective Shadow Maps: Care and Feeding
14.1. Introduction14.2. Problems with the PSM Algorithm14.2.1. Virtual CamerasVirtual Camera IssuesA Solution for Virtual Camera Issues14.2.2. The Light CameraUnit Cube ClippingUsing Cube Maps14.2.3. Biasing14.3. Tricks for Better Shadow Maps14.3.1. Filtering14.3.2. Blurring14.4. Results14.5. References
15. Managing Visibility for Per-Pixel Lighting
15.1. Visibility in a GPU Book?15.2. Batches and Per-Pixel Lighting15.2.1. A Per-Pixel Example15.2.2. Just How Many Batches, Anyway?15.3. Visibility As Sets15.3.1. The Visible Set15.3.2. The Lights Set15.3.3. The Illumination Set15.3.4. The Shadow Set15.4. Generating Sets15.4.1. The Visible Set15.4.2. The Lights Set15.4.3. The Illumination Set15.4.4. The Shadow SetShadows for Lights Inside a FrustumShadows for Lights Outside a Frustum15.5. Visibility for Fill Rate15.6. Practical Application15.7. Conclusion15.8. References
III. Materials
16. Real-Time Approximations to Subsurface Scattering
16.1. The Visual Effects of Subsurface Scattering16.2. Simple Scattering Approximations16.3. Simulating Absorption Using Depth Maps16.3.1. Implementation Details16.3.2. More Sophisticated Scattering Models16.4. Texture-Space Diffusion16.4.1. Possible Future Work16.5. Conclusion16.6. References
17. Ambient Occlusion
17.1. Overview17.2. The Preprocessing Step17.3. Hardware-Accelerated Occlusion17.4. Rendering with Ambient Occlusion Maps17.4.1. Environment Lighting17.5. Conclusion17.6. Further Reading
18. Spatial BRDFs
18.1. What Is an SBRDF?18.2. Details of the Representation18.3. Rendering Using Discrete Lights18.3.1. Texture Sampling18.4. Rendering Using Environment Maps18.4.1. The Math18.4.2. The Shader Code18.5. Conclusion18.6. References
19. Image-Based Lighting
19.1. Localizing Image-Based Lighting19.2. The Vertex Shader19.3. The Fragment Shader19.3.1. Additional Shader Details19.4. Diffuse IBL19.5. Shadows19.6. Using Localized Cube Maps As Backgrounds19.7. Conclusion19.8. Further Reading
20. Texture Bombing
20.1. Texture Bombing 10120.1.1. Finding the Cell20.1.2. Sampling the Image20.1.3. Adjacent Cells’ Images20.1.4. Image Priority20.1.5. Procedural ImagesMultiple Images per Cell20.1.6. Random Image Selection from Multiple Choices20.2. Technical Considerations20.2.1. Efficiency Issues20.3. Advanced Features20.3.1. Scaling and Rotating20.3.2. Controlled Variable Density20.3.3. Procedural 3D Bombing20.3.4. Time-Varying Textures20.3.5. Voronoi-Related Cellular Methods20.4. Conclusion20.5. References
IV. Image Processing
21. Real-Time Glow
21.1. Overview of the Technique21.2. Rendering Glows: Step by Step21.2.1. Specifying and Rendering the Sources of Glow21.2.2. Blurring the Glow Sources21.2.3. Adapting the Separable Convolution21.2.4. Convolution on the GPU21.3. Hardware-Specific Implementations21.3.1. Direct3D 921.3.2. Direct3D 821.3.3. Direct3D 721.4. Other Uses for Blur21.5. Adding the Effects to a Game Engine21.5.1. Rendering Context21.5.2. Aliasing Issues21.5.3. DirectX 7 Accuracy Issues21.5.4. The After-Image Effect21.5.5. The Variable Ramping Effect21.6. Conclusion21.7. References
22. Color Controls
22.1. Introduction22.2. Channel-Based Color Correction22.2.1. Levels22.2.2. Curves22.3. Multichannel Color Correction and Conversion22.3.1. Grayscale Conversion22.3.2. Color-Space Conversions22.4. References
23. Depth of Field: A Survey of Techniques
23.1. What Is Depth of Field?23.1.1. Calculating the Circle of Confusion23.1.2. Major Techniques23.2. Ray-Traced Depth of Field23.3. Accumulation-Buffer Depth of Field23.4. Layered Depth of Field23.4.1. Analysis23.5. Forward-Mapped Z-Buffer Depth of Field23.5.1. Analysis23.6. Reverse-Mapped Z-Buffer Depth of Field23.6.1. AnalysisArtifacts Due to Depth DiscontinuitiesArtifacts Due to Bilinear InterpolationArtifacts Due to Pixel Bleeding23.7. Conclusion23.8. References
24. High-Quality Filtering
24.1. Quality vs. Speed24.1.1. Filter Kernels: Image-to-Image ConversionsUser-Defined KernelsA Speedup for Grayscale DataWhen the Kernel Is ConstantA Bicubic Filter KernelScreen-Aligned Kernels24.2. Understanding GPU Derivatives24.3. Analytical Antialiasing and Texturing24.3.1. Interacting with Graphics API Antialiasing24.4. Conclusion24.5. References
25. Fast Filter-Width Estimates with Texture Maps
25.1. The Need for Derivatives in Shaders25.2. Computing Filter Width with Textures25.3. Discussion25.4. Further Reading
26. The OpenEXR Image File Format
26.1. What Is OpenEXR?26.1.1. High-Dynamic-Range Images26.1.2. A “Half” Format26.1.3. Range of Representable Values26.1.4. Color Resolution26.1.5. C++ Interface26.2. The OpenEXR File Structure26.2.1. The Header26.2.2. The Pixels26.3. OpenEXR Data Compression26.4. Using OpenEXR26.4.1. Reading and Displaying an OpenEXR Image26.4.2. Rendering and Writing an OpenEXR Image26.5. Linear Pixel Values26.6. Creating and Using HDR Images26.7. Conclusion26.8. References
27. A Framework for Image Processing
27.1. Introduction27.2. Framework Design27.2.1. Operators and Filters27.2.2. Image Data27.2.3. Missing Pieces27.3. Implementation27.3.1. The Image Class27.3.2. The ImageFilter Class27.3.3. Implementing a FilterFilter ParametersThe Fragment ProgramSetting the Cg Parameters27.4. A Sample Application27.5. Performance and Limitations27.6. Conclusion27.7. References
V. Performance and Practicalities
28. Graphics Pipeline Performance
28.1. Overview28.1.1. The Pipeline28.1.2. Methodology28.2. Locating the Bottleneck28.2.1. Raster Operations28.2.2. Texture Bandwidth28.2.3. Fragment Shading28.2.4. Vertex Processing28.2.5. Vertex and Index Transfer28.3. Optimization28.3.1. Optimizing on the CPUReduce Resource LockingMaximize Batch Size28.3.2. Reducing the Cost of Vertex Transfer28.3.3. Optimizing Vertex Processing28.3.4. Speeding Up Fragment Shading28.3.5. Reducing Texture Bandwidth28.3.6. Optimizing Frame-Buffer Bandwidth28.4. Conclusion28.5. References
29. Efficient Occlusion Culling
29.1. What Is Occlusion Culling?29.1.1. Occlusion Query29.1.2. Early-Z Rejection29.2. How Does Occlusion Query Work?29.3. Beginning to Use Occlusion Queries29.3.1. How to Use Occlusion Queries Properly29.3.2. Occluders vs. Occludees29.4. One Step Further29.4.1. Sorting Things Out29.4.2. A Small Caveat29.5. A Word About Bounding Boxes29.5.1. Static Objects29.5.2. Animated Objects29.6. Other Issues29.6.1. CPU Overhead Too High29.6.2. Rendering at High Resolutions29.6.3. Fast Depth-Writing Performance29.6.4. Frustum Culling29.7. A Little Reminder29.8. An Application: Lens Flares29.8.1. Rendering Lens Flares the Old Way29.8.2. Rendering Lens Flares the New Way29.9. Conclusion29.10. References
30. The Design of FX Composer
30.1. Tools Development30.2. Initial Features and Target Audience30.3. Object Design30.3.1. Benefits of the Interface ApproachObject QueryingObject LifetimePlug-In ManagementConnection ParametersMessage Senders and Receivers30.4. File Format30.5. User Interface30.6. Direct3D Graphics Implementation30.6.1. Device Windows30.6.2. Direct3D Effects30.6.3. ID3DXEffectCompiler30.6.4. ID3DXEffect30.7. Scene Management30.7.1. Geometry PipesSkinning30.8. Conclusion30.9. References
31. Using FX Composer
31.1. Getting Started31.1.1. The Materials Panel31.1.2. The Scene Graph Panel31.1.3. The Editor Window31.1.4. The Shader Perf Panel31.1.5. The Properties Panel31.1.6. The Scene Panel31.1.7. The Textures Panel31.1.8. The Tasks Panel31.1.9. The Log Panel31.2. Sample Project31.3. Conclusion
32. An Introduction to Shader Interfaces
32.1. The Basics of Shader Interfaces32.2. A Flexible Description of Lights32.3. Material Trees32.4. Conclusion32.5. References
33. Converting Production RenderMan Shaders to Real-Time
33.1. Introduction33.1.1. Conversion by Example33.2. Lights33.2.1. Light Sources33.2.2. Light Source Shaders33.2.3. Additional Lighting Parameters33.3. The Vertex Program vs. the Fragment Program33.4. Using Vertex and Fragment Programs33.5. Optimization Techniques on the Fragment Program33.5.1. Moving Code to the Application Level33.5.2. Moving Code to the Vertex Program33.5.3. Optimizing Through Texture Lookups33.5.4. Optimizing for Vectorization33.5.5. Final Optimizations33.6. Results and Conclusions33.7. References
34. Integrating Hardware Shading into Cinema 4D
34.1. Introduction34.2. Connecting Cinema 4D to CgFX34.3. Shader and Parameter Management34.4. Emulating the Offline Renderer34.5. Results and Performance34.6. Lessons Learned34.7. References
35. Leveraging High-Quality Software Rendering Effects in Real-Time Applications
35.1. Introduction35.2. The Content Pipeline for Hardware Rendering35.3. Components of Hardware Rendering35.3.1. Geometric Data35.3.2. Attribute Maps35.4. Generating the Components35.4.1. Creating the Geometry35.4.2. Rendering to Textures and Vertices35.5. Test Case and Results35.6. Conclusion35.7. References
36. Integrating Shaders into Applications
36.1. Introduction36.2. About Shaders36.2.1. Shader LanguagesIndividual ProgramsEffect Files: Why Use Them?36.3. The Anatomy of an Effect File36.3.1. Variables36.3.2. Structures36.3.3. Passes36.3.4. Techniques36.3.5. Annotations36.4. Types of Shader Data36.4.1. Scene Information36.4.2. Materials36.4.3. Renderer Context36.4.4. Vertex Data36.5. Communicating with the Shader36.5.1. Scene InformationUse the Variable NameUse Semantics or AnnotationsOptimizing Scene Communication36.5.2. Material Parameters36.5.3. Vertex Format36.5.4. Context36.5.5. Techniques vs. Passes for Context36.6. Extending the Effect File Format36.6.1. Supporting the Preprocessor36.6.2. Supporting Shader Variations36.6.3. Adding Shader Inheritance36.7. Conclusion36.8. References
VI. Beyond Triangles
37. A Toolkit for Computation on GPUs
37.1. Computing with the GPU37.1.1. The Programming Model37.1.2. Parallel Programming37.1.3. Advanced GPU Programming37.2. Reduce37.2.1. Parallel ReductionsPerformance37.2.2. Reduce Tidbits37.3. Sort and Search37.3.1. Bitonic Merge SortAlgorithmGPU ImplementationPerformance37.3.2. Binary SearchAlgorithmGPU ImplementationPerformance37.4. Challenges37.4.1. Limited Outputs37.4.2. Slow Readback37.4.3. GPU vs. CPU37.5. Conclusion37.6. Further Reading
38. Fast Fluid Dynamics Simulation on the GPU
38.1. Introduction38.1.1. Our Goal38.1.2. Our Assumptions38.1.3. Our Approach38.2. Mathematical Background38.2.1. The Navier-Stokes Equations for Incompressible Flow38.2.2. Terms in the Navier-Stokes EquationsAdvectionPressureDiffusionExternal Forces38.2.3. A Brief Review of Vector Calculus38.2.4. Solving the Navier-Stokes EquationsThe Helmholtz-Hodge DecompositionFirst RealizationSecond RealizationAdvectionViscous DiffusionSolution of Poisson EquationsInitial and Boundary Conditions38.3. Implementation38.3.1. CPU–GPU AnalogiesTextures = ArraysLoop Bodies = Fragment ProgramsFeedback = Texture Update38.3.2. Slab Operations38.3.3. Implementation in Fragment ProgramsAdvectionViscous DiffusionForce ApplicationProjectionBoundary Conditions38.4. Applications38.4.1. Simulating Liquids and Gases38.4.2. Buoyancy and ConvectionSmoke and Clouds38.5. Extensions38.5.1. Vorticity Confinement38.5.2. Three Dimensions38.5.3. Staggered Grid38.5.4. Arbitrary Boundaries38.5.5. Free Surface Flow38.6. Conclusion38.7. References
39. Volume Rendering Techniques
39.1. Introduction39.2. Volume Rendering39.3. Texture-Based Volume Rendering39.3.1. A Simple Example39.4. Implementation Details39.4.1. Data Representation and Processing39.4.2. Proxy Geometry39.4.3. RenderingTransfer FunctionsIlluminationCompositing39.5. Advanced Techniques39.5.1. Volumetric Lighting39.5.2. Procedural Rendering39.6. Performance Considerations39.6.1. Rasterization BottlenecksFragment Program LimitationsTexture Memory Limitations39.7. Summary39.8. References
40. Applying Real-Time Shading to 3D Ultrasound Visualization
40.1. Background40.2. Introduction40.2.1. Volume Rendering Data in a Cartesian GridEnclosing RectanglesPolygons of Intersection40.2.2. Volume Rendering Data in Pyramidal GridsThe Vertex ProgramThe Fragment ProgramVolume Rendering Ultrasound Data40.3. Results40.4. Conclusion40.5. References
41. Real-Time Stereograms
41.1. What Is a Stereogram?41.1.1. Stereo Photography41.1.2. Random-Dot Stereograms41.1.3. Single-Image Stereograms41.2. Creating a Single-Image Stereogram41.2.1. Parameters41.2.2. Rendering41.2.3. Creating Animated Single-Image Stereograms41.2.4. Fragment Program41.3. Sample Application41.3.1. Application Options41.4. References
42. Deformers
42.1. What Is a Deformer?42.1.1. Mathematical DefinitionControls42.2. Deforming on the GPU42.2.1. Formulating the Deformer42.2.2. Writing the Vertex ProgramWhat About Normals?42.2.3. Deforming NormalsHow Would We Compute Normals in Software?An Approximate Numerical TechniqueThe Jacobian Matrix42.3. Limitations42.4. Performance42.5. Example: Wave Deformer42.6. Conclusion
Appendix
Addison-Wesley Warranty on the CD-ROMNVIDIA Statement on the SoftwareNo WarrantyLimitation of Liability
Appendix
Natural EffectsLighting and ShadowsMaterialsImage ProcessingPerformance and PracticalitiesBeyond Triangles

Content preview from GPU Gems: Programming Techniques, Tips and Tricks for Real-Time Graphics

Chapter 5. Implementing Improved Perlin Noise

Ken Perlin New York University

This chapter focuses on the decisions that I made in designing a new, improved version of my Noise function. I did this redesign for three reasons: (1) to make Noise more amenable to a gradual shift into hardware, (2) to improve on the Noise function’s visual properties in some significant ways, and (3) to introduce a single, standard version that would return the same values across all hardware and software platforms.

The chapter is structured as follows: First, I describe the goals of the Noise function itself and briefly review the original implementation. Then I talk about specific choices I made in implementing improved Noise, to increase its quality and decrease visual ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

The Cg Tutorial: The Definitive Guide to Programmable Real-Time Graphics

Publisher Resources

ISBN: 9780321545404Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

GPU Gems: Programming Techniques, Tips and Tricks for Real-Time Graphics

by Randima Fernando

Chapter 5. Implementing Improved Perlin Noise

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.