Game Asset Pipeline

Name: Game Asset Pipeline
Price: 6.73 USD
Availability: InStock
ISBN: 9781584503422

ISBN-10: 1584503424

ISBN-13: 9781584503422

Edition: 2004

Authors: Ben Carter

List price: $49.95

30 day, 100% satisfaction guarantee!

Buy used: $7.12

Marketplace

2 new & used from $6.73

what's this?

Rush Rewards U
Members Receive:

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…

Book details

List price: $49.95
Copyright year: 2004
Publisher: Charles River Media
Publication date: 9/3/2004
Binding: Paperback
Pages: 302
Size: 7.40" wide x 9.25" long x 0.67" 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