Customer Reviews

Physics for Game Developers

5 star:		(8)
4 star:		(8)
3 star:		(9)
2 star:		(3)
1 star:		(1)

 

 

This book provides a good starting point for anyone looking to introduce more realistic physics into their game. It provides an overview of the laws of mechanics, focusing on rigid body and particle dynamics. It then takes these principles and applies them to specific simulations which often come up in games, such as projectiles, cars, airplanes, and hovercraft. The math is simplified, so the results are not always completely accurate, but they should be good enough for many games.

The book does have several shortcomings which prevent it from being a great book, the most important of which is that the content is fairly limited. It's less than 300 pages, and a significant amount of space (especially in the later chapters) is taken by source code listings. Of course, this is somewhat offset by the book's relatively low price.

If you buy this expecting it to be the ultimate guide to physics in games, you'll be disappointed. However, if you buy it as an introduction to physics in games (which how it's intended to be used), I think you'll be happy with it.

David gives an overview to basic physical and numerical principles and than describes the forces occuring in a couple of typical systems: projectiles, planes, ships, hovercrafts, cars. After that some issues on collision detection, integration and many-body-system are discussed.

The overall mathematical level is 'easy'.
David does not dig deeper into mechanics than it is necessary for a game.

The book is usefull for a beginner but also deserves the 'knowing' as a good cookbook for the games-level.

It would probably not be impossible to learn the physics you need for your game simulation from this book, but it would be difficult. The presentation often lacks much physical insight. This may be intentional as to make the book read easier to a non-specialist, but I think it is a mistake.

As an example, the simple trajectory problem, launch a particle in constant acceleration with no friction, is presented here as four separate problems; launch a particle with target at same height, launch a particle with target higher, launch a particle with target lower and launch a particle horizontally with target lower. No physicist would approach the problem this way, it is absolutely trivial to present them all as the same problem with the same general solution.

Occasionally the book lapses with just outright errors. The most serious so far I've seen is the cylinder rolling down a plane without slipping is solved by assuming the frictional force is the static coefficient of friction times the normal force. In fact, the force can be any amount less then this. As a result the solution given has the funny property that it will roll up the plane for small angles.

The book isn't all bad, and may well serve it's primary purpose, which I assume, is to give a litany of examples that game developers may paste into their games. It certainly has lots of examples, and most are correct physics, still, perhaps with my bias as a physics professor, I was hoping for a bit more physical insight into the problems.

The book does a startlingly good job of covering many areas of game programming that benefit from physics including projectiles, vehicles, and other solid bodies. Some more advanced concepts like fuel burnoff, body shape, and simulation in real time add to the usability of the book.

One of the biggest problems with the text is that if your going to jump into a single chapter and code up a sample of just the object being talked about your going to be okay. However, if your going to be deriving your own code and objects based on the material in the book your going to find yourself having a hard time.

A great example lies in the first chapter which derives formulas for working with a car, with a fuel tank and driver. Now, first off, the author implements 0 source code for the functions shown in the book. This leaves you as the reader to develop your own functions and test things out, possibly by adding another driver, or implementing a generic method for defining composite bodies. If your technically proficient enough to do this, you'll use the numbers provided to test your code. What do you find? Well, that the numbers the author put in the book are wrong.

Since the book is based on precise math and physics, this type of slip-up, especially in a prime example (its the major example for the first chapter), is killer in terms of my trust in the books content.

Still, I do recommend buying the book, just prepare yourself for the technical inconsistencies.

This book is superb in his examples for anyone who understands 3-d programming but is lacking physics in there game. I took his chapter 17 flag example and ported the code into my 3-d engine. It worked perfectly . I have boats in my game but could not get them to move realistically. I am know porting his rigid body and collision chapters into my game. To be fair I have graduated from mechanical engineering and KNow the concepts of momentia inertia, angular velocity,drag,vectors etc. This is a must for this book. I hope to have airplanes flying in my game from his book examples.

What I am praising is his physics examples. I do not care about units or language choice which seems to be a complaint. From his book I can add reality in terms of physics which I could not find in any other book.

If you're a physicist or aspiring to be one, then this book is not for you. If you are a game programmer then get it. The book cuts right to the chase and specifically focuses on rigid body mechanics, which is what you need to know in order to write realtime simulations for games, without pontificating on too much theoretical stuff.

The book reads easily and all the example code is well documented. While the examples use Windows Direct3D, all the physics/simulation code is separate from the GUI code so it's easy to follow.

I'd have given this book 5 stars instead of 4 if it weren't for two things:

