## Physics For Game Developers 328

*"In my opinion, the most difficult aspect of writing a good 3D game is coding complex physics. If you can take away all the flashy graphics, texture maps, light and shadows from a game, and it's still at least 75% as playable and addictive, then you have an excellent game. But too many programmers seem to be ready to concentrate on the graphics, neglecting the underlying physics which make the game playable. If you compare, say, Re-volt with its fabulously detailed models of remote-controlled cars, and Carmageddon which on the N64 at least has sucky physics, well I know which one I'm still playing."*He's contributed his review (below) of a book intended to help game programmers make games that

*aren't*sucky.

Physics For Game Developers | |

author | David M. Bourg |

pages | 326 |

publisher | O'Reilly |

rating | 8 |

reviewer | Richard Jones |

ISBN | 0-596-00006-5 |

summary | A good introduction to the difficult subject of writing 3D games and simulations with accurate physics, let down by a few minor snags. |

Programmers who want to get serious about game physics will love David M. Bourg's Physics for Game Developers. As I've said, the subject is inherently very difficult, and the book assumes that you are already familiar with vector and matrix arithmetic up to college level, integration and differentiation, and at least you hazily recall your mechanics/physics lessons from school. You also won't be afraid to wade through Bourg's carefully documented derivations of formulae for various physical effects, and his well-commented source code.

The book starts off by recapping the basic concepts of mass, centre of gravity, moment of inertia and inertia tensors. Bourg assumes that you have a working grasp of these subjects, and I admit that I had to go back to some of my A-level mechanics text books. He then goes straight into kinematics, where he uses standard (but forgotten!) integration techniques to calculate velocities from accelerations and positions from velocities. His examples are excellent, although a few exercises wouldn't have gone amiss. The chapter on forces covers a great many different types of forces such as springs and buoyancy, but curiously omits the important subject of contact forces (the normal force that a table, for instance, exerts on your computer monitor to stop it falling through the floor). In fact contact forces don't appear until much later in the book. Particles, rigid bodies and impulses (forces from collisions) are introduced in chapters 4 and 5.

At this point I have to say I was a little bit confused.
What did this have to do with *game* programming?
Everyone knows that games spend most of their time
running round a single big "main loop," working out
the forces on each object, looking for collisions and
working out which keys the user is pressing. It doesn't
seem imaginable that a game programmer could completely
solve all the equations of motion by pure integration at
the beginning of the game, and then just run the
positions of the players through the graphics engine
like a movie!

I already knew a little about this from what I'd found
from the web, but what most games actually do is
calculate all the forces on all the objects (players,
scenery, etc.) in the game, and then integrate them
at each step. Some of these forces will be generated
by human players pressing keys on the keyboard or
wiggling the joystick, and that's how the objects
end up moving. Pure integration isn't usually possible,
so the physics engine performs *numerical integration* -
a kind of fast approximation to the pure "closed form"
solution. Numerical integration is itself a tricky
subject, but it's the meat-and-veg of good game
programming. Surprisingly, numerical integration and
a realistic main loop doesn't appear until chapter
11 (172 pages into the book). I skipped straight
to this section, and I suggest you do so too...

The chapter on numerical integration is excellent and contains the first realistic gaming (or at least simulation) code. Many games I've examined use simple numerical integration, like this:

`
// At each step ... A = acceleration, dt = time step
Vx += Ax * dt;
Vy += Ay * dt;
Sx += Vx * dt;
Sy += Vy * dt;
`

Unfortunately this method (Euler's method) is very inaccurate and unstable: if you tried to simulate planets orbiting around a sun using this method, they'd soon fly off into outer space unrealistically. Bourg gives an excellent introduction to better methods such as the "improved Euler" method and the popular Runge-Kutta method, and he covers them in a context which will make it clear how to use these methods in your own programs.

The book reaches a crescendo with three fully developed simulations: two hovercraft which you can drive around and jolt into each other like bumper cars -- they spin around realistically; a flight simulator; and a 3D car which can be crashed into blocks that bounce around. Again the source code is meticulously commented and generally well written. My only two reservations about the code are: It would be nice if Bourg had chosen to use OpenGL instead of Direct3D so that those of us without regular access to Windows could actually compile and run the examples. The book would make an ideal companion to the OpenGL Red Book. And coming firmly from the Windows camp, Bourg's examples are full of all the horrors of Win32 APIs and Hungarian Notation. But maybe that's just my personal preference :-)

So in summary: **The Bad Points**:

- Measurement systems: Bourg moves uneasily between the English/US system and the European SI units. So we get examples which combine ft/s, meters, slugs and kilograms, uneasily converting between the two. He should have chosen one system and stuck with it.
- A common complaint about computer books: I've
just spent 25 quid on a book which will sit open
on my desk for months. Is it too much to ask that
it be
*ring bound*? - Some subjects are not explained in enough depth. Particularly: moments, contact forces, impulse methods. Bourg should probably have written a chapter or three on collision detection.
- The chapters are presented in a very strange order. Move chapters 6-10 until later, or introduce numerical integration earlier.
- A few of the illustrations are inaccurate.

and **The Good Points**:

- Considerably better than the usual round of maths/physics text books which make up this field. In fact, this is really one of only about 2 or 3 significant books in this area which are pitched for game developers as opposed to mathematicians, and it's certainly the best.
- The areas which are covered are done well, in significant depth, with a good bibliography where you can find out more.
- The commentary on the difficult equations is good, and Bourg resists the temptation to derive many of the formulae he presents, instead referring interested readers to other references.
- Code is well documented and explained.

And now I suppose I have no excuse not to resurrect XRacer :-)

You can purchase Physics for Game Developers at Fatbrain

## Greatest game of all time... (Score:2, Funny)

Is it just me, or does that describe Pong perfectly?

Note: Greatest game of all time referes to the classic version, 2 controls, 1 console, 1 tv, 1 wasted childhood.

## Re:A better book to read for Game Physics... (Score:2, Funny)

## Cartoon Physics (Score:5, Funny)

Physics for: just how long should a character remain suspended after realizing he's in mid-air? We'll need pure math computation methods for ordinary cartoons and numerical methods for interactive cartoon games.CartoonDevelopers## Lara Croft (Score:5, Funny)