Learn more Download now Shop now Shop now Shop now Shop now Shop now Shop now Shop now Shop now Learn More Shop now Learn more Shop Fire Shop Kindle Amazon Music Unlimited for Family Learn more Shop now Learn more

on 17 November 2014
I found this book very useful when I was writing my game engine
0Comment|Was this review helpful to you? Report abuse
on 12 November 2010
I admit my initial review was perhaps a tad harsh so I reviewed my review and added a star to my rating. Putting myself back to the mindset of a beginner in this field, the book is useful by covering the essential elements of building a physics engine (and why you should not do that, e.g. when all you want to do is a physics simulation of a single isolated phenomenon). However, the code provided is marred with inconsistencies and in particular, rather poor object oriented programming practice, i.e. class variables are often set public, whereas these should all be encapsulated and be accessed by 'accessor' methods and modified by 'mutator' methods. Before I purchased the book I was interested in the additional sections of the new edition, in particular the Jacobian, then to find out it is merely a section without maths or any other useful description about the main tool for resolving articulated constructions (like humanoid characters) using forward and inverse kinematics. The only interesting part in that aspect is a reference to the open-source ODE (Open Dynamics Engine) software (not for me though as I already know ODE). In summary, for readers of a basic skill level it will be useful but the poor OOP practice plus numerous typos need to be addressed, as well as adding some more advanced material so more experienced readers get something out of it. I hope Mr. Millington takes this on board so the next edition will be worthy of five stars!
22 Comments| One person found this helpful. Was this review helpful to you? Report abuse
on 6 January 2012
I must admit I am somewhat confused as to the reviews this book has gotten so far. However, this is likely because I am using the book differently to others.

For my purposes this books has been everything I need. I got the book at Christmas and now have a pretty good foundation 2D physics engine for my game engine (this book primarily covers 3D, but coversion to 2D is relatively simple, and the maths is easier. there is even a chapter on what you need to convert!)

Firstly, I am a physics graduate with a number of years (10+?) of hobbyist programming behind me. My language of choice (due to targeting Windows Phone platform) is currently C#. I can programme in others, including C++.

This book walks you through the steps required to start building YOUR OWN physics engine. I did not copy any code in the book. This book is fantastic for highlighting a possible structure for a physics engine (mine is radically different in actual implementation), as well as what you need to implement and watch out for. At every step, the relative merits and drawbacks of methods are discussed (with reference to further texts) with good insight into uses and limitations of the engine at each step.

I therefore cannot comment on the ability of the source code to run, or its programming practices. The comment I will make is that the author in a number of places advises that the code in the book has been arranged for readability rather than performance. Im not sure how that translates to the downloadable code.


This book is fantastic if you:
1. Mathematically literate to A-level. A good conceptual grasp of what calculus is all about helps with understanding the position -> velocity -> acceleration equations.
2. Need to build your own physics engine, understand the sort of laws you need to implement, but are unsure how you should approach the various parts.

I have bought many many programming / computer books over the years. Most of them recently were XNA or graphics programming related. I am almost always dissapointed, scratch that, I am ALWAYS dissapointed. THIS book has been Gold Dust from page one to the very end. I cannot stress that enough.

Writing a physics engine is actually the combination of a collision detection system (broken into seperate parts), a collision resolver and then a rigid body physics engine part on top. As there are a number of seperate systems, it leads to times whereby you are writing functions that will interact with later functions. This is why other people have commented to referencing unimplemented functions. It would be an absolute clusterf* if it was not structured that way.

How I used the book: I spent boxing day reading this book cover to cover, so in my head I could then plan my engine, taking into account the key takeaways I had. I then built my physics engine whilst slowly flipping through the book as reference.

This is the first time (I think) ive ever bothered with such a review. I can't recommend this enough, TO THE RIGHT PERSON

