Customer Reviews

3D Game Engine Design: A Practical Approach to Real-Time Computer Graphics (The Morgan Kaufmann Series in Interactive 3D Technology)

5 star:		(24)
4 star:		(11)
3 star:		(11)
2 star:		(2)
1 star:		(8)

 

 

The title of this book and the back cover convinced me to buy this book on sight. "At last," I thought, "a book covering the dificult task of game engine architechture." I was very wrong. This book does a fair job of going one level deeper than the Game Programming Gurus series, or 3D Game programming by De Geos, or any of the hack retained mode Direct X books, but it does not come close to the full knowledge of Foley - Van Dam, or the Watt and Watt books. It is written at a math level that if you can easily understand it, you don't need it. This book, ignoring its title for a minute is a poor substitute for Real Time Rendering even at twice the thickness. It is more complicated than the two excellent books by the Watt brothers, 3D Computer Graphics and Advanced Animation and Rendering Techniques. It fails to explain architecture even remotely as well as Lakos' book Large Scale C++. In short it does a poor job at replicating what many books have done before.

What it does do though, is expose a glaring hole in all the books relating to graphics programming and games in particular. There still is no good book on designing a game engine. I work in the industry, and while I've seen some briliant ideas on visual effects and performance gains, I have never seen an architecture that wouldn't have the lead programmer fired from any other industry. There is a need for what the title indicates, but the subject is contained in appendix A. The rest of the book is about culling and collisions and ray tracing and every other low level library function I could have gotten from a dozen books. There is massive amounts of source code. And while reasonably well written as a library, the whole is woefully lacking as a framework. This book should have been the other way around. We all have the libraries, how about a little discussion on the framework to hang them in.

First off, the positives:

1. Dr. Eberly is writing about a subject which has never really been dealt with at an intermediate or advanced level. "Game Programming For Dummies" this ain't.

