Wheeled Vehicle Down Force

First let me say that I'm really not a programmer, so if there are any obvious blunders, please feel free to tell me.

This is not a proper implementation of downforce. For that you would need to pick a couple points on the front and/or rear of the vehicle model and apply a "downward" force to them. This is much easier as it simply increases the vehicles' gravity as its' speed increases. The first obvious problem this will create is that as the vehicle reaches very high speeds, the downforce will fully compress its' springs, making for a rather bumpy ride. (Though it will still stay stuck to the ground.) To compensate for this I stiffen the springs so the vehicle will still maintain enough of a spring extension to absorb bumps.

First add a new datablock variable so we can control the amount of downforce applied.

In WheeledVehicle.h near the bottom of the definition for WheeledVehicleData add following the sequence variable:

S32 steeringSequence;         // Steering animation

F32 downForce;

Now move into wheeledVehicle.cc.

Initialize the new variable at the bottom of WheeledVehicleData::WheeledVehicleData()

brakeLightSequence = -1;
  downForce = 0.1;

Add a persistent field for it after the brakeTorque in: void WheeledVehicleData::initPersistFields()

addField("downForce", TypeF32, Offset(downForce, WheeledVehicleData));

Now we add it to the datablock pack and unPack methods. If you have not messed with adding variables to the pack/unPack methods, it is important to note that the order in which you pack the variables is the order you must use to unPack them. In this case I chose to add it after brakeTorque.

void WheeledVehicleData::packData(BitStream* stream)

stream->write(brakeTorque);
   
   stream->write(downForce);

Then unPack it.

void WheeledVehicleData::unpackData(BitStream* stream)

stream->read(&brakeTorque);
   
   stream->read(&downForce);

Since I decided to stiffen the springs to compensate for the vehicles extra weight, the calculations must be done early in the updateForces function so it can be used for every wheel/spring combination that has ground contact. Then near the bottom it will be applied to the vehicles gravity.

void WheeledVehicle::updateForces(F32 dt)

Find where the following loop begins...

// Sum up spring and wheel torque forces
   for (Wheel* wheel = mWheel; wheel < wend; wheel++)  {
      if (!wheel->tire || !wheel->spring)
         continue;

Above that insert the following:

//calculate here so we can stiffen the springs a bit based on
   //the final amount of downforce
   //get the speed
   F32 downForce = mRigid.linVelocity.len() <= 1 ? 1 : mRigid.linVelocity.len();
   //grab the datablock var
   downForce *= mDataBlock->downForce;
   //make it a smaller number so we can multiply gravity by it
   downForce = mSqrt(downForce);
   downForce /= 3;
   //ensure that it is not smaller then one, cause mulltiplying gravity by fractions is baaaad
   downForce = downForce < 1 ? 1 : downForce;

// Sum up spring and wheel torque forces
   for (Wheel* wheel = mWheel; wheel < wend; wheel++)  {
      if (!wheel->tire || !wheel->spring)
         continue;

Next, inside the wheel loop find the following:

// Spring force & damping
         F32 spring  = wheel->spring->force * (1 - wheel->extension);

Change to the following:

// Spring force & damping
         F32 spring  = wheel->spring->force * (1 - wheel->extension);
         //Add some stiffness to the springs in accordance with the downforce
         //so we don't bottom out at higher speeds.
         //you can adjust the fraction in the following to stiffen or weaken the springs. Since I am not making a
         //car simulator I have no need to make this adjustable, but it could easily be made a datablock variable
         spring += (spring * downForce) * 0.3f;

Next, to actually apply the extra downforce to the vehicles gravity find:

// Gravity
   mRigid.force += Point3F(0, 0, sWheeledVehicleGravity * mRigid.mass);

Change to:

// Container drag & buoyancy
   //Founder- implement downforce with the gravity to make a nice uniform pressure
   mRigid.force += Point3F(0, 0, (sWheeledVehicleGravity * mRigid.mass) * downForce);

DataBlocks

Now you have a new datablock variable for playing around with the downforce amount. Just slap downforce = x.xx; into a wheeledVehicle datablock and you're set.

A value of 0.01 effectively kills the downforce effect, though if you are very astute you might still notice some downforce at obscenely high speeds.

The most effective range for this is between 0.1 and 1.0, going higher really doesn't gain you much, and if you need it that much higher, you might consider upping the mass of your vehicle.


And now we're done!
My calculations could probably stand some improvements, as they are not based on anything other then achieving numbers that work well for the downforce effect. If you can improve on it, please share.