Customer Reviews

Real-Time Collision Detection (The Morgan Kaufmann Series in Interactive 3-D Technology)

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

 

 

Let me state in the most emphatic terms--this book contains the very best discussion on spatial indexing and querying ever written. If you have an algorithm which is spending too much time querying in quad trees, then you need to buy this book and read it until you become one with it.

It should be pointed out that this book will be useful not just for game programmers but also for other programmers who do a lot of computational geometry. EDA programmers, VLSI, CAD programmers, etc, rejoice.

I disagree with a previous reviewer who is complaining about lack of source code, etc. The author provides good C++ implementations of his algorithms and provides very clear descriptions of them. The author is holding up his end of the bargan--if you arn't a computational Jedi knight of space and time after reading this book, the fault isn't in the efforts of the author, its in the efforts of the reader.

Don't worry about how expensive the book is. I've used it on the job and it has already paid for itself many times over.

This book has great depth and breadth. It covers narrow phase, broad phase, and optimization. It has more coverage of broad phase and optimization than I have seen in any other book. Also, the bibliography is quite extensive, with many entries containing links to pdf files.

What I really appreciate about this book is the vectorized approach. Many algorithms are derived and implemented in a vectorized form. This not only improves readability, but also makes them efficient for modern SIMD architectures.

I have found this book to be invaluable in my day to day work. I highly recommend this book.

Christer has done an amazing job of completely covering a large topic. Anyone writing collision detection systems for games (or other real-time apps) needn't look any further than this book.

It's also full of things even non CD System writers will find handy, such as optimal intersection tests (Chapter 5)

And, in the end (Chapter 13), he includes a number of great optimization techniques.

Overall, this is great as both educational and reference. It's got a permanent spot on my bookshelf.

Highly recommended!

Solid theory coupled with the author's own practical experience makes this book an excellent choice for practitioners in the field. In addition to describing a wide range of relevant algorithms, the author also discusses optimization, numerical precision, robustness, and other topics critical in creating a workable interactive system.

As far as code goes, (a) there are a lot of libraries out there already (see the "Real-Time Rendering" site for links), and (b) it's probably better to write your own if you're poor, and thereby know its strengths and weaknesses, or license Havok's if you're rich. This is the book that will help you write your own. I love Schneider and Eberly's "Geometric Tools", but this book is more focused and more readable.

This book does more than collision.

Don't get me wrong -- it does all of the collision you'll likely need in any kind of current game, in good detail, with derivation of why it works, including source code. However, it also serves as an excellent primer in game geometry for anyone who might not have an intuitive understanding of what a closed manifold mesh is, or why the separating axis theorem works, or why T junctions are a problem.

I'm pretty well versed in the field, and I use this book as a comprehensive reference, and I love it. But even if you're a newcomer, you need this book, because it contains everything you need to know! And, conversely, if you don't know what's in this book, you won't have the success you want.

For such difficult topics, this book is surprisingly readable, accessible, and has plenty of source code to get you started. It also has one of the best sections I have ever seen about floating point accuracy and numerical stability. In addition, it has some of the best coverage of BSP trees, KDE trees, and other spatial organization. That alone makes it worth the price of the book.

Also, the book has a great bibliography that directs you to more advanced papers should you need something specialized. And finally, you do not have to be a genius to work through the algorithms. Anyone with a basic knowledge of vector algebra and a little linear algebra can work through the algorithms, if you are diligent and persistent. As a professional 3D programmer new to my field, I find it a great plus whenever I come across a resource that can save time in such an in-depth field.

I've read MANY collision detection books over the years and this is by far the best one i've seen to teach programmers how to LEARN collision detection from basic tests to highly advanced algorithms.

The physics in the book is simple. Elementary kinematics. Something often taught at the first year undergraduate level. But the book goes far further into its specialised need than you are likely to see in a physics text. Many computer games that rely on real time feedback need fast ways to see if two or three dimensional objects collide. Because then, some involved interaction must occur.

In essence, the book deals with simulations of moving bodies, where you time step Newton's equations. Much of the book becomes an excursion into linear algebra, as we seek to find if various geometric objects intersect. There are important special cases, like when a moving sphere hits another sphere.

The numerical computations, or, more specifically, the efficiency with which they can be found, is also important and discussed.

Many other topics are also studied. There is a surprising amount of depth in this field.

Two things stand out about this author: 1) he drives every discussion toward performance issues, and 2) he provides just enough source code for a developer like me to lock in the concepts. That's a great combo that makes this book a hands-down winner.

I've never worked in gaming. I've been doing CAD/CAE/CAM, mostly with Java and CATIA v4 / STEP data, for ten years. I'm currently involved in a robotics planning project, where I've been able to model all the kinematics of an 8-DOF robot system, but the scale of the collision detection challenges has overwhelmed me...until reading this book.

If I had to judge this book by its cover, I would have to give it three stars; although the binding is functional, it's one of the ugliest book covers I can remember. Yet the contents between the two covers is splendid, the language is clear, the grammar is correct, and I found not even one spelling mistake.

This book is well-indexed, which makes perfect sense as much of its content is about finding items. I haven't failed to find something I wanted quickly or to locate something I previously read. Citations are well-annotated, and they are complete enough that he cited someone I used to live in the same building with within my first two hours of reading. There are abundant well-drawn figures, and they usually display a high level of helpfulness.

How long does it take to read the entire contents? For me, about ten hours. I am no career mathematician, but I have been writing code nearly three decades and presently writing my third ray tracer. Naturally one can skip through sections where more detail is offered than needed at the time one is reading, but be cautious about this. Some of my most productive reading came from a chapter I didn't plan to (and still don't plan to) need to use.

As a full table of contents for this book is available elsewhere on the Internet, I won't summarize it here--except to say that when I was the table of contents, I ordered the book immediately and had it delivered the next day, which was a Saturday. I started reading Monday and finished Tuesday, and my time and money were well invested.

As I learned to optimize software more than twenty years ago, an unexpected benefit of this book was a lengthy discussion of how to exploit more contemporary hardware and languages, where the effects such as caching, pipelining, and aliasing must be considered, or a terrible drop in performance can result. Sometimes it's good to read some newer material.

Once in a great while, diagram conventions get distracting and require some unscrambling. For example, a diagram showing Andrew's algorithm for computing complex hulls defines "left" and "right" for an edge exactly opposite the reader's perspective. Another example, some binary search trees have their nodes labeled using sequential letters, where the labels indicated have nothing to do with the keys for each node. To one used to seeing nodes of trees marked with their contents, these figures appear at first glance to be incorrect. While they are not incorrect, I find that this choice of labeling is confusing and disrupts the continuity of reading.

The text is almost always perfectly clear and makes everything very simple. The only exception I noticed was the fourth sentence of the chapter "Convexity-based methods". That particular sentence needs a rewrite from scratch, although reading the rest of the paragraph permits one to recover the author's intent.

I didn't even break the seal on the enclosed CD. There is text in the book to say the CD contains the code fragments from the book, with absolutely no additions or other material. Even if it had other material, I still might not open it.

If I had to give this book a letter grade, it would definitely be an A+, although several friends who don't write code seem less enthusiastic about this particular volume.

Update 5 Nov 2010: I think the denominator in DistPointPlane() on page 127 needs a square root around it, but it's not in the errata yet. I'll email the author.