Please use and bookmark only this resource from now!
Added 24 Jan 05 Updated 01 Dec 08
Publisher Morgan Kaufmann
Publication Date 2004-12-31
Hardcover - 752 Pages
ISBN 012229064X
"Credo Interactive has been using the WildMagic API for the past 3 years in various commercial projects. 3D Game Engine Architecture provides an excellent source of theoretical background and practical usage information for the API. Together the textbook and the WildMagic sourcecode form a comprehensive and well designed foundation for any 3D application." Lars Wilke, Director of Development, Credo Interactive Inc.
"For those that have searched for a commercial quality rendering library available at virtually no cost and with extensive clear documentation. Let them look no further. From low level structures, to high level application design, Eberly has laid out everything necessary for commercial quality game development. May the projects inspired by his writings be plentiful and prosperous." Timothy Prepscius, DimensionDoor, Inc.
*CD-ROM with the complete C++ source code for Wild Magic version 3, a commercial-quality game engine for Windows, Linux, and OS X.
*A comprehensive, practical guide to all the steps necessary to build professional-quality real-time simulations with just minimal mathematics required.
*Emphasizes the application of software engineering principles and describes the architecture of large libraries.
Details;){kind=link}
New from 55.69 $
Used from 50.00 $
New from 52.99 $
Used from 54.95 $
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.
Whilst I have no doubt that the author is prolific in this field I felt this book was laid out in too complicated a manner for most people to follow.
Half the time it seems like the author is just talking to himself and enjoys the sound of himself waffling on about maths. What irks me here is that he himself said in the introduction that this book wouldn’t contain as much maths and more theory. This is rubbish and he’s soon just listing equations with almost no explanation to accompany them.
If you want to look at 3d graphics engines there’s a lot more on offer out there, I would recommend anything but this one.
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.
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.
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.
This book contains some very bad advice and some very bad code.
As an example, I’ll refer to an earlier review:
"Despite this, there are a few improvements / weaknesses I can see with the book. The TArray class has a crash bug in it (setting the grow size to 0 on an empty array and then try adding to it), The TList class is extremely simplified for low memory consumption and not speed (i.e. only one variety is presented to you)."
Dave Eberly rewrote Array and List classes that are available in the standard libraries. The alternatives provided are inflexible and slow compared to the C++ standard library - they also contain bugs, unlike most standard library implementations. He did this because he didn’t understand that the default memory allocation functions of the standard containers can be ignored in favour of user specified ones and becasue he assumed the containers were slow.
I’d also like to address a problem in the book’s synopsis - the ’Wild Magic’ engine is not a commercial level engine used by many companies. In fact I challenge Dave Eberly to produce evidence of a single successful commerical game built using his engine.
This book contains some very bad advice and some very bad code.
As an example, I’ll refer to an earlier review:
"Despite this, there are a few improvements / weaknesses I can see with the book. The TArray class has a crash bug in it (setting the grow size to 0 on an empty array and then try adding to it), The TList class is extremely simplified for low memory consumption and not speed (i.e. only one variety is presented to you)."
Dave Eberly rewrote Array and List classes that are available in the standard libraries. The alternatives provided are inflexible and slow compared to the C++ standard library - they also contain bugs, unlike most standard library implementations. He did this because he didn’t understand that the default memory allocation functions of the standard containers can be ignored in favour of user specified ones and becasue he assumed the containers were slow.
I’d also like to address a problem in the book’s synopsis - the ’Wild Magic’ engine is not a commercial level engine used by many companies. In fact I challenge Dave Eberly to produce evidence of a single successful commerical game built using his engine.
I wasn’t sure what to expect when I first bought this book, but having owned it for about 3-4 months and read a good deal of it, I have to say I was suprised (in the pleasant way :p). The book is well structured and gives a wealth of information on building a commercial quality game engine from the ground up. Starting with a few basic "graphics programming" examples to ease you into the subject, and then moving on to developing a full-blown engine this book covers subjects from basic 3D Vector math(s), to supporting shader programs for OpenGL and DirectX. All in all, an excellent read, and well deserving of its 5 star award. Get it now!
I wasn’t sure what to expect when I first bought this book, but having owned it for about 3-4 months and read a good deal of it, I have to say I was suprised (in the pleasant way :p). The book is well structured and gives a wealth of information on building a commercial quality game engine from the ground up. Starting with a few basic "graphics programming" examples to ease you into the subject, and then moving on to developing a full-blown engine this book covers subjects from basic 3D Vector math(s), to supporting shader programs for OpenGL and DirectX. All in all, an excellent read, and well deserving of its 5 star award. Get it now!
This book is, without doubt, the best book on writing a game engine I have seen. The wild magic engine contains an impressive amount of source code that helps you understand the author’s description on his topic’s of discussion. The book is well laid out and is extremely interesting to read, even more so than Harry Potter :). I found the content to be informative and well related to what goes into a professional engine, with a limited amount of maths theory thrown in for understanding purposes only, just like it should be. The fast mathematics functions are well explained and pretty good.
Despite this, there are a few improvements / weaknesses I can see with the book. The TArray class has a crash bug in it (setting the grow size to 0 on an empty array and then try adding to it), The TList class is extremely simplified for low memory consumption and not speed (i.e. only one variety is presented to you). There is not enough detail on custom heap management, which is essential for console game development.
However, these are very minor issues that are easily spotted if your implementing your own game engine. Its not really practical in a book covering so much detail in this kind of depth to talk about all the different types of each data structure (get a data structure book !) but it certainly gives you on a plate the ones you need in a game (from there you can look into lumped lists etc.). On the whole, this is an excellent book that makes you aware of all the issues involved in writing an engine of your own and ties up how the different areas fit in with each other superbly. It allows you go away and thoroughly investigate specialised topics for better/other alternatives and you know it will be relevant to what your trying to do. If I had two words to describe this book it would be "Top Class". Get it.
This book is, without doubt, the best book on writing a game engine I have seen. The wild magic engine contains an impressive amount of source code that helps you understand the author’s description on his topic’s of discussion. The book is well laid out and is extremely interesting to read, even more so than Harry Potter :). I found the content to be informative and well related to what goes into a professional engine, with a limited amount of maths theory thrown in for understanding purposes only, just like it should be. The fast mathematics functions are well explained and pretty good.
Despite this, there are a few improvements / weaknesses I can see with the book. The TArray class has a crash bug in it (setting the grow size to 0 on an empty array and then try adding to it), The TList class is extremely simplified for low memory consumption and not speed (i.e. only one variety is presented to you). There is not enough detail on custom heap management, which is essential for console game development.
However, these are very minor issues that are easily spotted if your implementing your own game engine. Its not really practical in a book covering so much detail in this kind of depth to talk about all the different types of each data structure (get a data structure book !) but it certainly gives you on a plate the ones you need in a game (from there you can look into lumped lists etc.). On the whole, this is an excellent book that makes you aware of all the issues involved in writing an engine of your own and ties up how the different areas fit in with each other superbly. It allows you go away and thoroughly investigate specialised topics for better/other alternatives and you know it will be relevant to what your trying to do. If I had two words to describe this book it would be "Top Class". Get it.
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.
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.
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.
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.
I’ve read quite a few of Mr Eberlys previous books, including his game engine book. One thing you can never say he’s shy of is putting in a little mathematics. Which is fine but its usually pretty hard going, and not really what you want to know.
Thankfully Mr Eberly has taken a different approach in this book, and has minimized the mathematical mumbo jumbo, and focused on the engineering issues in architecting a game engine which with the advent of vertex and pixel shaders has entered a new level of complexity.
The text focuses around the ’Wild Magic’ engine developed by Mr Eberly, and which is included on a CD with the book. The engine all in all is a pretty nice piece of work. It doesn’t contain everything a commercial game engine might have - such as scripting or networking support, but its got pretty much everything else. Each piece of functionality in the engine is broken down in the books text along with suitable extracts from the source code. One of the great things is if you want the detail you can just go to the source base, and find out really goes on.
One of the other great aspects of the book is that Mr Eberly often describes why he’s made a specific implementation choice, explaining competing solutions, and perhaps why he changed an implementation from a previous Wild Magic version. This is excellent stuff, and provides a real depth of understanding of what it takes to engineer a modern engine, which is passed on directly to the reader.
Another great aspect of the book is the implementation in the engine of the vertex/pixel shaders that is used. Its well explained and implemented, and I don’t know any other book that covers this fairly new subject matter in the context of engine architecture.
So in summary:
A really nice piece of work. Mr Eberlys best book so far. A great place to find out what makes a modern engine work, or to help building your own.
The best game engine architecture book currently available to my knowledge.
I’ve read quite a few of Mr Eberlys previous books, including his game engine book. One thing you can never say he’s shy of is putting in a little mathematics. Which is fine but its usually pretty hard going, and not really what you want to know.
Thankfully Mr Eberly has taken a different approach in this book, and has minimized the mathematical mumbo jumbo, and focused on the engineering issues in architecting a game engine which with the advent of vertex and pixel shaders has entered a new level of complexity.
The text focuses around the ’Wild Magic’ engine developed by Mr Eberly, and which is included on a CD with the book. The engine all in all is a pretty nice piece of work. It doesn’t contain everything a commercial game engine might have - such as scripting or networking support, but its got pretty much everything else. Each piece of functionality in the engine is broken down in the books text along with suitable extracts from the source code. One of the great things is if you want the detail you can just go to the source base, and find out really goes on.
One of the other great aspects of the book is that Mr Eberly often describes why he’s made a specific implementation choice, explaining competing solutions, and perhaps why he changed an implementation from a previous Wild Magic version. This is excellent stuff, and provides a real depth of understanding of what it takes to engineer a modern engine, which is passed on directly to the reader.
Another great aspect of the book is the implementation in the engine of the vertex/pixel shaders that is used. Its well explained and implemented, and I don’t know any other book that covers this fairly new subject matter in the context of engine architecture.
So in summary:
A really nice piece of work. Mr Eberlys best book so far. A great place to find out what makes a modern engine work, or to help building your own.
The best game engine architecture book currently available to my knowledge.
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.
You must login first, to write an comment/review!
Optimized for Internet Explorer 6.0+!