{

float throttle;

float steering;

float brake;

float boost;

bool handbrake;

bool handbrakeLeft;

bool handbrakeRight;

bool brakepedal;

bool bHasBrakePedal;

bool bAnalogSteering;

{

DECLARE_SIMPLE_DATADESC();

float speed;

float engineRPM;

int gear;

float boostDelay;

int boostTimeLeft;

float skidSpeed;

int skidMaterial;

float steeringAngle;

int wheelsNotInContact;

int wheelsInContact;

bool isTorqueBoosting;

{

Vector vecAxlePos[VEHICLE_DEBUGRENDERDATA_MAX_AXLES];

Vector vecWheelPos[VEHICLE_DEBUGRENDERDATA_MAX_WHEELS];

Vector vecWheelRaycasts[VEHICLE_DEBUGRENDERDATA_MAX_WHEELS][2];

Vector vecWheelRaycastImpacts[VEHICLE_DEBUGRENDERDATA_MAX_WHEELS];

{

public:

virtual ~IPhysicsVehicleController() {}

// call this from the game code with the control parameters

virtual void Update( float dt, vehicle_controlparams_t &controls ) = 0;

virtual const vehicle_operatingparams_t &GetOperatingParams() = 0;

virtual const vehicleparams_t &GetVehicleParams() = 0;

virtual vehicleparams_t &GetVehicleParamsForChange() = 0;

virtual float UpdateBooster(float dt) = 0;

virtual int GetWheelCount(void) = 0;

virtual IPhysicsObject *GetWheel(int index) = 0;

virtual bool GetWheelContactPoint( int index, Vector *pContactPoint, int *pSurfaceProps ) = 0;

virtual void SetSpringLength(int wheelIndex, float length) = 0;

virtual void SetWheelFriction(int wheelIndex, float friction) = 0;

virtual void OnVehicleEnter( void ) = 0;

virtual void OnVehicleExit( void ) = 0;

virtual void SetEngineDisabled( bool bDisable ) = 0;

virtual bool IsEngineDisabled( void ) = 0;

// Debug

virtual void GetCarSystemDebugData( vehicle_debugcarsystem_t &debugCarSystem ) = 0;

virtual void VehicleDataReload() = 0;

{

DECLARE_SIMPLE_DATADESC();

Vector massCenterOverride; // leave at vec3_origin for no override

float massOverride; // leave at 0 for no override

float addGravity; // keeps car down

float tiltForce; // keeps car down when not on flat ground

float tiltForceHeight; // where the tilt force pulls relative to center of mass

float counterTorqueFactor;

float keepUprightTorque;

float maxAngularVelocity; // clamp the car angular velocity separately from other objects to keep stable

{

DECLARE_SIMPLE_DATADESC();

float radius;

float mass;

float inertia;

float damping; // usually 0

float rotdamping; // usually 0

float frictionScale; // 1.5 front, 1.8 rear

int materialIndex;

int brakeMaterialIndex;

int skidMaterialIndex;

float springAdditionalLength; // 0 means the spring is at it's rest length

{

DECLARE_SIMPLE_DATADESC();

float springConstant;

float springDamping;

float stabilizerConstant;

float springDampingCompression;

float maxBodyForce;

{

DECLARE_SIMPLE_DATADESC();

Vector offset; // center of this axle in vehicle object space

Vector wheelOffset; // offset to wheel (assume other wheel is symmetric at -wheelOffset) from axle center

Vector raytraceCenterOffset; // offset to center of axle for the raytrace data.

Vector raytraceOffset; // offset to raytrace for non-wheel (some wheeled) vehicles

vehicle_wheelparams_t wheels;

vehicle_suspensionparams_t suspension;

float torqueFactor; // normalized to 1 across all axles

// e.g. 0,1 for rear wheel drive - 0.5,0.5 for 4 wheel drive

float brakeFactor; // normalized to 1 across all axles

{

DECLARE_SIMPLE_DATADESC();

float degreesSlow; // angle in degrees of steering at slow speed

float degreesFast; // angle in degrees of steering at fast speed

float degreesBoost; // angle in degrees of steering at fast speed

float steeringRateSlow; // this is the speed the wheels are steered when the vehicle is slow

float steeringRateFast; // this is the speed the wheels are steered when the vehicle is "fast"

float steeringRestRateSlow; // this is the speed at which the wheels move toward their resting state (straight ahead) at slow speed

float steeringRestRateFast; // this is the speed at which the wheels move toward their resting state (straight ahead) at fast speed

float speedSlow; // this is the max speed of "slow"

float speedFast; // this is the min speed of "fast"

float turnThrottleReduceSlow; // this is the amount of throttle reduction to apply at the maximum steering angle

float turnThrottleReduceFast; // this is the amount of throttle reduction to apply at the maximum steering angle

float brakeSteeringRateFactor; // this scales the steering rate when the brake/handbrake is down

float throttleSteeringRestRateFactor; // this scales the steering rest rate when the throttle is down

float powerSlideAccel; // scale of speed to acceleration

float boostSteeringRestRateFactor; // this scales the steering rest rate when boosting

float boostSteeringRateFactor; // this scales the steering rest rate when boosting

float steeringExponent; // this makes the steering response non-linear. The steering function is linear, then raised to this power

bool isSkidAllowed; // true/false skid flag

bool dustCloud; // flag for creating a dustcloud behind vehicle

{

DECLARE_SIMPLE_DATADESC();

float horsepower;

float maxSpeed;

float maxRevSpeed;

float maxRPM; // redline RPM limit

float axleRatio; // ratio of engine rev to axle rev

float throttleTime; // time to reach full throttle in seconds

// transmission

int gearCount; // gear count - max 10

float gearRatio[VEHICLE_MAX_GEAR_COUNT]; // ratio for each gear

// automatic transmission (simple auto-shifter - switches at fixed RPM limits)

float shiftUpRPM; // max RPMs to switch to a higher gear

float shiftDownRPM; // min RPMs to switch to a lower gear

float boostForce;

float boostDuration;

float boostDelay;

float boostMaxSpeed;

float autobrakeSpeedGain;

float autobrakeSpeedFactor;

bool torqueBoost;

bool isAutoTransmission; // true for auto, false for manual

{

DECLARE_SIMPLE_DATADESC();

int axleCount;

int wheelsPerAxle;

vehicle_bodyparams_t body;

vehicle_axleparams_t axles[VEHICLE_MAX_AXLE_COUNT];

vehicle_engineparams_t engine;

vehicle_steeringparams_t steering;

{

VEHICLE_SEAT_ANY, // Any available seat for our role

VEHICLE_SEAT_NEAREST, // Seat closest to our starting point

{

PASSENGER_SEAT_ENTRY,

PASSENGER_SEAT_EXIT