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

by David H. Eberly (Author) "Computer graphics has been a popular area of computer science for the last few decades..." (more)
Key Phrases: nonintersection test, vertex dependencies, renderer state, Last Separating Axis, Numerical Design, All Files (more...)

Editorial Reviews

Amazon.com Review
Aimed at the working Visual C++ game developer, 3D Game Engine Design provides a tour of mathematical techniques for 3-D graphics, and the source code that's used to implement them in state-of-the-art video game engines. If you work in the game industry (or would like to), this book will serve you well, because it delivers excellent best practices for algorithms and programming techniques that'll help your software keep up with the competition.

This text is a virtual encyclopedia of expertise that's based on the author's own work and research in the gaming industry. It provides the mathematical notation, algorithms, and C++ code (on the accompanying CD-ROM) that are needed to build fast and maintainable game engines. Early sections start with the basics, with the math that's used to work with common 3-D objects (like spheres and boxes). Highlights include a high-powered review of quaternion algebra--in many cases, the preferred way to transform 3-D data.

The chapters on graphics pipelines explain the math that's behind representing and rendering a 3-D world in 2-D with intervening effects like lighting and texture mapping. A variety of current algorithms are provided for representing 3-D scenes, efficient picking (which allows a programmer to determine the object in a 3-D world that has been selected), and collision detection (in which objects collide virtually). In the game software of today, curves--and not individual triangles or polygons--often are used to represent 3-D objects. Algorithms that are used to turn curves into rendered surfaces are provided, too.

Later sections look at the current thinking about animation techniques for characters (including key frames, inverse kinematics, and skinning (in which digital skin is fitted over digital bone to create more realistic-looking movement)). How to represent terrain inside virtual worlds also is explained. The book closes with excellent material on such cutting-edge special effects as lens flare and projected shadows, which can add an extra level of realism to a video game. An appendix examines guidelines for designing object-oriented game software in C++.

Filled with mathematical insight and expert code that puts each principle or algorithm to work, 3D Game Engine Design provides an expert view of what goes into building a state-of-the-art game engine. --Richard Dragan

Topics covered:

• Mathematical methods and sample source code for 3-D game development
• Geometrical transformations
• Coordinate systems
• Quaternions
• Euler angles
• Standard 3-D objects: spheres, oriented boxes, capsules, lozenges, cylinders, ellipsoids
• Distance methods for a variety of shapes
• Introduction to the graphics pipeline
• Model and world coordinates
• Projecting perspective
• Camera models
• Culling techniques
• Surface and vertex attributes
• Rasterizing
• Efficiency issues for clipping and lighting
• Hierarchical scene representation, using trees and scene graphs
• Picking algorithms for a variety of 3-D shapes
• Collision detection for static and dynamic graphical objects
• Oriented bounding-box (OBB) trees
• Basics of curves and special curves (including Bezier curves and various splines)
• Curves (generating surfaces from curves by using different techniques)
• Character animation, using keyframe animation and inverse kinematics
• Skinning
• Geometrical level of detail considerations
• Techniques for generating game terrain
• Spatial sorting and binary space partitioning (BSP)
• Special effects: lens flare, bump mapping, volumetric fogging, projected light and shadows, particle systems, morphing techniques
• C++ language features for effective object-oriented design
• Reference to the numerical methods required for game mathematics

Review
"I highly recommend David Eberly's "3D Game Engine Design: A Practical Approach to Real-Time Computer Graphics". This is from one of the developers behind the NetImmerse 3D engine, and it's a great book, filled with lots of practical information"
- Tim Sweeney, voodooextreme.com

"3D Game Engine Design....is best described as a reference manual for 3D real-time graphics engine programmers. But oh, what a reference manual it is."
-- Game Developer Magazine -- Review

See all Editorial Reviews

Product Details

• Hardcover: 561 pages
• Publisher: Morgan Kaufmann; Book & CD-ROM 1st edition (September 2000)
• Language: English
• ISBN-10: 1558605932
• ISBN-13: 978-1558605930
• Product Dimensions: 9.6 x 7.7 x 1.3 inches
• Shipping Weight: 2.9 pounds
• Average Customer Review: 3.8 out of 5 stars See all reviews (59 customer reviews)
• Amazon.com Sales Rank: #489,346 in Books (See Bestsellers in Books)

  Popular in this category: (What's this?)

  #16 in

  Books > Computers & Internet > Programming > Algorithms > Real-Time Data Processing

Customer Reviews

Most Helpful Customer Reviews

108 of 116 people found the following review helpful:

3.0 out of 5 stars Does not deliver as promised, November 14, 2000

By	"tavison" (Seattle, WA USA) - See all my reviews

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.

14 of 14 people found the following review helpful:

3.0 out of 5 stars You'd better know a *lot* of advanced math before starting, July 7, 2001

By A Customer

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.

11 of 11 people found the following review helpful:

4.0 out of 5 stars Useful and informative, but not to be used in isolation, December 5, 2000

By	Vat "machinshin" (Atlanta, GA, USA) - See all my reviews

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