Table Of Contents:
Introduction xiii
Contributor Biographies xv
About the Editor xxi

Part I Game Engine Design 1(216)

What to Look for When Evaluating Middleware for Integration 3(1)

Jason Hughes

Middleware, How Do I Love Thee? 3(1)

Integration Complexity and Modularity 3(1)

Memory Management 4(1)

Mass Storage I/O Access 5(1)

Logging 5(1)

Error Handling 6(1)

Stability and Performance Consistency 6(1)

Custom Profiling Tools 7(1)

Customer Support 7(1)

Demands on the Maintainers 7(1)

Source Code Availability 8(1)

Quality of Source Code 8(1)

Platform Portability 8(1)

Licensing Requirements 9(1)

Cost 10(1)

The Game Asset Pipeline 11(28)

Remi Arnaud

Asset Pipeline Overview 11(7)

Asset Pipeline Design 18(2)

Push or Pull Pipeline Model 20(2)

COLLADA, A Standard Intermediate Language 22(8)

OpenCOLLADA 30(3)

User content 33(6)

Volumetric Representation of Virtual Environments 39(22)

David Williams

Introduction 39(1)

Overview 40(2)

Data Structures 42(4)

Surface Extraction 46(6)

Rendering 52(4)

Physics 56(1)

The Future 57(4)

High-Level Pathfinding 61(18)

Daniel Higgins

Terms 62(1)

Start Your Engines 62(1)

Why High-Level Pathfinding? 63(1)

Preprocess Phase 64(7)

Fuzzy Pathing Phase 71(4)

Detailed Paths Phase 75(1)

Why Go Through All This Trouble? 76(3)

Environment Sound Culling 79(12)

Simon Franco

The Problem 79(1)

A Sound Culling Solution 80(3)

Constructing the Sound Grid 83(1)

Processing the Sound Grid 84(6)

Supporting Multiple Listeners 90(1)

Extensions 90(1)

A GUI Framework and Presentation Layer 91(16)

Adrian Hirst

GUI Systems 91(1)

Design Patterns: Model View Controller (MVC) 92(1)

A GUI Design 93(11)

And Finally 104(3)

World's Best Palettizer 107(16)

Jason Hughes

Palettes? Whatever for? 107(1)

Understanding Quantization 108(1)

Hard-Earned Lessons 109(2)

Algorithm Overview 111(9)

Future Work 120(1)

Results 120(3)

3D Stereoscopic Rendering: An Overview of Implementation Issues 123(16)

Anders Hast

Mechanisms of Plano-Stereoscopic Viewing 124(7)

Stereo Techniques 131(2)

Design Considerations for 3D Scenes 133(2)

Outlook 135(4)

A Multithreaded 3D Renderer 139(10)

Sebastien Schertenleib

The Memory Model 140(1)

Building the Display Lists in Parallel 141(2)

Parallel Models 143(1)

Synchronizing the GPU and CPU 144(1)

Using Additional Processing Resources 145(1)

Reducing the Pressure on the Memory Bandwidth 145(1)

Performing Graphical Operations in Parallel 146(3)

Camera-Centric Engine Design for Multithreaded Rendering 149(18)

Colt McAnlis

Uses of Multi-Core in Video Games 150(1)

Multithreaded Command Buffers 151(1)

Device-Independent Command Buffers 152(5)

A Camera-Centric Design 157(7)

Future Work 164(3)

A GPU-Managed Memory Pool 167(10)

Jeremy Moore

Background 168(1)

The Memory Pool 169(1)

Synchronization Issues 170(2)

The Staging Buffer 172(1)

Memory Pool Defragmentation 173(1)

Memory Pool Eviction 174(1)

Platform-Specific Considerations 174(1)

Future Work 175(2)

Precomputed 3D Velocity Field for Simulating Fluid Dynamics 177(10)

Khalid Djado

Richard Egli

Introduction 177(1)

Velocity Field Computation 178(3)

Physics Simplification 181(3)

Results and Discussion 184(3)

Mesh Partitioning for Fun and Profit 187(10)

Jason Hughes

Desirable Algorithm Properties 187(2)

Lessons Learned 189(2)

When Greedy Is Good 191(2)

