Skip to content

Game Asset Pipeline

Spend $50 to get a free movie!

ISBN-10: 1584503424

ISBN-13: 9781584503422

Edition: 2004

Authors: Ben Carter

List price: $49.95
Blue ribbon 30 day, 100% satisfaction guarantee!
what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!

Many of today's computer games are mega productions with huge teams and budgets, vast quantities of content, and crunched schedules. Getting these games to market is not an easy feat. Just managing the creation of content and getting that content into the right place at the right time is an enormous challenge. Hundreds of development hours are lost dealing with asset and pipeline issues, so the need for a working system is immense. The Game Asset Pipeline is written for tools programmers, producers, and managers who need to know how to create such a system. The solutions and ideas presented in the book cover current technology and methods that can be used to design and implement an asset…    
Customers also bought

Book details

List price: $49.95
Copyright year: 2004
Publisher: Charles River Media
Publication date: 9/3/2004
Binding: Paperback
Pages: 302
Size: 7.25" wide x 9.00" long x 1.00" tall
Weight: 1.694
Language: English

Ben Carter (Guildford, England) has been writing about the games industry and other topics since 1995. His articles have appeared in magazines and newspapers, including Edge, Super Play, The Irish Times, G4 Ireland, Manga Max, Game Developer, Develop, and CTW. He has also contributed to the Eurogamer Web site and was a speaker at ECTS/GDC Europe 2003. Since 1997, he has been working in various areas of game development, most recently as an engine/technology programmer on titles including Battle Engine Aquila and Harry Potter and the Prisoner of Azkaban.

Acknowledgments
Preface
Introduction
Offline Processing
Beating the RAM Barrier
Streaming
Other Factors
The Asset Pipeline
The Asset Feedback Loop
The Structure of Game Assets
Builds
Version Control
Asset Dependencies
Data Validation
Error Handling
Workflow
Conclusion
Where Do Assets Come From?
Tool Integration
Adding Features
Naming Conventions
Additional Data Fields
Plug-in Objects
Custom Export Tools
Data Formats
2D Bitmap Data
Audio Data
Video Data
3D Object Data
Custom Intermediate File Formats
Text or Binary?
File Structure
Wrapper Formats
XML
Conclusion
A High-Level View of Asset Management
Why Asset Management Is Not Source Control
Differences in Data
Handling Very Large Files
Asset Identification
Metadata
Change Tracking and History
Broken Data
Dealing with Broken Assets
Local Changes
Asset Building Shortcuts
Unrepresentative Previews
Runtime Editing
Synchronizing Code and Data
Integrating Code into the Asset Pipeline
Building a Distribution Package
Automated Testing
Conclusion
Building an Asset Management System
Storage Systems
Native Filing Systems
CVS
Subversion
Bitkeeper
Perforce
Alienbrain
Databases
Transactions and Locking
Operation Queues
Record Locking
Separating Metadata and File Locks
Client/Server Architecture
Clientless Architectures
The Client/Server Boundary
Using File Sharing Protocols
Intelligent File Updating
Client Tools
GUI Tools
Command-Line Tools
Shell Integration
Managing the Local Repository
Preventing Unwanted File Modifications
Handling Temporary Files
Client Tool UI and Functionality Considerations
Hierarchies and Views
Separating Projects
Sharing Files between Projects
Searching
Unique Identifiers
Linking Files
Metadata
Workflow Control
Preview Functionality
Showing Asset Modifications
Access Controls and Security
Using Views to Control Access
External Security
Providing an External API
Single and Multiple Client Models
Interface State
High-Level APIs
Scripting Support
Change Notification Handling
Caching Strategies
Archiving and Purging Data
Choosing Which Asset Revisions to Remove
Deleting Files
Archiving Files
Manually Purging Assets
Conclusion
Texture and Image Processing
Textures
Texture Swizzling
Texture Compression
Performing Texture Compression
Texture Quantization
Texture Resizing
Conforming Textures
Color Reduction
Dithering
Ordered Dithering
Error Diffusion Dithering
Dithering Textures
Using Alternative Color Spaces
The YUV Color Space
Conclusion
Geometry Processing
Mesh Data
Indexed Vertices
Model Hierarchy Information
Mesh Geometry Processing
Stripification
Building Triangle Strips
The Greedy Algorithm
The SGI Algorithm
Back-Face Culling and Winding Order
Merging Strips
Making Use of Draw-Cancel Flags
Strips versus Lists
Vertex Cache Optimization
Triangle Lists
Depth Sorting
Sanitizing Input Data
Orphaned Data
Vertex Welding
Removing Degenerate Triangles
Non-Coplanar Polygons
Regular Mesh Subdivision
Clipping Triangles
Clipping Polygons
Geometry Compression
Compressing Vertex Positions
Bone Weight Processing
Removing Redundant Bone Associations
Using Pre-Multiplied Bones
Constructing Composite Bones
Subdividing Skinned Meshes
Building Bounding Volumes
Axis-Aligned Bounding Boxes
Bounding Spheres
Oriented Bounding Boxes
Convex Hulls
Interior Bounding Volumes
Transparency and Bounding Volumes
Generating Multiple Bounding Volumes
Bounding Volumes for Animated Meshes
Bounding Volumes for Skinned Meshes
Performing Vertex Compression with Animated Bounding Boxes
Mesh Hierarchy Processing
Collapsing Nodes
Removing Leaf Nodes
Merging Nodes
Level of Detail Simplification
Hierarchy Merging
Polygon Reduction
Generating Imposter Sprites
Using Imposter Geometry
Audio and Video Processing
Audio
Resampling
Looping Samples
Audio Compression
ADPCM
MP3
Scripting Languages
Compiling Script Code
Deriving Dependencies from Scripts
Video
Video Compression
Localizing Video
Subtitles
Video Standard Conversion
Conclusion
Environment Processing
BSP Trees
Building a BSP Tree
Potentially Visible Sets
Portals
Ray Casting
Beam Casting
Routing Information
Accessibility Information
Connectivity Information
Precalculated Lighting
Vertex Lighting
Lightmaps
Volumetric Lighting
Conclusion
Managing Asset Processing
Dependency-Based Processing
Determining Asset Dependencies
Determining When Assets Have Changed
Handling Code Changes
The Make Tool
Descriptor File Syntax
Advantages and Limitations of Make
Output Data Formats
Standardizing Wrapper Formats
Including Metadata
Memory Ready and Parsed Formats
Byte Order Considerations
Handling File Interdependencies
Building Robust Tools
Be Lenient in What You Accept, but Strict in What You Output
Handling Tool Failure
Debugging the Pipeline
Maintaining Data Integrity
Interfacing to Existing Systems
Conclusion
Final Data
File Packing
Packed File Formats
Handling Very Large Package Files
Using Multiple Package Files
Obfuscating Data
Data Layout
Optimizing Linear Loading Procedures
Optimizing Streaming
Audio Streams
Interleaved Streams
Integrity Checking
Digital Signatures
Public Key Signatures
Cryptographic Hashing
Using Cryptography in Games
Encryption
What to Encrypt
Compression
What Can Be Compressed?
Compression Schemes
Other Compression Issues
Distribution Media
CD-ROMs
DVDs
Cartridges
Hard Discs
Internet Distribution
After Shipping
Data Archival
Patching Data
Conclusion
Bibliography
Index