332 lines
18 KiB
C++
332 lines
18 KiB
C++
/// splendid tutorial by RedPhoenix could be found at
|
|
/// http://forums.bistudio.com/showthread.php?165390-Tutorial-Creating-Custom-Engine-Gearbox-and-Suspension-Vehicle-configuration
|
|
|
|
thrustDelay = 0.2; /// initial delay to cause lesser slip when on 1st gear - thrust goes from zero to full in this time
|
|
brakeIdleSpeed = 1.78; /// under what speed (in m/s) does the brake apply for a vehicle without thrust
|
|
maxSpeed = 150; /// vehicle can go a bit over, but dramatically decreases thrust
|
|
fuelCapacity = 20;
|
|
wheelCircumference = 2.607; /// diameter of 725 Measured diameter 0.830m so wheelCircumference = 2.607;
|
|
|
|
antiRollbarForceCoef = 1.9; /// how strong is the anti-roll bar of vehicle preventing it to lose grip in turns (not any magical stuff, real ARB)
|
|
antiRollbarForceLimit = 24; /// highest possible force of ARB
|
|
antiRollbarSpeedMin = 30; /// the roll bar force gets from zero to full in range of min and max speed
|
|
antiRollbarSpeedMax = 150; /// this simulates losing grip at high speed turns
|
|
|
|
/// Gearbox and transmission via PhysX
|
|
idleRpm = 900; // RPM at which the engine idles.
|
|
redRpm = 6900; // RPM at which the engine redlines.
|
|
|
|
class complexGearbox
|
|
{
|
|
GearboxRatios[] = {"R1",-3.231,"N",0,"D1",2.462,"D2",1.870,"D3",1.241,"D4",0.970,"D5",0.711};
|
|
TransmissionRatios[] = {"High",4.111}; // Optional: defines transmission ratios (for example, High and Low range as commonly found in offroad vehicles)
|
|
gearBoxMode = "auto"; //gearbox can be of type: full-auto (only requires 'W' or 'S'), auto (requires shift between drive and reverse), semi-auto, manual
|
|
moveOffGear = 1; // defines what gear an automatic or semi-automatic gearbox will move off from stationary in. 1 by default.
|
|
driveString = "D"; // string to display in the HUD for forward gears.
|
|
neutralString = "N"; // string to display in the HUD for neutral gear.
|
|
reverseString = "R"; // string to display in the HUD for reverse gears.
|
|
|
|
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/// PhysX parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// <Description>: Defines simulation type of the vehicle. PhysX simulation ends with letter "x", "carx", "tankx" ...
|
|
// <Type>: string
|
|
// <Default>: (required)
|
|
simulation = "carx";
|
|
|
|
// <Description>: Defines how much dampers react to random little bumps on surface. It's only visual effect, doesn't influence drive simulation,
|
|
// only taken into account when calculating damper animation.
|
|
// <Type>: float
|
|
// <Default>: 0.0
|
|
dampersBumpCoef = 0.05;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Differential parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// <Description>: A number of differential types are supported: 4-wheel drive with open differential, 4-wheel drive with limited slip, front-wheel drive
|
|
// with open differential, front-wheel drive with limited slip, rear-wheel drive with open differential, rear-wheel drive with limited slip.
|
|
// <Type>: string; acceptable values: "all_open", "all_limited", "front_open", "front_limited", "rear_open", "rear_limited"
|
|
// <Default>: "all_limited"
|
|
differentialType = "all_limited";
|
|
|
|
// <Description>: Ratio of engine power that goes to front wheels out of total power for 4-wheel drive differentials.
|
|
// Choosing a value greater than 0.5 delivers more torque to the front wheels, while choosing a value less than 0.5
|
|
// delivers more torque to the rear wheels. This value is ignored for front-wheel drive and rear-wheel drive differentials.
|
|
// <Type>: float
|
|
// <Default>: 0.5
|
|
frontRearSplit = 0.5;
|
|
|
|
// <Description>: This is the largest possible relative difference between speed of front wheels. It helps to have outside wheels a bit faster
|
|
// during the turns, but it prevents the faster wheel to take all the power while sliding. The power is shifted to slower wheel once the value is reached.
|
|
// Locked differential has value of 1, the softer is the lock the greater should the value be.
|
|
// This value is ignored except for front-wheel drive or four wheel drive with limited slip.
|
|
// A good starting value is around 1.3.
|
|
// <Type>:
|
|
// <Default>:
|
|
frontBias = 1.5;
|
|
|
|
// <Description>: This is similar to frontBias except that it refers to the rear wheels.
|
|
// This value is ignored except for rear-wheel drive or four wheel drive with limited slip.
|
|
// A good starting value is around 1.3.
|
|
// <Type>: float
|
|
// <Default>: 1.3
|
|
rearBias = 1.3;
|
|
|
|
// <Description>: This value is similar to the frontBias and rearBias, except that it refers to the sum of the front wheel rotation speeds and the sum
|
|
// of the rear wheel rotation speeds.
|
|
// This value is ignored except for four wheel drive with limited slip.
|
|
// A good starting value is around 1.3.
|
|
// <Type>: float
|
|
// <Default>: 1.3
|
|
centreBias = 1.3;
|
|
|
|
// <Description>: How fast is engine power distributed to the wheels. Stronger values mean more aggressive drive performance inclining to
|
|
// slip a little while changing gears while weaker values are better for comfortable seamless ride.
|
|
// <Type>: float
|
|
// <Default>: 10.0
|
|
clutchStrength = 15.0;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Engine parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// <Description>: Power of the engine in kW.
|
|
// <Type>: float
|
|
// <Default>: (required)
|
|
enginePower = 100;
|
|
|
|
|
|
// <Description>: This is the maximum rotational speed of the engine expressed in radians per second. It could be calculated from maximum
|
|
// engine RPM like this:
|
|
// maxOmega = (maxRpm*2*Pi)/60.
|
|
// <Type>: float
|
|
// <Default>: 600 which is cca 6000 rounds per minute.
|
|
maxOmega = 720;
|
|
|
|
// <Description>: This is the maximum torque that is ever available from the engine. This is expressed in Newton metres.
|
|
// <Type>: float
|
|
// <Default>: value calculated from enginePower according to http://en.wikipedia.org/wiki/Horsepower#Relationship_with_torque
|
|
peakTorque = 350;
|
|
|
|
// <Description>: These three values describe internal damping of the engine. Bigger values mean greater damping. Clutch disengaged value
|
|
// is used while shifting gears, engine interpolates between clutch engaged and full throttle values according to throttle input.
|
|
// We tend to use slightly lower clutch engaged values because it allows cars to turn more smoothly.
|
|
// Typical values in range (0.25,3). The simulation can become unstable with damping rates of 0.
|
|
// <Type>: float, float, float
|
|
// <Default>: 0.08, 2.0, 0.35
|
|
dampingRateFullThrottle = 0.08;
|
|
dampingRateZeroThrottleClutchEngaged = 0.35;
|
|
dampingRateZeroThrottleClutchDisengaged = 0.35;
|
|
|
|
// <Description>: This is a graph of peak torque versus engine rotational speed.
|
|
// The x-axis of the curve is the relative engine speed; that is, the engine speed divided by the maximum engine speed. The y-axis of the curve is a
|
|
// multiplier in range (0,1) that is used to scale the peak torque. It is good to keep the values in mind while setting changeGearMinEffectivity.
|
|
// <Type>: Array[i][2] where i = number of samples, maximum 8;
|
|
// <Default>: {{0.0, 0.8}, {0.33, 1.0}, {1.0, 0.8}}
|
|
torqueCurve[] = {{0.000, 0.000}, {0.178, 0.800}, {0.250, 1.0}, {0.461, 0.900}, {0.900, 0.800}, {1.000, 0.300}};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Gearbox parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// <Description>: Value of minimal gear effectivity to hold current gear. If there is better gear and effectivity is below this value then change gear.
|
|
// <Range>: (0,1)
|
|
// <Type>: Array[i] where i = number of gears
|
|
// <Default>: 0.95 for every value (Neutral = 0.15 Not sure how important this is but we want to kick out of neutral very quickly)
|
|
changeGearMinEffectivity[] = {0.95, 0.15, 0.95, 0.95, 0.95, 0.95, 0.95};
|
|
|
|
// <Description>: The switch time describes how long it takes (in seconds) for a gear change to be completed. This needs to be set to aggresive shifting
|
|
// or it would cause issues while trying to run aggressively (mainly during evading the enemies).
|
|
// <Type>: float
|
|
// <Default>: 0.01
|
|
switchTime = 0.31;
|
|
|
|
// <Description>: Set the latency time of the gearbox, specified in s.
|
|
// This is used to prevent instant shifting after changing gears - there is some power loss during gear change and it could seem that
|
|
// previous gear is better for a brief time after shifting.
|
|
// <Type>: float
|
|
// <Default>: 2.0
|
|
latency = 1.0;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Wheels parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
class Wheels
|
|
{
|
|
class LF
|
|
{
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// General parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// <Description>: Name of the bone, used for wheel and suspension animations.
|
|
// <Type>: string
|
|
// <Default>: ""
|
|
boneName = "wheel_1_1_damper";
|
|
|
|
// <Description>: If true, wheel is steerable, false - wheel is fixed.
|
|
// <Type>: bool
|
|
// <Default>: (required)
|
|
steering = true;
|
|
|
|
// <Description>: Defines if wheel is on the right or left side of the vehicle
|
|
// <Type>: string
|
|
// <Default>: "right"
|
|
side = "left";
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Wheel PX parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// <Description>: Center of the wheel (axis)
|
|
// <Type>: memory point
|
|
// <Default>: (required)
|
|
center = "wheel_1_1_axis";
|
|
|
|
// <Description>: Point on the outside rim of the tire, used to calculate radius of the wheel (distance between center and boundary).
|
|
// <Type>: memory point
|
|
// <Default>: (required)
|
|
boundary = "wheel_1_1_bound";
|
|
|
|
// <Description>: This is the weight in kg of wheel including both rim and tyre.
|
|
// <Type>: float
|
|
// <Default>: 10.0
|
|
mass = 100;
|
|
|
|
// <Description>: This is the wheel's moment of inertia about the rolling axis. Smaller values result in more slips in aggresive driving
|
|
// while larger hamper the gain of speed. Good base to start with is this formula:
|
|
// MOI = 0.5 * Mass * Radius * Radius
|
|
// Some tweaking is needed after the computation, but it is still better than nothing.
|
|
// <Type>: float
|
|
// <Default>: 0.5 * WheelMass * WheelRadius * WheelRadius
|
|
MOI = 3.3;
|
|
|
|
// <Description>:The damping rate describes the rate at which a freely spinning wheel loses rotational speed.
|
|
// Values in range (0.25, 2) seem like sensible values. Experimentation is always a good idea, even outside this range.
|
|
// <Type>: float
|
|
// <Default>: 0.1
|
|
dampingRate = 0.5;
|
|
|
|
// <Description>: This is the value of the torque applied to the wheel when the brakes are maximally applied. Higher torques will lock the wheel
|
|
// quicker when braking, while lower torques will take longer to lock the wheel.
|
|
// A value of around 1500 is a good starting point for a vanilla wheel but a google search will reveal typical braking torques. One difficulty is
|
|
// that these are often expressed by manufacturers as braking horsepower or in "pounds inches". The values required here are in "Newton metres".
|
|
// <Type>: float
|
|
// <Default>: 2500
|
|
maxBrakeTorque = 2000;
|
|
|
|
// <Description>: This is the same as the max brake torque except for the handbrake rather than the brake. Typically, for a 4-wheeled car,
|
|
// the handbrake is stronger than the brake and is only applied to the rear wheels. A value of 4000 for the rear wheels is a good starting point,
|
|
// while a value of 0 is necessary for the front wheels to make sure they do not react to the handbrake.
|
|
// <Type>: float
|
|
// <Default>: 2*maxBrakeTorque
|
|
maxHandBrakeTorque = 4000;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Wheel simulation parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// <Description>: This is the direction of the suspension in the downward direction in the rest configuration of the vehicle. A vector that
|
|
// points straight downwards is a good starting point.
|
|
// <Type>: Array[3]
|
|
// <Default>: {0, -1, 0}
|
|
suspTravelDirection[] = {0, -1, 0};
|
|
|
|
// <Description>: This is the application point of the suspension force.
|
|
// <Type>: memory point
|
|
// <Default>: center
|
|
suspForceAppPointOffset = "wheel_1_1_axis";
|
|
|
|
// <Description>: This is almost the same as the suspension force app point except for the lateral and longitudinal forces that develop on the tire.
|
|
// A good starting point is to duplicate the suspension force application point.
|
|
// <Type>: memory point
|
|
// <Default>: suspForceAppPointOffset
|
|
tireForceAppPointOffset = "wheel_1_1_axis";
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Suspension parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// <Description>: These values describe the maximum compression and elongation in metres that the spring can support.
|
|
// <Type>: float
|
|
// <Default>: 0.15
|
|
maxCompression = 0.15; //0.75*0.2
|
|
mMaxDroop = 0.15;
|
|
|
|
// <Description>: This is the mass in kg that is supported by the suspension spring.
|
|
// <Type>: float
|
|
// <Default>: vehicleMass/numberOfWheels
|
|
sprungMass = 475; // 1900/4
|
|
|
|
// <Description>: This is the strength of the suspension spring in Newtons per metre.
|
|
// springStrength = naturalFrequency * naturalFrequency * sprungMass
|
|
// <Type>: float
|
|
// <Default>: sprungMass*5,0*5,0
|
|
//springStrength = 9680;
|
|
//springStrength = 22600;
|
|
springStrength = 59375; // = 125 * sprungMass
|
|
|
|
// <Description>: This describes the rate at which the spring dissipates the energy stored in the spring.
|
|
// Basic equiation for this is
|
|
// springDamperRate = dampingRatio * 2 * sqrt(springStrength * sprungMass)
|
|
// where dampingRatio = 1 mean critical damping (critically damped pendulum should get back to start point in every swing)
|
|
// <Type>: float
|
|
// <Default>: 0,4*2*sqrt(springStrength*sprungMass)
|
|
//springDamperRate = 1936;
|
|
//springDamperRate = 8680;
|
|
springDamperRate = 10621;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Tire parameters
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// <Description>: Increasing this value will result in the tire attempting to generate more longitudinal force when the tire is slipping.
|
|
// Typically, increasing longitudinal stiffness will help the car accelerate and brake. The total tire force available is limited by the
|
|
// load on the tire so be aware that increases in this value might have no effect or even come at the expense of reduced lateral force.
|
|
// <Type>: float
|
|
// <Default>: 10000
|
|
longitudinalStiffnessPerUnitGravity = 100000;
|
|
|
|
// <Description>: These values together describe the lateral stiffness per unit lateral slip (in radians) of the tire.
|
|
// <Type>: float, float
|
|
// <Default>: 25, 180
|
|
latStiffX = 25;
|
|
latStiffY = 18000;
|
|
|
|
// <Description>: These six values describe a graph of friction as a function of longitudinal slip.
|
|
// A good starting point for this is a flat graph of friction vs slip with these values:
|
|
// frictionVsSlipGraph[0][0]=0.0
|
|
// frictionVsSlipGraph[0][1]=1.0
|
|
// frictionVsSlipGraph[1][0]=0.5
|
|
// frictionVsSlipGraph[1][1]=1.0
|
|
// frictionVsSlipGraph[2][0]=1.0
|
|
// frictionVsSlipGraph[2][1]=1.0
|
|
// <Type>: Array[3][2]
|
|
// <Default>: {{0, 1}, {0.5, 1}, {1,1}}
|
|
frictionVsSlipGraph[] = {{0, 1}, {0.5, 1}, {1,1}};
|
|
};
|
|
class LR: LF
|
|
{
|
|
boneName = "wheel_1_2_damper";
|
|
steering = false;
|
|
center = "wheel_1_2_axis";
|
|
boundary = "wheel_1_2_bound";
|
|
suspForceAppPointOffset = "wheel_1_2_axis";
|
|
tireForceAppPointOffset = "wheel_1_2_axis";
|
|
};
|
|
class RF: LF
|
|
{
|
|
boneName = "wheel_2_1_damper";
|
|
center = "wheel_2_1_axis";
|
|
boundary = "wheel_2_1_bound";
|
|
suspForceAppPointOffset = "wheel_2_1_axis";
|
|
tireForceAppPointOffset = "wheel_2_1_axis";
|
|
steering = true;
|
|
side = "right";
|
|
};
|
|
class RR: RF
|
|
{
|
|
boneName = "wheel_2_2_damper";
|
|
steering = false;
|
|
center = "wheel_2_2_axis";
|
|
boundary = "wheel_2_2_bound";
|
|
suspForceAppPointOffset = "wheel_2_2_axis";
|
|
tireForceAppPointOffset = "wheel_2_2_axis";
|
|
};
|
|
}; |