Future Work 193(1)

Graphical Walkthrough 194(3)

Moments of Inertia for Common Shapes 197(20)

Eric Lengyel

Center of Mass 197(1)

The Inertia Tensor 198(3)

Derivation of Moments of Inertia 201(14)

Summary 215(2)

Part II Rendering Techniques 217(64)

Physically-Based Outdoor Scene Lighting 219(10)

Frank Kane

Positioning the Sun and Moon 219(2)

Computing Natural Sunlight 221(2)

Moonlight and Other Nighttime Light Sources 223(1)

Tone-Mapping the Light 224(2)

Implementation Notes 226(3)

Rendering Physically-Based Skyboxes 229(6)

Frank Kane

Generating and Drawing the Skybox 229(2)

Computing the Skybox Vertex Colors 231(2)

Integrating the Skybox with Your Scene 233(1)

Embellishing Your Skybox 234(1)

Motion Blur and the Velocity-Depth-Gradient Buffer 235(14)

Eric Lengyel

Technique Overview 236(2)

Rendering to the Velocity-Depth-Gradient Buffer 238(4)

Rendering the Post-Processing Effect 242(3)

Grid Optimization 245(4)

Fast Screen-Space Ambient Occlusion and Indirect Lighting 249(14)

Laszlo Szirmay-Kalos

Balazs Toth

Tamas Umenhoffer

Introduction 249(1)

A General Ambient Illumination Model 250(2)

Screen-Space Representation of the Scene 252(1)

Volumetric Ambient Occlusion 253(4)

Indirect Lighting of the Near Geometry 257(1)

Implementation 257(3)

Results 260(3)

Real-Time Character Dismemberment 263(8)

Aurelio Reis

What is Character Damage Modeling? 263(1)

Methods of Mutilation 264(1)

Bone Matrix Flattening 265(1)

Improvements 266(3)

Demo 269(2)

A Deferred Decal Rendering Technique 271(10)

Jan Krassnigg

The Problem 272(1)

The General Idea 272(1)

Geometry Rendering 273(2)

Fade Out And Wrap-Around 275(2)

Surface Clipping 277(2)

Limitations 279(1)

Additional Features 279(2)

Part III Programming Methods 281(70)

Multithreaded Object Models 283(6)

Jon Parise

Explicit Locking 283(1)

Message-Based Updates 284(1)

Multiple Thread Contexts 285(1)

Buffered State Changes 286(1)

Selecting the Best Approach 287(2)

Holistic Task Parallelism for Common Game Architecture Patterns 289(8)

Brad Werth

Tasks Versus Threads in Games 289(1)

The Task Scheduler 290(1)

Decomposing Game Patterns into Tasks 291(5)

The Future of Task Parallelism in Games 296(1)

Dynamic Code Execution Hierarchies 297(8)

Martin Linklater

What are Code Execution Hierarchies? 297(3)

Design Features 300(3)

Benefits & Pitfalls 303(2)

Key-Value Dictionary 305(6)

Martin Linklater

Design 305(1)

Using the KVD 306(1)

Code Details 307(3)

Caveats 310(1)

A Basic Scheduler 311(4)

John Bolton

Overview 311(1)

Task Functionality 311(1)

Scheduler Functionality 312(1)

Implementation 313(1)

Additional Functionality 314(1)

The Game State Observer Pattern 315(14)

Ron Barbosa

Creating a Game State Manager 317(4)

The Interfaces of the Game State Observer Pattern 321(1)

Making GameState Observable 322(3)

Creating Observers 325(2)

Managing Functionality by Game State 327(2)

Fast Trigonometric Operations Using CORDIC Methods 329(10)

John Bolton

Rotation Mode Algorithm 329(2)

Vectoring Mode Algorithm 331(1)

Applications 332(1)

Implementation 332(5)

Considerations 337(1)

Extensions 337(2)

Inter-Process Communication Based on Your Own RPC Subsystem 339(12)

Kurt Pelzer

History of Remote Procedure Call 340(1)

How RPC Works: Internal Architecture of RPC 341(2)

How to Build Your Own RPC Subsystem 343(4)

Why RPC is Useful for Game Engines 347(4)
About the CD 351(2)
Index 353