Customer Reviews

3D Game Engine Architecture: Engineering Real-Time Applications with Wild Magic (The Morgan Kaufmann Series in Interactive 3D Technology)

5 star:		(5)
4 star:		(3)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

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.

I don't know if this book the best documentation of a software architecture ever written, but its gotta rate up there. Probably its only rivals would be some of the foundational papers about the design of UNIX.

Why are there so few good contenders? Well, the genre of documentation for software architecture is a demanding one, because you need to master of so many skills in order to do it right. What makes it even harder is that the codebase is always changing in response to bugfixes and enhancements, which puts the documentation in continual jeopardy of drifting away from the codebase it describes.

Yes, this volume is a bit more plodding than Eberly's usual effortless writing style, but remember, he's documenting a software architecture, which is an inherently plodding task. Its ploddinghood is therefore a feature, not a bug. Moreover, he is never gratuitously plodding.

f you want to be a great documentor of software architectures, then pay close attention to the techniques Eberly uses here. Notice how, by casting the documentation in a tutorial form, he simultaniously makes it (1) a much more interesting read, and (2) makes it a dual-use document, invaluable both to newbies getting up to speed and to old pro's wanting to refresh their memory.

Budding game engine developers will find this book invaluable, but they are not the only ones who would benefit from reading it. This book could be profitably used in a general software architecture class, as an example of how to really document a software architecture.

In addition, a game engine's architecture is a superset of many other software architectures. For example, someone who is building a large-scale CAD system, or an EDA package, or an event-driven simulation package, or a physics simulation package, would also save themselves from many unanticipated "gotchas" by giving this book a close read.

The title says everything, this book treats most aspects concerning game engine design architecture and programming. Although not focusing in the next generation graphics architectures and shaders, it does provide an excellent basis for core engine and underlying graphics architecture design. General programming topics such as memory layout and shared object references are also discussed. A great book for begginers and a nice reading for professionals.

Eberly's latest book is worth a read for those interested in game/graphic engine architecture. This is not a book on the latest and most sophisticated graphics algorithms. It is a book on architecting a well designed, commercial quality game engine. I think it will be especially useful for those trying to improve the design of an existing architecture.

I really liked his treatment of continuous level of detail, terrain and bounding volumes. Though I did find some other sections were pretty dry. In particular I think the first chapter was pretty drawn out and didn't help motivate me for the rest of the book.

The CD comes with tons of source code accompanied by some lengthy release notes. Don't let the release notes scare you as you should only have to change a few things to get the code to compile.

If you're using/planning to use the Wild Magic engine, this book is required reading.

The book combined with the working(!) examples on the CD really get you started. The very first example shows how you can draw an object, view it in perspective projection, rotate and translate the object, and rotate and translate the camera.
The examples use OpenGL API, and I compiled only the VC++ 7.1 project that use OpenGL as the rendering mechanism in VC++ 8.0 on Windows Vista - this works well.
Only complaint is that there is no chapter that explains the matrix model of OpenGL. Sure enough this is to be found in a lot of other books, but if the author had decided to put in a chapter explaining the matrix model - e.g. how the perspective transformation matrix is derived from first principles, then this would be the only book you ever need.

Well, needless to say, Eberly rocks. This is a great book on game engine architecture - even though it's less mathematically intensive than Eberly's other books (which, for many, is a good thing), it has a very good coverage of software engineering aspects of game engines, as it explains in detail how (and why) the WildMagic engine is organized. Do keep in mnid, though, that the book's purpose is not teacing how to develop games or algorithms for that - it's a software engineering book, and a good one at that.

I've had several false starts at 3d programming. I've tried using the code from several other books but quickly gave up after getting a short distance into the concepts. Making the sample programs work with Windows XP and Visual Studio just isn't that easy in most cases. These programs worked as indicated with Visual Studio. I was quite happy.

None the less the code could use more documentation and clarity. For instance in the simple drawmesh program the LoadBmp24 routine returns Hight and Width as a side-effect of the call. I tried my own odd shaped bitmap and the routine kept failing. These two comment lines would have been really helpful:

// OpenGL prior to 2.1 requires textures be in 2d arrays
// whose dimensions are multples of 2.

After spending hours tracking that down it was easy to adjust the routines to actually work with arbitrary bitmaps and triangle meshes.