Rating: 
Summary: Not suitable for newbie
Review: First I would like to state I am reviewing this book in the perspective of a Newbie.1.The Book is fill with hardcore math jargon so if you are not experience in math don't try this book 2. The style of writting is definite for friendly to those who are not very familar with the topic. 3. It explain only all the math and theory in realtime 3D rendering and not much on the building a 3D engine. However the code that come with it do provide a clue . But I think it is not enough In Conclusion the book is definitely not for you if you do not have a good foundation in Math and you have no pior experience in this field. If you are looking for more API related reference I suggest Adrain Perez's "Advance 3D game programming using Direct X7". If you are interested in know more about real-time rendering I would suggest reading Tomas Moller's "Real-Time Rendering" the style of writting is less intimidation and easier to understand.
Rating: 
Summary: Useful and informative, but not to be used in isolation
Review: 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
Rating: 
Summary: Highly recommended for those learning computer graphics.
Review: 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.
Rating:
Summary: Does not deliver as promised
Review: 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.
Rating: 
Summary: Not so good
Review: This book was pretty terrible. "Linux source code" doesn't compile on latest gnu c++ compiler for linux. All methods and classes start with "Mgc" for branding which is extremely annoying. The book itself is unbearable unless you're a math professor and it doesn't need to be this way. Probably the worst of many computer science books i've purchased.
Rating:
Summary: an essential reference for the *mathematically* inclined
Review: This book is a great resource for all things 3D (or at least alot of them). Be forewarned that Dr. Eberly has TWO Ph.D.'s -- one in mathematics and one in computer science, and it shows in the book. Not that education is a bad thing, but it is a fairly rigorous book in terms of requiring a modicum of mathematical savy to digest. The applicability of the subject matter to the title of the book is excellent. You definitely get exactly what you pay for with this title. Bravo, Dr. Eberly! When is volume 2 coming out (hint, hint)?
Rating:
Summary: Good reference
Review: Hello all, Well, we (my boss and I) went out and bought this book thinking it was the end all from the grand master and would end our quest for the ultimate tome on high level 3D multimedia engine design and development. Our quest is not quite over, because it is and it isn't. This is a low level book, which gives you an exhaustive mathmematical perspective on the common alogrithms in use in 3D engine development. It is a decent reference for understanding what makes up all the functions and algorithms in a low level 3D library (better break out the calculus book though). Do you need the book? It's a good reference, but could you find the information say for a BSP or a Portal algorithm on the net? Sure. The code is opengl based, and some is kind of buggy at the moment, but there is a promise to make upgrades available on the site. Still, you can't beat having a bunch of algorithms in hand, especially when you're piecing together your engine. Do I like it? Yeah, I know it will come in real handy in time, but as others have said if you don't already have a clue about designing a 3d engine, then you may not get one from this book, so what's the point? The point is that it best qualifies as college text book suited for someone studying computer graphics programming at the lowest level. It is not even in the same genre as the current trend of how-to books on game development. I doubt that was ever the intent. It is along the line of the Foley, Van Dam book, Computer Graphics: Principles and Practice. Don't buy this if you think your going to have a 'Quake killer' when you're finished reading it.
Rating:
Summary: Perfect....Almost
Review: This is truly a one of a kind book. While not the Foley/VanDam of game programming books, it is rather comprehensive. What it does cover it does quite well. Although this book will NEVER leave my side it is still wrought with problems. First off is the writing style of the author. David's greatest strength is also his biggest weakness. Since he possesses a PhD in mathematics this book is chock full of math equations. Unfortunately, nearly every line of the book is an equation. This is not a book for the faint hearted and one can not casually "jump into" a random chapter. Perhaps he could have targetted as many lay people as industry techs by cutting back on some of the excessive math. Not a problem for me, but for some..... Additionally, he glosses over some topics as if he were running out of pages. His coverage of Portal technology is cursory at best, taking a meager 5 pages of the book. Some topics such as bump mapping, lens flares, and other special effects are mentioned, but barely. Finally, it seems that there are thing that SHOULD have been covered, but were not. There is absolutely no discussion on Subsivision Surfaces (approximated OR interpolated). There's no discussion at all on iso surfaces (metaballs), cloth animation, toon rendering, etc.. Even with all these problems this is must have book. Just bone up on you matrix math, calculus, and algebra. YOU'LL NEED IT.
Rating:
Summary: Doesn't live up to the hype
Review: I purchased this book based on the description and reviews that I had read. I initially believed that I would be able to finally understand some of the concepts that I had read in other books, but upon opening this book I was faced with confusing explanations of simple concepts. Chapter 2 attempts to explain matrices and the standard concept of rotations. I've seen a better explanation in the openGL redbook. He takes a simple concept and uses the most obscure math terms he can to describe it. If I already didn't have a basic grasp of what he was talking about, I would have been completely lost. Anyone who is looking for a book that explains how to write a 3d engine without dumping a bunch of math on you, this book isn't it. If you already know how to write a 3d engine, you don't need this book. If you don't know how to write one, find another book.
Rating:
Summary: trust me
Review: Although i should dedicated more time to writing this, dave has done a good job with this book. he gets straight to the problems. this isn't a "casual" book though, this is the kind of book you wish you had when your publisher is coming over to take a look at how your game is coming a long, and for some odd reason your patches aren't subdividing correctly. there for you really don't want any "fluff", you just want ANSWERS. hehe, anyways, it's a good buy and you won't regret it. let's just say that you will still be using 10 years down the road. problems like collision detection will always be there, and this book is really good for stuff like that. surfaces chapter is really good to btw, there IS _CODE_, and there are _DEMOS_ :) peace, akbar A.
|
