||New Reviews| |Software Methodologies| |Popular Science| |AI/Machine Learning| |Programming| |Java| |Linux/Open Source| |XML| |Software Tools| |Other| |Web| |Tutorials| |All By Date| |All By Title| |Resources| |About||
Keywords: C++, game development, PS2, Xbox, Game Cube
Title: Cross-Platform Game Programming
Author: Steven Goodwin
Publisher: Charles River Media
Media: Book, CD
Verdict: A decent book but it could have been more
In Cross Platform Game Programming, author Steven Goodwin describes the major challenges developers face when building a cross-platform game or engine. The book spans eleven chapters through 460 pages and includes a CDROM containing the book's sample code and several useful toolkit libraries.
As games publishers continue to release titles simultaneously on multiple platforms, developers must contend with two or more console architectures during development. In order to isolate the high level changes and streamline development efficiency, games usually sit on top of an engine designed to abstract away hardware details to common API calls. The first chapter describes the typical problems encountered when attempting to write a cross-platform engine and discusses how to design low level systems to prevent cross-platform issues.
A key goal in writing cross-platform software is to reduce fundamental differences between target environments. The book's second chapter highlights code design methods and nuances that are critical to consider and adopt. Some of the more subtle points discussed include language implementation differences between compilers, deterministic mathematical calculations, and different debugging environments. Goodwin describes common pitfalls to avoid and design considerations to adopt.
Each of the subsequent chapters focus on a specific hardware difference: memory, CPU, storage, and input devices. The memory chapter describes issues associated with alignment, basic type sizes, and designing a memory management layer to create a common allocation scheme. The CPU chapter considers hardware timers, multi-threading, and various time management strategies. The storage chapter discusses creating cross-platform data file formats, endian issues, safe serialization, and creating a custom file system. Lastly, the input device chapter considers treatment controllers and platform specific interface devices.
Without going into specific detail regarding today's console hardware, the book does a good job describing typical pitfalls and troubles one will encounter writing an engine to abstract the hardware of all three major systems. In particular, Goodwin addresses game specific problems like resource construction, the art asset pipeline, and video playback. Sample code is sprinkled throughout the book to help highlight topics discussed in the text. I was a little surprised the book didn't allude to any specs of the upcoming consoles, however, but instead stuck with the PS2, Xbox, and Game Cube.
In the later chapters, the book tackles cross platform problems found in higher-level systems like audio, graphics and networking, with mixed success. For example, the audio chapter emphasizes various resource compression algorithms (MP3, Ogg, etc.) as a mechanism for data homogeneity across multiple platforms but the audio engine itself seemed rather shallow and contrived compared to the previous chapters on hardware abstraction.
The text comes with a CDROM that contains the book source code and figures, as well as several freely available SDK and toolkit packages like DirectX, Lua, and Ogg Vorbis. The CD is nice but unspectacular given the book is relatively light on sample code and examples and considering that most developers probably already have the other packages.
Overall, Goodwin does a good job presenting the challenges facing game developers who undertake writing a cross platform engine. In reading the text, I've encountered and had to cope with almost every issue he presented and found the writing to be credible. However given the book's length, I wished that it had included actually creating such an engine rather than talking about it generically (with some partial implementation of specific subsystems).