Game Physics Engine Development 2nd Edition

This book is an excellent, practical introduction to game physics engine developers. The goals is to take a good programmer [and 3D engine/game developer] with little or no physics experience, and help him upgrade his 3D engine from "no physics" to "modest physics". Thus the book covers the most fundamental and important types of physics for most games, but omits most niche or highly advanced [special purpose] physics.The great strength of this book is the near absense of "arm waving". The types of physics this book covers are covered more-or-less completely, and implemented in the code that can be downloaded and inspected.In most 3D books, and especially "physics engine" books, the author discusses each issue more-or-less independently, and in varying levels of detail (for his convenience), then leaves the reader to figure out how to effectively implement the details of the technique, and worse, to encounter and deal with the many practical tradeoffs and gotchas on his own.In contrast, this author discusses each issue in exactly as much depth and detail as necessary to implement code that works, and deals with practical tradeoffs, gotchas, and integration with the rest of the engine. This makes the book far more helpful for programmers who are not scientists or not very familiar with newtonian-style physics.Frankly, I'd love for this book to have a "second half" that revisits each level at a higher, more advanced and/or more abstract level, plus discusses many niche/specialty types of physics for game engines. However, the author and publisher leave the Eberly "game physics" book to satisfy that desire. The Eberly game physics book is also excellent, but suffers from the common "weaknesses" that I mention this book does not suffer from. On the other hand, "weakness" is a relative term --- the Eberly book may be written in a perfectly fine manner for scientists, physicists, and especially math wizards (or at least highly comfortable with advanced mathematics).This book does have a few weaknesses.It fills far too many lines and pages with same source-code. The problem is not that he includes source-code, that much is fine. The problem is, most of the source-code he includes in the text of the book contains lengthy comments that simply repeat what we just read in the body of the text. This wastes a LOT of space, pushes related paragraphs onto separate pages where they are more difficult to glance back and forth to compare, and makes the few lines of actual code difficult to locate visually between the lengthy comment blocks. He should omit most if not all these comments, then the source-code would make a substantial contribution to the book, rather than mostly just be annoying.I found a few errors in the book, but so far have not found errata anywhere (for example, on the [...] website).I also have not yet found a forum dedicated to this book and the physics engine it implements. This would make it a lot easier for readers to get quick, easy answers to questions, confusions, errata, etc.While the author carefully explained his notation, he would have been better served to adopt the simplest notation possible for this book aimed at the minimally math-savvy audience the book is otherwise so perfectly written for. I mean, is there any reason we must read f = mp (with two dots over the p) instead of f = ma ??? It is as-if "v" for "velocity" and "a" for "acceleration" are x-rated words, and this is a PG book... or something. Elsewhere the author wisely adopted the most clear, simple ways to express his ideas and the math. He should have stuck to that principle. Alternatively, almost everywhere he had plenty of room to state each equation in both forms. This would have been a great service to less math-savvy readers, as seeing equivalent forms side-by-side repeatly is a great way to become comfortable with more advanced symbology and formulation.Bottom line: The strengths of this book are far greater and more precious and rare than the weaknesses. Everyone trying to implement a physics engine should buy this book. However, physics engines are chock full of subtle issues, niche fields, gotchas and quirks, anyone who actually implements one should get every recent (less than ~7 years old) book and PDF, and read everything, and keep them around for reference, comparisions, and varied presentation.

Let's first say that I've seen my fair share of physics literature. I've pored over papers, tutorials, etc. with little to show beyond some simple collisions between spheres. What I really wanted to implement was something ideally "not" much more difficult: a rigid body simulation with simple primitives (spheres, boxes, planes) that collide and interact with each other, giving a realistic enough feel to build a game around.Unfortunately, even this idea is extremely complex and difficult to implement. You would think the math and code would be fairly easy, and it actually is (depending on your math background. A few semesters of college calculus and physics is very helpful, but not required). But programming a physics engine is 40% math and physics and 60% being clever enough to get the computer to do what you want. Floating point errors, inaccuracies in integration and bugs you can't even imagine from the start all mess with your beautiful equations.And this is where the author, Ian Millington, saves the day with this great book. All throughout, he lays down the challenges of building a physics engine and gives you realistic solutions that are explained very well. You build from the ground up: from a simple particle engine, to a mass aggregate physics engine, all the way to a full blown physics engine. Each chapter he describes what algorithms you need to implement and variations on those algorithms, providing pros and cons for each. I cannot TELL you how fantastic it feels to have an author tell you in an honest tone: here's where this works, here's where it doesn't. Never at any time do you feel that things are being hid behind a curtain of intellect and egomania. And if the author does hide any details, he tells you and with good reason.In the end, if you plow through all 20 chapters with diligence and fortitude, you're going to end up with a working physics engine. It will be a physics engine capable of a lot of very cool things, but it isn't a finished product. And the author makes it very clear throughout the book that you will not end up with a spit polished physics engine to compete with the likes of Havok. It will be rough on the edges with plenty of room for improvement, but it gets the job done. The author helps you create a working model and leaves you with many options on how to improvement. However, those options require much more advanced coding.This book provided me with exactly what I was looking for: the know-how and experience to create a physics engine for the everyday game designer. I highly recommend it. If you want to create something commercial, this is a great start, but you're going to have to buy some heavier books on top of this one if you want a very robust, optimized engine.

Gives a full tour through building a working physics engine, so it's really useful if you're getting started. However, it may feel a bit slow if you have a physics background, as this is intended at a more introductory level. The author hints at more advanced topics, such as alternative collision resolution techniques and optimization techniques, but doesn't go into detail. That said, the book does give a fully working engine, which counts for a lot.Overall a solid foundation, but you may want to supplement with more advanced materials.

Viele Beispiele, wie man physikalische Problemstellungen in einer eigenen Software lösen kann.

Ottimo testo di riferimento per l'implementazione di un engine fisico. Cura in particolar modo gli aspetti pratici, fornendo sempre il codice completo stampato, rimandando al codice fornito online solo in rari casi ovvi o, al contrario, troppo contorti. Attenzione però, di questo testo in genere si leggono recensioni di gente che lo consiglia come primo testo sull'argomento. La cosa non mi trova d'accordo. La parte matematica, purtroppo, è solo messa lì per dire questa è la formula, ora vediamo come implementarla in codice o come adattarla. Quindi, a meno che uno non abbia già una discreta conoscenza teorica di base, non lo consiglio come primo testo ma, piuttosto, come testo di riferimento pratico quando si deve andare ad implementare l'engine vero e proprio.

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.AnywayThis 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 PERSONPerhaps 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.

I found this book very useful when I was writing my game engine

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!