3D Game Engine Architecture. Engineering Real-Time Applications with Wild Magic: Engineering Real-time Applications with Wild Magic (Morgan Kaufmann Series in Interactive 3D Technology) [Englisch] [Gebundene Ausgabe]

One of the criticisms I had of Dave Eberly's previous 3D Game Engine Design is that it didn't really say much about how to design an engine. Rather, it focused mostly on the programming/implementation details, which was disappointing to some. This new book is what many people expected from the older book.

In this book, the author walks through the design and architecture of a 3D game engine, using his Wild Magic engine as an example, but also drawing on his experience developing NDL's NetImmerse. Throughout, he describes why each design decision was made, and in many cases alternative solutions are discussed as well. This isn't just a high level discussion, however, as ample source code, figures, equations, and sample applications are included to get you started with implementation.

The topics covered include the core engine systems, scene graphs, renderers, cameras, LOD, animation, terrain, special effects, physics and collision detection. Numerous sample applications and tools are also included. Dave's writing style is clear and minimally conversational, and he's kept the math to a minimum, making this a remarkably easy read.

This isn't a complete treatment of a game engine, since some important topics (e.g. scripting, audio) aren't included, but the material it does cover is worth it. Whether you're currently working on a game engine, planning to start one, or just want to have a better understanding of how they work, you'll be happy with this book.

This is an acceptable introductory book for the architecture of an AAA-quality game engine, under the consideration that it has so little competition.

The most significant criticism I have of the book is its repeated digression of topics into a documentation of the Wild Magic engine. If you intend to use the Wild Magic engine, I highly recommend the book, but for anyone not using it, this book saves far too few pages for discussions of general engine architecture.

For example, the entire second chapter is basically a documentation of the basic types defined for the Wild Magic engine. If you are architecting a large scale project, you do not want to start the discussion with talk of a smart pointer class. Or an array class. Unfortunately, this is exactly how the book begins.

Throughout the book, the reader is constantly forced to shift through documentation for each Wild Magic class. While the author does use the engine to illustrate points, often the point is so heavily mixed with the documentation that it is tedious to pick out the general discussion.

My secondary criticism of the book is that too many words are used in specific (but uncommon) ways - making it hard to follow at times. The sad part is that the author acknowledges this for some words (which helps the reader) but fails to for others. An example of the latter is when the author concedes that he uses the word `animation' to mean any event that happens over a period of time. You will not find that definition in any dictionary, but at least he specifies his intent, which is slightly forgivable. What is not forgivable is the other phrases/words that are not acknowledged as being uncommonly used, such as `world bounds' and `local bounds'. Too often I found myself carefully following discussions not because I found the material difficult, but because I needed to extract the context for which the author is using a word or phrase. In this sense it makes it hard for anyone to simply use the book for reference purposes.

This book deserves three stars because it is a good (although sometimes short) treatment of the many subjects that are part of a 3D game engine. It loses one star for trying to combine two related, but what should be separate discussions - general engine architecture and documenting Wild Magic. It loses another for being overly verbose and dry (see my secondary criticism). It has so few competitors that you might just have to accept its failings and shift through the material to dig out the general architecture nuggets that are dispersed throughout the book.

Few books on the topic of 3D and game engines are as thorough as Eberly's latest. He walks you through a top shelf commercial quality engine (minus some bells and whistles) and gives strong details and motivations behind the entire codebase's design choices.

Not only is it well written, its generous of him to continue to make this quality code so cheaply available to readers. A job well done, I urge all fellow hobbyists and professionals to support his work.