Car Physics Demo

Introduction

This is a car driving simulation, based on a small rigid body physics engine that I have written in C++. Drive your car round the circuit, going over the jumps, across the bridge, and around the loop. Try to avoid hitting any cubes.

Update (March 2014): The implementation of Featherstone's algorithm, which I developed as part of this work, is now being used (in a modified form) in the Bullet open-source physics library.

Video

Download

Click here to download the demo zip file (3.6 M)

You may also download the source code (979 K).

Instructions

Unzip the demo and run "car_demo.exe". In the setup dialog, set Rendering System to either OpenGL or Direct3D (it doesn't matter which). You may also want to change the Video Mode, or set Full Screen to "no" to run in windowed mode. Then click OK to start.

Controls

WASD or IJKL keys = Drive car

Arrow keys = Move camera
Right mouse button (drag) = Rotate camera
F1 = Reset camera
F2–F4 = Alternate camera views

Left mouse button = Fire spheres into the scene.

You can also click "Settings" to adjust various parameters, or "Reset Simulation" if you crash and need to restart :)

Hints

Don't try to drive round the corners too fast!

When going over the jumps, release the accelarator once you are in mid-air; otherwise, the car tends to pitch upwards. (This should probably be fixed somehow.)

Notes

This section gives some brief notes on the implementation.

Physics engine features

The "core" of the demo is a physics engine written in C++. It implements the following features:

• Rigid body dynamics simulation, using the standard methods (e.g. symplectic Euler time integration, sequential impulses for constraint solving, etc).
• Featherstone's algorithm for articulated bodies (see below for details).
• Stable stacking (I have not tested huge stacks of blocks, but reasonably-sized stacks are stable).
• Accurate static friction (i.e. block resting on ramp does not slide down).
• Sleeping for inactive bodies.

Please note that I did not implement the collision detection code myself; I instead re-used the collision detection routines from Bullet. However, all of the actual physics simulation and constraint solving code is my own work (i.e. the only component taken from Bullet was their collision detection library).

Car

A physics engine by itself is fairly boring, so I decided to implement a simple car, along with a "race track" for it to drive around. The car is modelled as follows:

• Car body is modelled as a cuboid
• Wheels are modelled as cylinders, mounted on springs (to simulate suspension)
• Engine and brakes are modelled by applying torques to the wheels
• Steering is modelled by mounting the front wheels on a revolute joint, which rotates when the steering keys are pressed.

All car joints are simulated using generalized coordinates and Featherstone's algorithm.

Bridge

The demo also contains a "rope bridge" as an example of a complex multi-jointed object. This is composed of 10 rectangular "planks" which are connected by revolute joints. It is simulated using Featherstone's algorithm together with an additional position constraint on the final plank.

Notes on Featherstone's algorithm

Featherstone's algorithm is a method that allows articulated bodies (such as the car and the bridge) to be represented using generalized coordinates. So, for example, the bridge's position is represented by ten scalars (the joint angles), as opposed to ten vectors (positions) and ten quaternions (orientations).

The main advantage of doing this is that it is impossible for joints to "break apart"; for example, a state where the bridge planks have separated from one another is simply not possible in the generalized coordinates representation.

The disadvantage is that the algorithm is somewhat complex to implement. For this reason it is not usually implemented in game physics engines. However, I was curious to see how it would work out, so I decided to implement it in my code.

An excellent explanation of Featherstone's algorithm can be found in Brian Mirtich's thesis, "Impulse-based Dynamic Simulation of Rigid Body Systems" (see chapter 4).

Open source libraries used

The core physics engine is my own code, but other components used open source libraries, as follows:

• Bullet – some of their collision detection routines were used (as explained above).
• OGRE – for graphics rendering.
• Eigen – for vector/matrix calculations.

Limitations

The physics engine implemented in this demo is not perfect, and has several limitations, for example:

• Currently there is no distinction between static and dynamic friction (so wheels do not "lose grip" when slipping, as they would in real life).
• Car engine/transmission is not simulated in detail (instead the "engine" just applies a constant torque to the wheels).
• Car wheel collisions are detected using ray casting so may not be completely accurate. (However, this has not proved to be much of a problem in practice.)
  • An attempt was made to use the Bullet cylinder primitive for the wheels, but it was found that this gave inaccurate collision normals resulting in unrealistically "bumpy" motion.
• Parameter values used (such as car mass, car size/shape, air resistance etc) are not particularly realistic.
• Code is not fully optimized.
• As with many physics engines, this one tends to suffer instabilities when a heavy object is placed on top of a light object. This affects the car demo in that the car wheels had to be made a lot heavier (relative to the car body) than they would be in real life, in order to prevent this instability.

Copyright

The demo is copyright (C) Stephen Thompson, 2011.

The Car Physics Demo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

The Demo is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

The text of the GPL can be viewed here: https://www.gnu.org/licenses/gpl.html, or alternatively a copy can be found within the demo zip files (see "Downloads" above).

(Please note: I also gave special permission for the Bullet project to use my code without needing to abide by the GPL. So if you are using my code indirectly via the Bullet library, then you only have to comply with the Bullet licence, and not the GPL.)