1) the example code uses Windows (I'm a Mac developer and would, of course, rather see Mac examples); however, like I said, the physics part of the code is standard (c++).

2) the chapters are ordered strangely. I suggest you read the first few chapters (1 - 5) and then skip right to chapters 11-17 to get into the realtime sim. examples. The other chapters are interesting, but can wait until after you've finished chapters 11 - 17.

Maybe a future edition will include Mac examples and reorgainze the chapters, but, all in all, this is a good book.

I would have rated this book as great, but:

1 - Why in the name of everything that is good and wholesome would anyone use imperial units when writing about physics?

2 - The code in the examples is appallingly bad. There are abundant global variables, poor comments etc...

For really, really small objects, Newton's laws of motion don't apply (that's why we have Quantum mechanics and the like.) For everything else, we follow Sir Issac. If you're a game developer, you'll need more than a rudimentary understanding of physics if your aim is realism. David M. Bourg's most recent book covers the theory you'll need to polish your game while keeping it "real."

Inside the covers, you'll discover a review of Newton's laws accompanied by a hearty dose of explanatory graphics. Warning: as a prerequisite, he assumes solid math and basic intro college physics skills. Next, he segues into Kinematics, you know, the underlying mechanics of motion of objects.) He teaches linear and angular displacement, velocity and acceleration. Don't worry, it's not all equations and graphs, he includes helpful sample code (in C) too.

The final chapters cover advanced topics like 3D rigid body simulators and rotations, collision response and particle systems. Before you reach those chapters however, Bourg covers specific examples for projectiles, aircraft, ships, hovercraft and cars.

With the advancement in speed and power of today's microcomputers, achieving reality in games is certainly possible. Bourg's book helps you achieve that without having to spend days in the library pouring over college physics texts. This book is a sound physics review and very well written for the gaming professional.

If you wish to add more realistic environment interaction or object behavior to your games, you will benefit from this book. This book is much better for beginners than more recent books on the subject that maybe talk in more detail about game physics, but do so from the standpoint of some specific physics engine that the author has put together. I have personally lifted several pieces of code from this book, adapted them to Java, and placed them in a multimedia application I have been writing with no trouble. The book goes over the basics of adapting Newtonian physics to games, and then uses these ideas to set up the motion of simple projectiles, cars, hovercraft, and ships. 3D issues are also discussed at length.
To be sure, you do not need to be a physics expert to learn something from this book, but it is assumed that you have a basic level of understanding of classical physics. Anyone who has taken high school or college level physics should have no trouble understanding the material. You should also be proficient in trigonometry and vector and matrix mathematics. Certain topics in calculus are also discussed, so some degree of familiarity would be useful, but is not required. However, a strong C++ programming background is required if you are to tackle integration of a physics system into your existing game engine. This book is a great starting point for readers who aspire to understand "Game Physics" by Eberly, which is far more advanced and academic in tone.
I shall talk about the details of the book in the context of its table of contents:
PART 1 - MECHANICS PRIMER
This consists of chapters 1 through 5 and starts out with simple concepts such as Newton's laws and builds up until you get to rigid body dynamics. If you are already are up to speed on mechanics, you can skip these chapters.
PART 2 - REAL-WORLD EXAMPLES
Chapters 6 through 10 focus on modeling so that you have a solid understanding of the nature of certain physical systems. The craft selected were chosen because they best illustrate the specific physical phenomenon and concepts that are relevant to a wide variety of problems. The systems modeled are projectiles, aircraft, ships, hovercraft, and automobiles.
PART 3 - REAL-TIME SIMULATION
This field is discussed as it applies to games in chapters 11 through 17. These chapters focus on the fundamentals by walking through the development of the 2D simulation of hovercraft, a 3D flight simulation, a generic multibody simulation in 3D with collision response, and a simulation of cloth using particles and springs.
The appendices show implementations in C++ of classes for vector operations, matrix operations, and quaternion operations. The book's bibliography provides information sources for mechanics, mathematics, and specific technical subjects such as aerodynamics. All of the code for the book can be downloaded from the book's website at O'Reilly and Associates. I highly recommend this fun and comprehensive book for anyone getting started in adding physics to game programs.

This book had a few disappointments. The biggest was that it uses imperial units for everything (prepare for feet per second, pounds per square inch, etc). It could be improved a hundredfold by using normal SI metric units.

The second was possibly more an issue of having the wrong expectations of the book. Although it discusses issues such as collision response (the actual physics), it does not describe the actual collision detection.

The examples in this book are all written for the Windows API, rather than using a cross-platform API such as SDL. As a result, they cannot be compiled on Linux or any other platform (eg. MacOS X).

At times I felt that it was too mathematically oriented. It would do better if it explained the techniques in source code more often. Sometimes I wondered if it was really just a mechanics textbook trying to be something more.