2. The discussions and subjects tackled are top-notch. If you really want to know how a solid graphics engine works, aside from stealing the code to Quake 2 and sifting through it (not an easy read, I'm sure), this is the best place to begin. All sorts of advanced topics are touched upon, things you won't find in any other book.

3. The writing itself is quite good, especially considering the technical discussions involved.

Sad to say, however, the book gets only rates average for the following reasons:

1. The mathematical understanding needed to make sense of much of the text is considerably more than the preface and some reviewers would have you think, and

2. For a 3D "Game Programming" book, there are damn few illustrations in parts.

The math used in this book requires you to know a fair amount of later-semester calculus, to be very fresh on your advanced linear algebra, and to even know some statistics. Covariance matrices? They're in there.

Those of you who took calculus a few years back and forgot some of it, or maybe had linear algebra as a freshman, are in for quite a surprise. And those who haven't taken many math classes, period, can save your $60 and just forget it.

I don't disagree with anyone who says you need to know a lot of math in order to work with computer graphics, and 3D in general. Anyone tackling the subjects Dr. Eberly does had better know their stuff. It's just that a shameless plug by the author for his favorite math texts (or a better primer) might have helped a lot of readers get up to speed.

Even if you've got enough of a math background to follow the technical discussions, the bigger problem is the lack of diagrams in the book.

When you're talking about bounding volumes or collision detection, it really helps to be able to see a sample of what the author is talking about. Instead, all we get for much of the book is equation after equation, with no images to try and place things against.

Whether this was Dr. Eberly's oversight, or the fault of the publisher is unimportant. The book in it's present form just won't do for any but those looking for a code tidbit, or your run-of-the mill PhD who likes to sketch out his own illustrations as he reads the text. The rest of us will have a hard time making use of it. It's too bad, considering it's strengths.

I read this a few years ago, and have referred back to it many times, but I only recently realized that I neglected to write a review of it.

This book is well-written and contains a lot of useful information. The author is one of the few people qualified to write a book of this nature, and he has done an admirable job. That said, the title is pretty misleading, since the book has very little to say about the design of a game engine. Instead, it focuses on implementation details and the math involved with them. Topics covered include geometrical methods, the graphics pipeline, tree-based scene graphics, intersections, collision detection, curves and surfaces, animation, terrain, spatial sorting (quad/octrees, portals, BSPs), special effects, object-oriented infrastructure, and numerical methods. The author doesn't gloss over anything, providing detailed mathematical derivations of how things work.

Unfortunately, the math is so heavy that unless you're already pretty familiar with the subject matter, you'll probably have a hard time with the book. Therefore, I think that the target audience is much smaller that the group that would be attracted by the title.

If you're involved in game engine development or just want to deepen your knowledge, I think you'll appreciate the fact that the author doesn't pull any punches. Otherwise, you'll probably be more interested in the author's new book 3D Game Engine Architecture, which was recently released.

This is an extremely thorough text and covers a wide variety of topics in a fairly detailed manner. The book is sort of a survey or "toolkit" of game and graphics engine techniques. it is unlikely that in writing a single game you will use everything in this book - but having the exposure to the numerous topics he dicsusses is good.

As others have noted, he's "heavy on the math." For me, this is a good thing, since I intend to use the book as a reference, not as a primer. While he is "heavy on the math" he is "light on the diagrams," really the only negative about this book at all.

I found the coverage of intersection and collision tests, and the section on numerical methods in the end, both to be especially good compared to other books.

In general, this book is an excellent reference for experienced readers, not a how-to for beginners. Very thorough, well written. The book feels academic and authoritative - however, the author has the in-the-trenches experience which lends him creditibility. Once you know the basics, this book is a must-have reference book.

I do think this is a great book for programmers. The fact that it comes with well written code libraries makes it a very powerful teaching tool. I was very pleased that an updated version of the code was available online that fixed some bugs. Many games use technologies that are discussed in this book. While many games may solve problems in much narrower ways because of the particular focus that their project has, this book covers good general approaches that are definitely valuable knowledge. One standout for me is the section on culling and clipping where different clip and transform sequences are discussed. Games very often use different sequences for clip and transform based on what is being rendered, but many graphics books only address a single traditional method. The appendix discussion and code implementation of c++ persistent storage is a good basis for tools code. Personally, I really like the author's kind of code style which has practical and readable c++ coding techniques similar those used in MFC. To be fair, the book doesn't really talk about a game engine, it talks about the many 3d math and rendering techniques that part of what is needed for a game engine.

This is a book on 3D Game Engines that is a must have for game developers. David Eberly does not shirk from presenting the user with rigorous mathematics (even a proof or two). Some of the coverage is really useful like LOD techniques,Scene Graph Management,Skinning and Curved Surfaces. This book is definitely not for beginners, and it would be best for intermediate level game programmers. If you don't like math stay away from this one (and computer graphics and game programming as well.) The author never fails to keep track of performance issues and discusses the costs involved in using various techniques. The best thing about this book: It was the first one to discuss such a wide array of topics about game programming at a time when most other references talked only graphics and ignored special considerations that arise in real-time 3D (notable exception, "Real Time Rendering / Moller & Haines").

However, the author could have done more justice to important topics like BSP trees(disposed off summarily in a single chapter). A discussion about speeding up math calculations using SIMD extensions in today's processors would have been a relevant addition to the book. The source code provided is incomplete (ex. the software renderer). Also, there is an OOP overkill in the sample code.

All in all, a most useful book to possess.

This is a really good book, and is quite useful, but having read both the reviews here, & the "review on the reviews" on david's website i can say that there are some caveats.
Cons->
1) Lots of Math
Yes, this true, there *IS* lots of math, and at times it can see overwhelming, but it's all useful, and david is right, if you think you can do 3d graphics engine programming without mathematics you're either delusional or on some drugs (and why aren't you sharing?)
2) No real explanations on most of the Math, or most of the rest of the methodologies either..
Ok, now (for me) *THIS* is the big one.. he gives you lots of different methodolgies, like using lozenges vs. capsules vs. AABB or OOBB for containing an a set of Vertices, but he doesn't give (from what i've seen) reasons as to *WHY* you'd want to prefer one technique over another, i mean, what's the advantage of using lozenge's to contain objects instead of using a OOBB or a k-DOP ? i get no such explanation, or even am attempt at one.
This book is what i would call "faith-based 3d graphics programming", he doesn't tell you *HOW* the math works, or even *WHY* it works, or *WHEN* you should use it, but he expects you to just understand and accept it, thanks but no thanks david.
Pros->
1) Lots of Math
What is bad is also good. David has taken mathematical concepts and equations from a couple dozen books and SIGGRAPH articles and condensed them into one book. And it's done pretty nicely.
2) *COPIOUS* amounts of C++ code
The amount of code this book comes with (indexed in the book by the mathematical equations defining the code) is truly staggering. But i hear you say , "hey wait, he's got code on his website, why can't i just use THAT?!?!" .. and you'd be right there is code on his site, but (barring a few exceptions) there's no math there to explain that code, so if you dont' know why it's there, and what it all means, the code's useless to you.Also, the code on the site (and in part the book) is meant to be used as drop-ins, take code drop into existing project,and keep going, the code in the book can be compiled, and there exist examples on *USING* the code.
The only question i have is his "branding" thing, i mean i have no problem with the Mgc prefix, but if you're going to do that David, and you're using C++, why not just encapsulate everything in a few namespaces?
namespace Mgc { class Quaternion{}; }; //and etc..
now, i hear ppl saying that Real-Time Rendering is "better" .. well not quite, RTR has good explanations but there's little math or code there, my suggestion would be in most part read the books in unison(course in places where the topics don't overlap you'd have to find other explanations, or math/code).. the math in this book and the explanations in RTR (+ a few other books i suppose) ..
overall high quality..