Perhaps I am biased, I came to this understanding all the concepts and mathematics involved (that's a lie, i had never heard of seperating axis test, i mean more the general maths / physics concepts and techniques). However...I will say this. Although I ended up in 2D, this has by far the clearest practical explaination of Quaternion use in 3d graphics I have ever read. I think the text explanation of concepts is generally very good. But again, its always easier if you know the subject a little already :)

Big Rant, Big Ramble. Buy this book (if it's for you).

I randomly bought a book on AI programming recently that i havent read yet, was pleasantly supised that to find its the same author so i look forward to that.
0Comment| 4 people found this helpful. Was this review helpful to you? Report abuse
on 8 October 2011
The uncompromising truth about this book.

You will not build a Robust Commercial Grade Physics Engine with this book
(2nd edition) without Additional work.
Reason, There are so many mistakes, errors, flawed codes and lacking of
supporting maths at later pages. It's unprofessional! Over 90 pages in this book have errors and flaw codes of some sort. It's unbelievable that all those professional rewiewers of the 1st edition did not spot the mistakes in this book before it went to press.

You will need to download and read the full listings of the code and demo code to understand how the engine is put together. But unfortunately some of the code written in the book is missing from the full listing (the latest download) One of many examples, page 330 of the 2nd edition.

It possible to build a limited physics engine without reading the full listing and just read the book alone, but you will not understand how certain elements are put together, thus compromising developing a better engine than if you did.

This book is badly organised just like its source code taken from different sources.
The evidents is in the code itself, in the book as well as in the full listing.


Be aware that this is a Badly organised book, flaw codes, full of errors, lacking supporting maths.
You are going to double your time in reading this book just to correct all the errors in it - this includes the appendix.
11 Comment| One person found this helpful. Was this review helpful to you? Report abuse
on 13 June 2013
I got this book recently as a gift (I know I'm a geek) and found it not only to be useful but also (remarkably) quite an interesting read that I read from cover to cover without feeling "bogged down" in it. This book starts from very little assumed knowledge (for example vectors are explained) but quickly builds up to some quite advanced concepts. I have a degree in physics but I think I would classify that as useful rather than essential for this book to be useful to you. A decent background in programming is probably essential but not necessarily C++ (the books language of choice)

Text books can in general be split into two groups, those that are mathematically rigorous to the expense of clarity and those that are actually useful. This book definitely falls into latter category; and is better for it.

I am a java programmer with no experience of C++ however the book (which is C++ focused) remained very useful with the supplied code being supplemental to the text section rather than being essential. However, the code that I did read was clear with expressive variable names and clear logic.

Other reviewers have commented that the collision detection chapter is weak and I have to agree; if that is your main difficulty then this book may not be for you. However collision detection is quite self-contained; separated out from the rest of a physics engine so you can plug in whatever collision detection you like. For me this was fine as in my previous "less than satisfactory" attempts at physics engines the collision detection was the only part that was good and I just slotted in the old collision detection into the new engine. I would also warn (if you don't read the book from cover to cover) that the author has used operator overloading; be aware that % has been used for the cross product, not the more usual modulus operator.

Very little is glossed over in this book; for example a whole chapter (and several separate sections) are dedicated to stability (i.e. sorting the problems of vibrations at rest that plague physics engines). Not to mention that a complete engine written based on the concepts of this book is linked to on the internet so if anything is ever unclear (not that it really is) you can go and look at the complete source code to see exactly how it was done).

In conclusion; I have written 3 physics engines, the first let things fall through each other occasionally, the second sort of worked but everything vibrated at rest and behaved strangely sometimes, the third, written with this books help, just works. I can thoroughly recommend this book
0Comment| 4 people found this helpful. Was this review helpful to you? Report abuse
on 20 July 2014
0Comment|Was this review helpful to you? Report abuse
on 30 June 2011
All in all, it was a decent introduction to physics programming. Having done A-level physics & maths barely anything new was introduced so the physics principles were faily straighforward. It was the programming that was quite tricky at times. Being a C# beginner-ish level, converting from C++ was faily easy (when combined with a bit of googling).
I highly recommended you have already programmed a basic 3D engine.
The first half of the book was quite clear and there was no need to look up any source code online. However, the reason for only 2 stars is the second half of the book. Big corners were cut. Concepts were explained without any code to go with it. Where there was code, methods/functions were often added yet not meated out until much later, meaning going through many chapters with just plain reading and coding without being able to test your engine (easily). Bits of code is dotted around and its rarely clear whether you're suppose to include that code, or where in the engine it should be placed. The most tricky part of the book, and the one I was most interested in learning, was collision detection. And this was the part where the most corners were cut. In the end, and really disappointingly, I've ended up having to copy and paste these sections of the source code from online (and re-writing to C#). If you do this you'll often find methods/functions that weren't covered in the book yet were fundamental to the engine.
If you're a good programmer you may get alot more out of this book. A good introduction but if you're interested in collision detection for rigid bodies, I really can't recommend this book.
0Comment| 7 people found this helpful. Was this review helpful to you? Report abuse
on 31 October 2011
As a games development student with an interest in physics in the real world I wanted to see how it would work in games, so I bought this book.

When I read the 1st and second chapter I was confused, more me than the book alot of info to take in, but when I was coding it I noticed some problems with the class members being public, this is bad practice, should have a accessor function, but moving off my main point.

During the 3rd chapter it shows a function but there is another function call in there to a function that hasn't been written into the code so this just calls a non-existent function that seems to be necessary.

Little disappointed with the book.
0Comment| One person found this helpful. Was this review helpful to you? Report abuse

Sponsored Links

  (What is this?)