--vat

I'm giving this book an average rating because it tends to mislead folks. If you are not well grounded in mathematics before undertaking this book you will quickly find yourself lost.

If you are just starting out I would recommend Foley & van Damm, Computer Graphics : Principles and Practice, Second Edition in C or Alan Watt, 3D Computer Graphics 3rd Edition. These books provide a much gentler introduction to the topics, but do not cover 3D game engine design. My favorite 3D game engine text is by Alan Watt and Fabio Policarpo, 3D Games, Volume 1 : Real-time Rendering and Software Technology -- my only complaint about that book is its Windows-centric nature.

One great thing about this book is that the examples work under both Linux and Windows -- and as someone who's completely ditched Windows for Linux, I really appreciate this fact.

This book is an excellent reference for those intermediate to advanced computer scientists with an interest in 3D graphics/game engine design. If this doesn't sound like you, first get up to speed with the books I mentioned above and then come back to this one.

I have read the majority of the comments about this book, and I must say that I strongly disagree with some of you.

There seem to be an abnormal number of "math haters" buying this book, such that one does wonder as to the type of developer who is reading it.

In developing an advanced, or even not so advanced, 3D graphics engine, there is no getting around the Mathematics involved. I feel that Dr. Eberly has done a terrific job of covering the general gamut of what is needed for such an indepth and difficult task.

I apologize if I stereotype anyone here, but no serious, professional developer in his right mind is going to whine over needing to learn the Mathematics behind their work. Computer languages are built around the Mathematical principles that bore them, so please, before you blast a book and its author over _your_ inability to understand the material, consider a different job.

As a side note, I believe that Dr. Eberly intended his book primarily as a reference guide, not so much a learning tool. And I would also wager that Dr. Eberly himself has such a reference guide on his desk as well.

On the subject of reviewing this book, I thoroughly enjoy it, and it has a permanent place on my reference shelf, within easy reach. Even though I myself do not yet posess the knowledge to encompass ALL of the Mathematics in this book, knowing that it is there, and that more remains to be learned, is a great motivation to continue Mathematical study.

In closing, I applaud Dr. Eberly for writing a concise, accurate, and excellent Mathematical reference book, he has made a difficult subject significantly simpler.

Yes, this book is an invaluable reference. All the mathematical knowledge necessary to building a 3D engine is contained within its pages. Each topic is covered separately, with algorithm examples to support each mathematical discussion. A basic 3D engine is also included to help the reader put the concepts together.

You must, however, adapt well to formal mathematical notation to understand this book -- there is no handholding; it assumes the reader is familiar with vector and matrix algebra, linear algebra, multivariate calculus, and data structures. Following the mathematics can become quite tedious if you are lacking in any of these areas. One thing I think Eberly might have improved is "dumbing down" the mathematical notation to appeal to a broader audience, or at least have written the book in a more personal, explanatory manner (Its funny how the smarter a person is, the harder it is for him/her to express ideas in a way understanding to the rest of us).

For you college kids, I'd say you need up to Calc 3 and Linear Algebra. It'll help if you've taken a couple graphics courses, covering things like BSP/Oct/Quad trees, rendering pipeline analysis, and intersection testing. I myself AM a college kid, so trust me on this... it'll help if you have a little background. Also note that this book is non-API specific; you must know a 3D API well in order to implement the author's ideas. He uses OpenGL for his CD-ROM examples.

What else... Don't buy this book if you just want to implement special effects... check out the 3D Graphics Gems series for that. Concepts such as Lens Flare, Bump/Enviroment Mapping, Shadows, and Particle Systems are discussed, but only slightly within 4 pages of the last chapter -- which is understandable, considering the focus of this book is on the core 3D engine, not the flare surrounding it.

That's about it. Buy it if you've got patience, persistence, and are serious about 3D game programming -- and that's the bottom line.