H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 06:06:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
source-engine/vphysics/physics_vehicle.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

1607 lines
55 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#ifdef _WIN32
#pragma warning (disable:4127)
#pragma warning (disable:4244)
#endif
#include "cbase.h"
#include "ivp_controller.hxx"
#include "ivp_cache_object.hxx"
#include "ivp_car_system.hxx"
#include "ivp_constraint_car.hxx"
#include "ivp_material.hxx"
#include "vphysics/vehicles.h"
#include "vphysics/friction.h"
#include "physics_vehicle.h"
#include "physics_controller_raycast_vehicle.h"
#include "physics_airboat.h"
#include "ivp_car_system.hxx"
#include "ivp_listener_object.hxx"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define THROTTLE_OPPOSING_FORCE_EPSILON 5.0f
#define VEHICLE_SKID_EPSILON 0.1f
// y in/s = x miles/hour * (5280 * 12 (in / mile)) * (1 / 3600 (hour / sec) )
//#define MPH2INS(x) ( (x) * 5280.0f * 12.0f / 3600.0f )
//#define INS2MPH(x) ( (x) * 3600 * (1/5280.0f) * (1/12.0f) )
#define MPH_TO_METERSPERSECOND 0.44707f
#define METERSPERSECOND_TO_MPH (1.0f / MPH_TO_METERSPERSECOND)
#define MPH_TO_GAMEVEL(x) (ConvertDistanceToHL( (x) * MPH_TO_METERSPERSECOND ))
#define GAMEVEL_TO_MPH(x) (ConvertDistanceToIVP(x) * METERSPERSECOND_TO_MPH)
#define FVEHICLE_THROTTLE_STOPPED 0x00000001
#define FVEHICLE_HANDBRAKE_ON 0x00000002
struct vphysics_save_cvehiclecontroller_t
{
CPhysicsObject *m_pCarBody;
int m_wheelCount;
vehicleparams_t m_vehicleData;
vehicle_operatingparams_t m_currentState;
float m_wheelRadius;
float m_bodyMass;
float m_totalWheelMass;
float m_gravityLength;
float m_torqueScale;
CPhysicsObject *m_pWheels[VEHICLE_MAX_WHEEL_COUNT];
Vector m_wheelPosition_Bs[VEHICLE_MAX_WHEEL_COUNT];
Vector m_tracePosition_Bs[VEHICLE_MAX_WHEEL_COUNT];
int m_vehicleFlags;
unsigned int m_nTireType;
unsigned int m_nVehicleType;
bool m_bTraceData;
bool m_bOccupied;
bool m_bEngineDisable;
float m_flVelocity[3];
DECLARE_SIMPLE_DATADESC();
};
BEGIN_SIMPLE_DATADESC( vphysics_save_cvehiclecontroller_t )
DEFINE_VPHYSPTR( m_pCarBody ),
DEFINE_FIELD( m_wheelCount, FIELD_INTEGER ),
DEFINE_EMBEDDED( m_vehicleData ),
DEFINE_EMBEDDED( m_currentState ),
DEFINE_FIELD( m_wheelCount, FIELD_INTEGER ),
DEFINE_FIELD( m_bodyMass, FIELD_FLOAT ),
DEFINE_FIELD( m_totalWheelMass, FIELD_FLOAT ),
DEFINE_FIELD( m_gravityLength, FIELD_FLOAT ),
DEFINE_FIELD( m_torqueScale, FIELD_FLOAT ),
DEFINE_VPHYSPTR_ARRAY( m_pWheels, VEHICLE_MAX_WHEEL_COUNT ),
DEFINE_ARRAY( m_wheelPosition_Bs, FIELD_VECTOR, VEHICLE_MAX_WHEEL_COUNT ),
DEFINE_ARRAY( m_tracePosition_Bs, FIELD_VECTOR, VEHICLE_MAX_WHEEL_COUNT ),
DEFINE_FIELD( m_vehicleFlags, FIELD_INTEGER ),
DEFINE_FIELD( m_nTireType, FIELD_INTEGER ),
DEFINE_FIELD( m_nVehicleType, FIELD_INTEGER ),
DEFINE_FIELD( m_bTraceData, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bOccupied, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bEngineDisable, FIELD_BOOLEAN ),
DEFINE_ARRAY( m_flVelocity, FIELD_FLOAT, 3 ),
END_DATADESC()
BEGIN_SIMPLE_DATADESC( vehicle_operatingparams_t )
DEFINE_FIELD( speed, FIELD_FLOAT ),
DEFINE_FIELD( engineRPM, FIELD_FLOAT ),
DEFINE_FIELD( gear, FIELD_INTEGER ),
DEFINE_FIELD( boostDelay, FIELD_FLOAT ),
DEFINE_FIELD( boostTimeLeft, FIELD_INTEGER ),
DEFINE_FIELD( skidSpeed, FIELD_FLOAT ),
DEFINE_CUSTOM_FIELD( skidMaterial, MaterialIndexDataOps() ),
DEFINE_FIELD( steeringAngle, FIELD_FLOAT ),
DEFINE_FIELD( wheelsInContact, FIELD_INTEGER ),
DEFINE_FIELD( wheelsNotInContact,FIELD_INTEGER ),
DEFINE_FIELD( isTorqueBoosting, FIELD_BOOLEAN ),
END_DATADESC()
BEGIN_SIMPLE_DATADESC( vehicle_bodyparams_t )
DEFINE_FIELD( massCenterOverride, FIELD_VECTOR ),
DEFINE_FIELD( massOverride, FIELD_FLOAT ),
DEFINE_FIELD( addGravity, FIELD_FLOAT ),
DEFINE_FIELD( maxAngularVelocity, FIELD_FLOAT ),
DEFINE_FIELD( tiltForce, FIELD_FLOAT ),
DEFINE_FIELD( tiltForceHeight, FIELD_FLOAT ),
DEFINE_FIELD( counterTorqueFactor, FIELD_FLOAT ),
DEFINE_FIELD( keepUprightTorque, FIELD_FLOAT ),
END_DATADESC()
BEGIN_SIMPLE_DATADESC( vehicle_wheelparams_t )
DEFINE_FIELD( radius, FIELD_FLOAT ),
DEFINE_FIELD( mass, FIELD_FLOAT ),
DEFINE_FIELD( inertia, FIELD_FLOAT ),
DEFINE_FIELD( damping, FIELD_FLOAT ),
DEFINE_FIELD( rotdamping, FIELD_FLOAT ),
DEFINE_FIELD( frictionScale, FIELD_FLOAT ),
DEFINE_CUSTOM_FIELD( materialIndex, MaterialIndexDataOps() ),
DEFINE_CUSTOM_FIELD( brakeMaterialIndex, MaterialIndexDataOps() ),
DEFINE_CUSTOM_FIELD( skidMaterialIndex, MaterialIndexDataOps() ),
DEFINE_FIELD( springAdditionalLength, FIELD_FLOAT ),
END_DATADESC()
BEGIN_SIMPLE_DATADESC( vehicle_suspensionparams_t )
DEFINE_FIELD( springConstant, FIELD_FLOAT ),
DEFINE_FIELD( springDamping, FIELD_FLOAT ),
DEFINE_FIELD( stabilizerConstant, FIELD_FLOAT ),
DEFINE_FIELD( springDampingCompression, FIELD_FLOAT ),
DEFINE_FIELD( maxBodyForce, FIELD_FLOAT ),
END_DATADESC()
BEGIN_SIMPLE_DATADESC( vehicle_axleparams_t )
DEFINE_FIELD( offset, FIELD_VECTOR ),
DEFINE_FIELD( wheelOffset, FIELD_VECTOR ),
DEFINE_FIELD( raytraceCenterOffset, FIELD_VECTOR ),
DEFINE_FIELD( raytraceOffset, FIELD_VECTOR ),
DEFINE_EMBEDDED( wheels ),
DEFINE_EMBEDDED( suspension ),
DEFINE_FIELD( torqueFactor, FIELD_FLOAT ),
DEFINE_FIELD( brakeFactor, FIELD_FLOAT ),
END_DATADESC()
BEGIN_SIMPLE_DATADESC( vehicle_steeringparams_t )
DEFINE_FIELD( degreesSlow, FIELD_FLOAT ),
DEFINE_FIELD( degreesFast, FIELD_FLOAT ),
DEFINE_FIELD( degreesBoost, FIELD_FLOAT ),
DEFINE_FIELD( steeringRateSlow, FIELD_FLOAT ),
DEFINE_FIELD( steeringRateFast, FIELD_FLOAT ),
DEFINE_FIELD( steeringRestRateSlow, FIELD_FLOAT ),
DEFINE_FIELD( steeringRestRateFast, FIELD_FLOAT ),
DEFINE_FIELD( throttleSteeringRestRateFactor, FIELD_FLOAT ),
DEFINE_FIELD( boostSteeringRestRateFactor, FIELD_FLOAT ),
DEFINE_FIELD( boostSteeringRateFactor, FIELD_FLOAT ),
DEFINE_FIELD( steeringExponent, FIELD_FLOAT ),
DEFINE_FIELD( speedSlow, FIELD_FLOAT ),
DEFINE_FIELD( speedFast, FIELD_FLOAT ),
DEFINE_FIELD( turnThrottleReduceSlow, FIELD_FLOAT ),
DEFINE_FIELD( turnThrottleReduceFast, FIELD_FLOAT ),
DEFINE_FIELD( powerSlideAccel, FIELD_FLOAT ),
DEFINE_FIELD( brakeSteeringRateFactor, FIELD_FLOAT ),
DEFINE_FIELD( isSkidAllowed, FIELD_BOOLEAN ),
DEFINE_FIELD( dustCloud, FIELD_BOOLEAN ),
END_DATADESC()
BEGIN_SIMPLE_DATADESC( vehicle_engineparams_t )
DEFINE_FIELD( horsepower, FIELD_FLOAT ),
DEFINE_FIELD( maxSpeed, FIELD_FLOAT ),
DEFINE_FIELD( maxRevSpeed, FIELD_FLOAT ),
DEFINE_FIELD( maxRPM, FIELD_FLOAT ),
DEFINE_FIELD( axleRatio, FIELD_FLOAT ),
DEFINE_FIELD( throttleTime, FIELD_FLOAT ),
DEFINE_FIELD( maxRPM, FIELD_FLOAT ),
DEFINE_FIELD( isAutoTransmission, FIELD_BOOLEAN ),
DEFINE_FIELD( gearCount, FIELD_INTEGER ),
DEFINE_AUTO_ARRAY( gearRatio, FIELD_FLOAT ),
DEFINE_FIELD( shiftUpRPM, FIELD_FLOAT ),
DEFINE_FIELD( shiftDownRPM, FIELD_FLOAT ),
DEFINE_FIELD( boostForce, FIELD_FLOAT ),
DEFINE_FIELD( boostDuration, FIELD_FLOAT ),
DEFINE_FIELD( boostDelay, FIELD_FLOAT ),
DEFINE_FIELD( boostMaxSpeed, FIELD_FLOAT ),
DEFINE_FIELD( autobrakeSpeedGain, FIELD_FLOAT ),
DEFINE_FIELD( autobrakeSpeedFactor, FIELD_FLOAT ),
DEFINE_FIELD( torqueBoost, FIELD_BOOLEAN ),
END_DATADESC()
BEGIN_SIMPLE_DATADESC( vehicleparams_t )
DEFINE_FIELD( axleCount, FIELD_INTEGER ),
DEFINE_FIELD( wheelsPerAxle, FIELD_INTEGER ),
DEFINE_EMBEDDED( body ),
DEFINE_EMBEDDED_AUTO_ARRAY( axles ),
DEFINE_EMBEDDED( engine ),
DEFINE_EMBEDDED( steering ),
END_DATADESC()
bool IsVehicleWheel( IVP_Real_Object *pivp )
{
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pivp->client_data);
// FIXME: Check why this is null! It occurs when jumping the ravine in seafloor
if (!pObject)
return false;
return (pObject->CallbackFlags() & CALLBACK_IS_VEHICLE_WHEEL) ? true : false;
}
inline bool IsMoveable( IVP_Real_Object *pObject )
{
IVP_Core *pCore = pObject->get_core();
if ( pCore->pinned || pCore->physical_unmoveable )
return false;
return true;
}
inline bool IVPFloatPointIsZero( const IVP_U_Float_Point &test )
{
const float eps = 1e-4f;
return test.quad_length() < eps ? true : false;
}
bool ShouldOverrideWheelContactFriction( float *pFrictionOut, IVP_Real_Object *pivp0, IVP_Real_Object *pivp1, IVP_U_Float_Point *pNormal )
{
if ( !pivp0->get_core()->car_wheel && !pivp1->get_core()->car_wheel )
return false;
if ( !IsVehicleWheel(pivp0) )
{
if ( !IsVehicleWheel(pivp1) )
return false;
// swap so pivp0 is a wheel
IVP_Real_Object *pTmp = pivp0;
pivp0 = pivp1;
pivp1 = pTmp;
}
// if we got here then pivp0 is a car wheel object
// BUGBUG: IVP sometimes sends us a bogus normal
// when doing a material realc on existing contacts!
if ( !IVPFloatPointIsZero(pNormal) )
{
IVP_U_Float_Point normalWheelSpace;
pivp0->get_core()->get_m_world_f_core_PSI()->vimult3( pNormal, &normalWheelSpace );
if ( fabs(normalWheelSpace.k[0]) > 0.2588f ) // 15 degree wheel cone
{
// adjust friction here, this isn't a valid part of the wheel for contact, set friction to zero
//Vector tmp;ConvertDirectionToHL( normalWheelSpace, tmp );Msg("Wheel sliding on surface %.2f %.2f %.2f\n", tmp.x, tmp.y, tmp.z );
*pFrictionOut = 0;
return true;
}
}
// was car wheel, but didn't adjust - use default friction
return false;
}
class CVehicleController : public IPhysicsVehicleController, public IVP_Listener_Object
{
public:
CVehicleController( );
CVehicleController( const vehicleparams_t &params, CPhysicsEnvironment *pEnv, unsigned int nVehicleType, IPhysicsGameTrace *pGameTrace );
~CVehicleController();
// CVehicleController
void InitCarSystem( CPhysicsObject *pBodyObject );
// IPhysicsVehicleController
void Update( float dt, vehicle_controlparams_t &controls );
float UpdateBooster( float dt );
void SetSpringLength(int wheelIndex, float length);
const vehicle_operatingparams_t &GetOperatingParams() { return m_currentState; }
const vehicleparams_t &GetVehicleParams() { return m_vehicleData; }
vehicleparams_t &GetVehicleParamsForChange() { return m_vehicleData; }
int GetWheelCount(void) { return m_wheelCount; };
IPhysicsObject* GetWheel(int index);
virtual bool GetWheelContactPoint( int index, Vector *pContactPoint, int *pSurfaceProps );
void SetWheelFriction(int wheelIndex, float friction);
void SetEngineDisabled( bool bDisable ) { m_bEngineDisable = bDisable; }
bool IsEngineDisabled( void ) { return m_bEngineDisable; }
// Save/load
void WriteToTemplate( vphysics_save_cvehiclecontroller_t &controllerTemplate );
void InitFromTemplate( CPhysicsEnvironment *pEnv, void *pGameData, IPhysicsGameTrace *pGameTrace, const vphysics_save_cvehiclecontroller_t &controllerTemplate );
void VehicleDataReload();
// Debug
void GetCarSystemDebugData( vehicle_debugcarsystem_t &debugCarSystem );
// IVP_Listener_Object
// Object listener, only hook delete
virtual void event_object_deleted( IVP_Event_Object *);
virtual void event_object_created( IVP_Event_Object *) {}
virtual void event_object_revived( IVP_Event_Object *) {}
virtual void event_object_frozen ( IVP_Event_Object *) {}
// Entry/Exit
void OnVehicleEnter( void );
void OnVehicleExit( void );
protected:
void CreateIVPObjects( );
void ShutdownCarSystem();
void InitVehicleData( const vehicleparams_t &params );
void InitCarSystemBody( IVP_Template_Car_System &ivpVehicleData );
void InitCarSystemWheels( IVP_Template_Car_System &ivpVehicleData );
void AttachListener();
IVP_Real_Object *CreateWheel( int wheelIndex, vehicle_axleparams_t &axle );
void CreateTraceData( int wheelIndex, vehicle_axleparams_t &axle );
// Update.
void UpdateSteering( const vehicle_controlparams_t &controls, float flDeltaTime, float flSpeed );
void UpdatePowerslide( const vehicle_controlparams_t &controls, bool bPowerslide, float flSpeed );
void UpdateEngine( const vehicle_controlparams_t &controls, float flDeltaTime, float flThrottle, float flBrake, bool bHandbrake, bool bPowerslide );
bool UpdateEngineTurboStart( const vehicle_controlparams_t &controls, float flDeltaTime );
void UpdateEngineTurboFinish( void );
void UpdateHandbrake( const vehicle_controlparams_t &controls, float flThrottle, bool bHandbrake, bool bPowerslide );
void UpdateSkidding( bool bHandbrake );
void UpdateExtraForces( void );
void UpdateWheelPositions( void );
float CalcSteering( float dt, float speed, float steering, bool bAnalog );
void CalcEngine( float throttle, float brake_val, bool handbrake, float steeringVal, bool torqueBoost );
void CalcEngineTransmission( float flThrottle );
virtual bool IsBoosting( void );
private:
void ResetState();
IVP_Car_System *m_pCarSystem;
CPhysicsObject *m_pCarBody;
CPhysicsEnvironment *m_pEnv;
IPhysicsGameTrace *m_pGameTrace;
int m_wheelCount;
vehicleparams_t m_vehicleData;
vehicle_operatingparams_t m_currentState;
float m_wheelRadius;
float m_bodyMass;
float m_totalWheelMass;
float m_gravityLength;
float m_torqueScale;
CPhysicsObject *m_pWheels[VEHICLE_MAX_WHEEL_COUNT];
IVP_U_Float_Point m_wheelPosition_Bs[VEHICLE_MAX_WHEEL_COUNT];
IVP_U_Float_Point m_tracePosition_Bs[VEHICLE_MAX_WHEEL_COUNT];
int m_vehicleFlags;
unsigned int m_nTireType;
unsigned int m_nVehicleType;
bool m_bTraceData;
bool m_bOccupied;
bool m_bEngineDisable;
float m_flVelocity[3];
};
CVehicleController::CVehicleController( const vehicleparams_t &params, CPhysicsEnvironment *pEnv, unsigned int nVehicleType, IPhysicsGameTrace *pGameTrace )
{
m_pEnv = pEnv;
m_pGameTrace = pGameTrace;
m_nVehicleType = nVehicleType;
InitVehicleData( params );
ResetState();
}
CVehicleController::CVehicleController()
{
ResetState();
}
void CVehicleController::ResetState()
{
m_pCarSystem = NULL;
m_flVelocity[0] = m_flVelocity[1]= m_flVelocity[2] = 0.0f;
for ( int i = 0; i < VEHICLE_MAX_WHEEL_COUNT; i++ )
{
m_pWheels[i] = NULL;
}
m_pCarBody = NULL;
m_torqueScale = 1;
m_wheelCount = 0;
m_wheelRadius = 0;
memset( &m_currentState, 0, sizeof(m_currentState) );
m_bodyMass = 0;
m_vehicleFlags = 0;
memset( m_wheelPosition_Bs, 0, sizeof(m_wheelPosition_Bs) );
memset( m_tracePosition_Bs, 0, sizeof(m_tracePosition_Bs) );
m_bTraceData = false;
if ( m_nVehicleType == VEHICLE_TYPE_AIRBOAT_RAYCAST )
{
m_bTraceData = true;
}
m_nTireType = VEHICLE_TIRE_NORMAL;
m_bOccupied = false;
m_bEngineDisable = false;
}
CVehicleController::~CVehicleController()
{
ShutdownCarSystem();
}
IPhysicsObject* CVehicleController::GetWheel( int index )
{
// TODO: This is getting messy.
if ( m_nVehicleType == VEHICLE_TYPE_CAR_WHEELS )
{
return m_pWheels[index];
}
else if ( m_nVehicleType == VEHICLE_TYPE_CAR_RAYCAST && m_pCarSystem )
{
return static_cast<CPhysics_Car_System_Raycast_Wheels*>( m_pCarSystem )->GetWheel( index );
}
else if ( m_nVehicleType == VEHICLE_TYPE_AIRBOAT_RAYCAST && m_pCarSystem )
{
return static_cast<CPhysics_Airboat*>( m_pCarSystem )->GetWheel( index );
}
return NULL;
}
void CVehicleController::SetWheelFriction(int wheelIndex, float friction)
{
CPhysics_Airboat *pAirboat = static_cast<CPhysics_Airboat*>( m_pCarSystem );
if ( !pAirboat )
return;
pAirboat->SetWheelFriction( wheelIndex, friction );
}
bool CVehicleController::GetWheelContactPoint( int index, Vector *pContactPoint, int *pSurfaceProps )
{
bool bSet = false;
if ( index < m_wheelCount )
{
IPhysicsFrictionSnapshot *pSnapshot = m_pWheels[index]->CreateFrictionSnapshot();
float forceMax = -1.0f;
m_pWheels[index]->GetPosition( pContactPoint, NULL );
while ( pSnapshot->IsValid() )
{
float thisForce = pSnapshot->GetNormalForce();
if ( thisForce > forceMax )
{
forceMax = thisForce;
if ( pContactPoint )
{
pSnapshot->GetContactPoint( *pContactPoint );
}
if ( pSurfaceProps )
{
*pSurfaceProps = pSnapshot->GetMaterial(1);
}
bSet = true;
}
pSnapshot->NextFrictionData();
}
m_pWheels[index]->DestroyFrictionSnapshot(pSnapshot);
}
else
{
if ( pContactPoint )
{
pContactPoint->Init();
}
if ( pSurfaceProps )
{
*pSurfaceProps = 0;
}
}
return bSet;
}
void CVehicleController::AttachListener()
{
m_pCarBody->GetObject()->add_listener_object( this );
}
void CVehicleController::event_object_deleted( IVP_Event_Object *pEvent )
{
// the car system's constraint solver is going to delete itself now, so NULL the car system.
m_pCarSystem->event_object_deleted( pEvent );
m_pCarSystem = NULL;
ShutdownCarSystem();
}
IVP_Real_Object *CVehicleController::CreateWheel( int wheelIndex, vehicle_axleparams_t &axle )
{
if ( wheelIndex >= VEHICLE_MAX_WHEEL_COUNT )
return NULL;
// HACKHACK: In Save/load, the wheel was reloaded, so pretend to create it
// ALSO NOTE: Save/load puts the results into m_pWheels regardless of vehicle type!!!
// That's why I'm not calling GetWheel().
if ( m_pWheels[wheelIndex] )
{
CPhysicsObject *pWheelObject = static_cast<CPhysicsObject *>(m_pWheels[wheelIndex]);
return pWheelObject->GetObject();
}
objectparams_t params;
memset( &params, 0, sizeof(params) );
Vector bodyPosition;
QAngle bodyAngles;
m_pCarBody->GetPosition( &bodyPosition, &bodyAngles );
matrix3x4_t matrix;
AngleMatrix( bodyAngles, bodyPosition, matrix );
Vector position = axle.offset;
// BUGBUG: This only works with 2 wheels per axle
if ( wheelIndex & 1 )
{
position += axle.wheelOffset;
}
else
{
position -= axle.wheelOffset;
}
Vector wheelPositionHL;
VectorTransform( position, matrix, wheelPositionHL );
params.damping = axle.wheels.damping;
params.dragCoefficient = 0;
params.enableCollisions = false;
params.inertia = axle.wheels.inertia;
params.mass = axle.wheels.mass;
params.pGameData = m_pCarBody->GetGameData();
params.pName = "VehicleWheel";
params.rotdamping = axle.wheels.rotdamping;
params.rotInertiaLimit = 0;
params.massCenterOverride = NULL;
// needs to be in HL units because we're calling through the "outer" interface to create
// the wheels
float radius = axle.wheels.radius;
float r3 = radius * radius * radius;
params.volume = (4 / 3) * M_PI * r3;
CPhysicsObject *pWheel = (CPhysicsObject *)m_pEnv->CreateSphereObject( radius, axle.wheels.materialIndex, wheelPositionHL, bodyAngles, &params, false );
pWheel->Wake();
// UNDONE: only mask off some of these flags?
unsigned int flags = pWheel->CallbackFlags();
flags = 0;
pWheel->SetCallbackFlags( flags );
// copy the body's game flags
pWheel->SetGameFlags( m_pCarBody->GetGameFlags() );
// cache the wheel object pointer
m_pWheels[wheelIndex] = pWheel;
IVP_U_Point wheelPositionIVP, wheelPositionBs;
ConvertPositionToIVP( wheelPositionHL, wheelPositionIVP );
TransformIVPToLocal( wheelPositionIVP, wheelPositionBs, m_pCarBody->GetObject(), true );
m_wheelPosition_Bs[wheelIndex].set_to_zero();
m_wheelPosition_Bs[wheelIndex].set( &wheelPositionBs );
pWheel->AddCallbackFlags( CALLBACK_IS_VEHICLE_WHEEL );
return pWheel->GetObject();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CVehicleController::CreateTraceData( int wheelIndex, vehicle_axleparams_t &axle )
{
if ( wheelIndex >= VEHICLE_MAX_WHEEL_COUNT )
return;
objectparams_t params;
memset( &params, 0, sizeof( params ) );
Vector bodyPosition;
QAngle bodyAngles;
matrix3x4_t matrix;
m_pCarBody->GetPosition( &bodyPosition, &bodyAngles );
AngleMatrix( bodyAngles, bodyPosition, matrix );
Vector tracePosition = axle.raytraceCenterOffset;
// BUGBUG: This only works with 2 wheels per axle
if ( wheelIndex & 1 )
{
tracePosition += axle.raytraceOffset;
}
else
{
tracePosition -= axle.raytraceOffset;
}
Vector tracePositionHL;
VectorTransform( tracePosition, matrix, tracePositionHL );
IVP_U_Point tracePositionIVP, tracePositionBs;
ConvertPositionToIVP( tracePositionHL, tracePositionIVP );
TransformIVPToLocal( tracePositionIVP, tracePositionBs, m_pCarBody->GetObject(), true );
m_tracePosition_Bs[wheelIndex].set_to_zero();
m_tracePosition_Bs[wheelIndex].set( &tracePositionBs );
}
void CVehicleController::CreateIVPObjects( )
{
// Initialize the car system (body and wheels).
IVP_Template_Car_System ivpVehicleData( m_wheelCount, m_vehicleData.axleCount );
InitCarSystemBody( ivpVehicleData );
InitCarSystemWheels( ivpVehicleData );
BEGIN_IVP_ALLOCATION();
// Raycast Car
switch ( m_nVehicleType )
{
case VEHICLE_TYPE_CAR_WHEELS:
m_pCarSystem = new IVP_Car_System_Real_Wheels( m_pEnv->GetIVPEnvironment(), &ivpVehicleData );
break
;
case VEHICLE_TYPE_CAR_RAYCAST:
m_pCarSystem = new CPhysics_Car_System_Raycast_Wheels( m_pEnv->GetIVPEnvironment(), &ivpVehicleData );
break;
case VEHICLE_TYPE_AIRBOAT_RAYCAST:
m_pCarSystem = new CPhysics_Airboat( m_pEnv->GetIVPEnvironment(), &ivpVehicleData, m_pGameTrace );
break;
}
AttachListener();
END_IVP_ALLOCATION();
}
void CVehicleController::InitCarSystem( CPhysicsObject *pBodyObject )
{
if ( m_pCarSystem )
{
ShutdownCarSystem();
}
// Car body.
m_pCarBody = pBodyObject;
m_bodyMass = m_pCarBody->GetMass();
m_gravityLength = m_pEnv->GetIVPEnvironment()->get_gravity()->real_length();
// Setup axle/wheel counts.
m_wheelCount = m_vehicleData.axleCount * m_vehicleData.wheelsPerAxle;
CreateIVPObjects();
if ( m_nVehicleType == VEHICLE_TYPE_AIRBOAT_RAYCAST )
{
float flDampSpeed = 1.0f;
float flDampRotSpeed = 1.0f;
m_pCarBody->SetDamping( &flDampSpeed, &flDampRotSpeed );
}
}
void CVehicleController::VehicleDataReload()
{
// compute torque normalization factor
m_torqueScale = 1;
// Clear accumulation.
float totalTorqueDistribution = 0.0f;
for ( int i = 0; i < m_vehicleData.axleCount; i++ )
{
totalTorqueDistribution += m_vehicleData.axles[i].torqueFactor;
}
if ( totalTorqueDistribution > 0 )
{
m_torqueScale /= totalTorqueDistribution;
}
// input speed is in miles/hour. Convert to in/s
m_vehicleData.engine.maxSpeed = MPH_TO_GAMEVEL(m_vehicleData.engine.maxSpeed);
m_vehicleData.engine.maxRevSpeed = MPH_TO_GAMEVEL(m_vehicleData.engine.maxRevSpeed);
m_vehicleData.engine.boostMaxSpeed = MPH_TO_GAMEVEL(m_vehicleData.engine.boostMaxSpeed);
}
//-----------------------------------------------------------------------------
// Purpose: Setup the body parameters.
//-----------------------------------------------------------------------------
void CVehicleController::InitCarSystemBody( IVP_Template_Car_System &ivpVehicleData )
{
ivpVehicleData.car_body = m_pCarBody->GetObject();
ivpVehicleData.index_x = IVP_INDEX_X;
ivpVehicleData.index_y = IVP_INDEX_Y;
ivpVehicleData.index_z = IVP_INDEX_Z;
ivpVehicleData.body_counter_torque_factor = m_vehicleData.body.counterTorqueFactor;
ivpVehicleData.body_down_force_vertical_offset = ConvertDistanceToIVP( m_vehicleData.body.tiltForceHeight );
ivpVehicleData.extra_gravity_force_value = m_vehicleData.body.addGravity * m_gravityLength * m_bodyMass;
ivpVehicleData.extra_gravity_height_offset = 0;
#if 0
// HACKHACK: match example
ivpVehicleData.extra_gravity_force_value = 1.2;
ivpVehicleData.body_down_force_vertical_offset = 2;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Setup the wheel paramters.
//-----------------------------------------------------------------------------
void CVehicleController::InitCarSystemWheels( IVP_Template_Car_System &ivpVehicleData )
{
int wheelIndex = 0;
m_wheelRadius = 0;
m_totalWheelMass = 0;
int i;
for ( i = 0; i < m_vehicleData.axleCount; i++ )
{
for ( int w = 0; w < m_vehicleData.wheelsPerAxle; w++, wheelIndex++ )
{
IVP_Real_Object *pWheel = CreateWheel( wheelIndex, m_vehicleData.axles[i] );
if ( pWheel )
{
// Create ray trace data for wheel.
if ( m_bTraceData )
{
CreateTraceData( wheelIndex, m_vehicleData.axles[i] );
}
ivpVehicleData.car_wheel[wheelIndex] = pWheel;
ivpVehicleData.wheel_radius[wheelIndex] = pWheel->get_core()->upper_limit_radius;
ivpVehicleData.wheel_reversed_sign[wheelIndex] = 1.0;
// only for raycast car
ivpVehicleData.friction_of_wheel[wheelIndex] = m_vehicleData.axles[i].wheels.frictionScale;
ivpVehicleData.spring_constant[wheelIndex] = m_vehicleData.axles[i].suspension.springConstant * m_bodyMass;
ivpVehicleData.spring_dampening[wheelIndex] = m_vehicleData.axles[i].suspension.springDamping * m_bodyMass;
ivpVehicleData.spring_dampening_compression[wheelIndex] = m_vehicleData.axles[i].suspension.springDampingCompression * m_bodyMass;
ivpVehicleData.max_body_force[wheelIndex] = m_vehicleData.axles[i].suspension.maxBodyForce * m_bodyMass;
ivpVehicleData.spring_pre_tension[wheelIndex] = -ConvertDistanceToIVP( m_vehicleData.axles[i].wheels.springAdditionalLength );
ivpVehicleData.wheel_pos_Bos[wheelIndex] = m_wheelPosition_Bs[wheelIndex];
if ( m_bTraceData )
{
ivpVehicleData.trace_pos_Bos[wheelIndex] = m_tracePosition_Bs[wheelIndex];
}
m_totalWheelMass += m_vehicleData.axles[i].wheels.mass;
}
}
ivpVehicleData.stabilizer_constant[i] = m_vehicleData.axles[i].suspension.stabilizerConstant * m_bodyMass;
// this should output in radians per second
float radius = ConvertDistanceToIVP( m_vehicleData.axles[i].wheels.radius );
float totalMaxSpeed = max( m_vehicleData.engine.boostMaxSpeed, m_vehicleData.engine.maxSpeed );
ivpVehicleData.wheel_max_rotation_speed[i] = totalMaxSpeed / radius;
if ( radius > m_wheelRadius )
{
m_wheelRadius = radius;
}
}
for ( i = 0; i < m_wheelCount; i++ )
{
m_pWheels[i]->EnableCollisions( true );
}
}
void CVehicleController::ShutdownCarSystem()
{
delete m_pCarSystem;
m_pCarSystem = NULL;
for ( int i = 0; i < m_wheelCount; i++ )
{
if ( m_pWheels[i] )
{
m_pEnv->DestroyObject( m_pWheels[i] );
}
m_pWheels[i] = NULL;
}
}
void CVehicleController::InitVehicleData( const vehicleparams_t &params )
{
m_vehicleData = params;
VehicleDataReload();
}
void CVehicleController::SetSpringLength(int wheelIndex, float length)
{
m_pCarSystem->change_spring_length((IVP_POS_WHEEL)wheelIndex, length);
}
//-----------------------------------------------------------------------------
// Purpose: Allows booster timer to run,
// Returns: true if time still exists
// false if timer has run out (i.e. can use boost again)
//-----------------------------------------------------------------------------
float CVehicleController::UpdateBooster( float dt )
{
m_pCarSystem->update_booster( dt );
m_currentState.boostDelay = m_pCarSystem->get_booster_delay();
return m_currentState.boostDelay;
}
//-----------------------------------------------------------------------------
// Purpose: Are whe boosting?
//-----------------------------------------------------------------------------
bool CVehicleController::IsBoosting( void )
{
return ( m_pCarSystem->get_booster_time_to_go() > 0.0f );
}
//-----------------------------------------------------------------------------
// Purpose: Update the vehicle controller.
//-----------------------------------------------------------------------------
void CVehicleController::Update( float dt, vehicle_controlparams_t &controlsIn )
{
vehicle_controlparams_t controls = controlsIn;
// Speed.
m_currentState.speed = ConvertDistanceToHL( m_pCarSystem->get_body_speed() );
float flSpeed = GAMEVEL_TO_MPH( m_currentState.speed );
float flAbsSpeed = fabsf( flSpeed );
// Calculate the throttle and brake values.
float flThrottle = controls.throttle;
bool bHandbrake = controls.handbrake;
float flBrake = controls.brake;
bool bPowerslide = bHandbrake && ( flAbsSpeed > 18.0f );
if ( bHandbrake )
{
flThrottle = 0.0f;
}
if ( IsBoosting() )
{
controls.boost = true;
flThrottle = flThrottle < 0.0f ? -1.0f : 1.0f;
}
if ( flThrottle == 0.0f && flBrake == 0.0f && !bHandbrake )
{
flBrake = 0.1f;
}
// Update steering.
UpdateSteering( controls, dt, flAbsSpeed );
// Update powerslide.
UpdatePowerslide( controls, bPowerslide, flSpeed );
// Update engine.
UpdateEngine( controls, dt, flThrottle, flBrake, bHandbrake, bPowerslide );
// Update handbrake.
UpdateHandbrake( controls, flThrottle, bHandbrake, bPowerslide );
// Update skidding.
UpdateSkidding( bHandbrake );
// Apply the extra forces to the car (downward, counter-torque, etc.)
UpdateExtraForces();
// Update the physical position of the wheels for raycast vehicles.
UpdateWheelPositions();
}
//-----------------------------------------------------------------------------
// Purpose: Update the steering on the vehicle.
//-----------------------------------------------------------------------------
void CVehicleController::UpdateSteering( const vehicle_controlparams_t &controls, float flDeltaTime, float flSpeed )
{
// Steering - IVP steering is in radians.
float flSteeringAngle = CalcSteering( flDeltaTime, flSpeed, controls.steering, controls.bAnalogSteering );
m_pCarSystem->do_steering( DEG2RAD( flSteeringAngle ), controls.bAnalogSteering );
m_currentState.steeringAngle = flSteeringAngle;
}
//-----------------------------------------------------------------------------
// Purpose: Update the powerslide state (wheel materials).
//-----------------------------------------------------------------------------
void CVehicleController::UpdatePowerslide( const vehicle_controlparams_t &controls, bool bPowerslide, float flSpeed )
{
// Only allow skidding if it is allowed by the vehicle type.
if ( !m_vehicleData.steering.isSkidAllowed )
return;
// Check to see if the vehicle is occupied.
if ( !m_bOccupied )
return;
// Set the powerslide left/right.
bool bPowerslideLeft = bPowerslide && controls.handbrakeLeft;
bool bPowerslideRight = bPowerslide && controls.handbrakeRight;
int iWheel = 0;
unsigned int newTireType = VEHICLE_TIRE_NORMAL;
if ( bPowerslideLeft || bPowerslideRight )
{
newTireType = VEHICLE_TIRE_POWERSLIDE;
}
else if ( bPowerslide )
{
newTireType = VEHICLE_TIRE_BRAKING;
}
if ( newTireType != m_nTireType )
{
for ( int iAxle = 0; iAxle < m_vehicleData.axleCount; ++iAxle )
{
int materialIndex = m_vehicleData.axles[iAxle].wheels.materialIndex;
if ( newTireType == VEHICLE_TIRE_POWERSLIDE && ( m_vehicleData.axles[iAxle].wheels.skidMaterialIndex != - 1 ) )
{
materialIndex = m_vehicleData.axles[iAxle].wheels.skidMaterialIndex;
}
else if ( newTireType == VEHICLE_TIRE_BRAKING && ( m_vehicleData.axles[iAxle].wheels.brakeMaterialIndex != -1 ) )
{
materialIndex = m_vehicleData.axles[iAxle].wheels.brakeMaterialIndex;
}
for ( int iAxleWheel = 0; iAxleWheel < m_vehicleData.wheelsPerAxle; ++iAxleWheel, ++iWheel )
{
m_pWheels[iWheel]->SetMaterialIndex( materialIndex );
}
m_nTireType = newTireType;
}
}
// Push the car a little.
float flFrontAccel = 0.0f;
float flRearAccel = 0.0f;
if ( flSpeed > 0 && (bPowerslideLeft != bPowerslideRight) )
{
// NOTE: positive acceleration is to the left
float powerSlide = RemapValClamped( flSpeed, m_vehicleData.steering.speedSlow, m_vehicleData.steering.speedFast, 0, 1 );
float powerSlideAccel = ConvertDistanceToIVP( m_vehicleData.steering.powerSlideAccel);
if ( bPowerslideLeft )
{
flFrontAccel = powerSlideAccel * powerSlide;
flRearAccel = -powerSlideAccel * powerSlide;
}
else
{
flFrontAccel = -powerSlideAccel * powerSlide;
flRearAccel = powerSlideAccel * powerSlide;
}
}
m_pCarSystem->set_powerslide( flFrontAccel, flRearAccel );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CVehicleController::UpdateEngine( const vehicle_controlparams_t &controls, float flDeltaTime,
float flThrottle, float flBrake, bool bHandbrake, bool bPowerslide )
{
bool bTorqueBoost = UpdateEngineTurboStart( controls, flDeltaTime );
CalcEngine( flThrottle, flBrake, bHandbrake, controls.steering, bTorqueBoost );
UpdateEngineTurboFinish();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CVehicleController::UpdateEngineTurboStart( const vehicle_controlparams_t &controls, float flDeltaTime )
{
bool bTorqueBoost = false;
if ( controls.boost > 0 )
{
if ( m_vehicleData.engine.torqueBoost )
{
// Turbo will be applied at the engine level.
bTorqueBoost = true;
m_pCarSystem->activate_booster( 0.0f, m_vehicleData.engine.boostDuration, m_vehicleData.engine.boostDelay );
}
else
{
// Activate the turbo force booster - applied to vehicle body.
m_pCarSystem->activate_booster( m_vehicleData.engine.boostForce * controls.boost, m_vehicleData.engine.boostDuration, m_vehicleData.engine.boostDelay );
}
}
m_pCarSystem->update_booster( flDeltaTime );
m_currentState.boostDelay = m_pCarSystem->get_booster_delay();
m_currentState.isTorqueBoosting = bTorqueBoost;
return bTorqueBoost;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CVehicleController::UpdateEngineTurboFinish( void )
{
if ( m_vehicleData.engine.boostDuration + m_vehicleData.engine.boostDelay > 0 ) // watch out for div by zero
{
if ( m_currentState.boostDelay > 0 )
{
m_currentState.boostTimeLeft = 100 - 100 * ( m_currentState.boostDelay / ( m_vehicleData.engine.boostDuration + m_vehicleData.engine.boostDelay ) );
}
else
{
m_currentState.boostTimeLeft = 100; // ready to go any time
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Update the handbrake.
//-----------------------------------------------------------------------------
void CVehicleController::UpdateHandbrake( const vehicle_controlparams_t &controls, float flThrottle, bool bHandbrake, bool bPowerslide )
{
// Get the current vehicle speed.
m_currentState.speed = ConvertDistanceToHL( m_pCarSystem->get_body_speed() );
if ( !bPowerslide )
{
// HACK! Allowing you to overcome gravity at low throttle.
if ( ( flThrottle < 0.0f && m_currentState.speed > THROTTLE_OPPOSING_FORCE_EPSILON ) ||
( flThrottle > 0.0f && m_currentState.speed < -THROTTLE_OPPOSING_FORCE_EPSILON ) )
{
bHandbrake = true;
}
}
if ( bHandbrake )
{
// HACKHACK: only allow the handbrake when the wheels have contact with something
// otherwise they will affect the car in an undesirable way
bHandbrake = false;
for ( int iWheel = 0; iWheel < m_wheelCount; ++iWheel )
{
if ( m_pWheels[iWheel]->GetContactPoint(NULL, NULL) )
{
bHandbrake = true;
break;
}
}
}
bool currentHandbrake = (m_vehicleFlags & FVEHICLE_HANDBRAKE_ON) ? true : false;
if ( bHandbrake != currentHandbrake )
{
if ( bHandbrake )
{
m_vehicleFlags |= FVEHICLE_HANDBRAKE_ON;
}
else
{
m_vehicleFlags &= ~FVEHICLE_HANDBRAKE_ON;
}
for ( int iWheel = 0; iWheel < m_wheelCount; ++iWheel )
{
m_pCarSystem->fix_wheel( ( IVP_POS_WHEEL )iWheel, bHandbrake ? IVP_TRUE : IVP_FALSE );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CVehicleController::UpdateSkidding( bool bHandbrake )
{
m_currentState.skidSpeed = 0.0f;
m_currentState.skidMaterial = 0;
m_currentState.wheelsInContact = m_wheelCount;
m_currentState.wheelsNotInContact = 0;
if ( m_vehicleData.steering.isSkidAllowed )
{
// Estimate rot speed based on current speed and the front wheels radius
float flAbsSpeed = fabs( m_currentState.speed );
Vector contact;
Vector velocity;
int surfaceProps;
m_currentState.wheelsInContact = 0;
m_currentState.wheelsNotInContact = 0;
for( int iWheel = 0; iWheel < m_wheelCount; ++iWheel )
{
if ( GetWheelContactPoint( iWheel, &contact, &surfaceProps ) )
{
// NOTE: The wheel should be translating by the negative of the speed a point in contact with the surface
// is moving. So the net velocity on the surface is zero if that wheel is 100% engaged in driving the car
// any velocity in excess of this gets compared against the threshold for skidding
m_pWheels[iWheel]->GetVelocityAtPoint( contact, &velocity );
float speed = velocity.Length();
if ( speed > m_currentState.skidSpeed || m_currentState.skidSpeed <= 0.0f )
{
m_currentState.skidSpeed = speed;
m_currentState.skidMaterial = surfaceProps;
}
m_currentState.wheelsInContact++;
}
else
{
m_currentState.wheelsNotInContact++;
}
}
// Check for locked wheels.
if ( bHandbrake && ( flAbsSpeed > 30 ) )
{
m_currentState.skidSpeed = flAbsSpeed;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Apply extra forces to the vehicle. The downward force, counter-
// torque etc.
//-----------------------------------------------------------------------------
void CVehicleController::UpdateExtraForces( void )
{
// Extra downward force.
IVP_Cache_Object *co = m_pCarBody->GetObject()->get_cache_object();
float y_val = co->m_world_f_object.get_elem( IVP_INDEX_Y, IVP_INDEX_Y );
if ( fabs( y_val ) < 0.05 )
{
m_pCarSystem->change_body_downforce( m_vehicleData.body.tiltForce * m_gravityLength * m_bodyMass );
}
else
{
m_pCarSystem->change_body_downforce( 0.0 );
}
co->remove_reference();
// Counter-torque.
if ( m_nVehicleType == VEHICLE_TYPE_CAR_WHEELS )
{
m_pCarSystem->update_body_countertorque();
}
// if the car has a global angular velocity limit, apply that constraint
AngularImpulse angVel;
m_pCarBody->GetVelocity( NULL, &angVel );
if ( m_vehicleData.body.maxAngularVelocity > 0 && angVel.Length() > m_vehicleData.body.maxAngularVelocity )
{
VectorNormalize(angVel);
angVel *= m_vehicleData.body.maxAngularVelocity;
m_pCarBody->SetVelocityInstantaneous( NULL, &angVel );
}
}
//-----------------------------------------------------------------------------
// Purpose: Update the physical position of the wheels for raycast vehicles.
// NOTE: Raycast boat doesn't have wheels.
//-----------------------------------------------------------------------------
void CVehicleController::UpdateWheelPositions( void )
{
if ( m_nVehicleType == VEHICLE_TYPE_CAR_RAYCAST )
{
m_pCarSystem->update_wheel_positions();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CVehicleController::CalcSteering( float dt, float speed, float steering, bool bAnalog )
{
float degrees = RemapValClamped( speed, m_vehicleData.steering.speedSlow, m_vehicleData.steering.speedFast, m_vehicleData.steering.degreesSlow, m_vehicleData.steering.degreesFast );
float speedGame = MPH_TO_GAMEVEL(speed);
if ( speedGame > m_vehicleData.engine.maxSpeed )
{
degrees = RemapValClamped( speedGame, m_vehicleData.engine.maxSpeed, m_vehicleData.engine.boostMaxSpeed, m_vehicleData.steering.degreesFast, m_vehicleData.steering.degreesBoost );
}
if ( m_vehicleData.steering.steeringExponent != 0 )
{
float sign = steering < 0 ? -1 : 1;
float absSteering = fabs(steering);
if ( bAnalog )
{
// analog steering is directly mapped, not integrated, so go ahead and map the full range using the exponent
// then clamp to the output cone - keeps stick position:turn rate constant
// NOTE: Also hardcode exponent to 2 because we can't add a script entry at this point
float output = pow(absSteering, 2.0f) * sign * m_vehicleData.steering.degreesSlow;
return clamp(output, -degrees, degrees );
}
// digital steering is integrated, keep time to full turn rate constant
return pow(absSteering, m_vehicleData.steering.steeringExponent) * sign * degrees;
}
return steering * degrees;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CVehicleController::CalcEngineTransmission( float flThrottle )
{
// Automatic Transmission?
if ( !m_vehicleData.engine.isAutoTransmission )
return;
// Calculate the average rotational speed of the vehicle's wheels.
float flAvgRotSpeed = 0.0;
for( int iWheel = 0; iWheel < m_wheelCount; ++iWheel )
{
float flRotSpeed = fabs( m_pCarSystem->get_wheel_angular_velocity( IVP_POS_WHEEL( iWheel ) ) );
flAvgRotSpeed += flRotSpeed;
}
flAvgRotSpeed *= 0.5f / ( float )IVP_PI / m_wheelCount;
float flEstEngineRPM = flAvgRotSpeed * m_vehicleData.engine.axleRatio * m_vehicleData.engine.gearRatio[m_currentState.gear] * 60;
// Only shift up when going forward (throttling).
if ( flThrottle > 0.0f )
{
// Shift up?, top gear is gearcount-1 (0 based)
while ( ( flEstEngineRPM > m_vehicleData.engine.shiftUpRPM ) && ( m_currentState.gear < m_vehicleData.engine.gearCount-1 ) )
{
m_currentState.gear++;
flEstEngineRPM = flAvgRotSpeed * m_vehicleData.engine.axleRatio * m_vehicleData.engine.gearRatio[m_currentState.gear] * 60;
}
}
// Downshift?
while ( ( flEstEngineRPM < m_vehicleData.engine.shiftDownRPM ) && ( m_currentState.gear > 0 ) )
{
m_currentState.gear--;
flEstEngineRPM = flAvgRotSpeed * m_vehicleData.engine.axleRatio * m_vehicleData.engine.gearRatio[m_currentState.gear] * 60;
}
m_currentState.engineRPM = flEstEngineRPM;
}
//-----------------------------------------------------------------------------
// Purpose:
// throttle goes forward and backward, [-1, 1]
// brake_val [0..1]
//-----------------------------------------------------------------------------
void CVehicleController::CalcEngine( float throttle, float brake_val, bool handbrake, float steeringVal, bool torqueBoost )
{
// Update the engine transmission.
CalcEngineTransmission( throttle );
// Get the speed of the vehicle.
float flAbsSpeed = fabs( m_currentState.speed );
// Speed governor
if ( IsPC() )
{
float maxSpeed = torqueBoost ? m_vehicleData.engine.boostMaxSpeed : m_vehicleData.engine.maxSpeed;
maxSpeed = max(1.f,maxSpeed); // make sure this is non-zero before the divide
if ( (throttle > 0) && (flAbsSpeed > maxSpeed) )
{
float frac = flAbsSpeed / maxSpeed;
if ( frac > m_vehicleData.engine.autobrakeSpeedGain )
{
throttle = 0;
brake_val = (frac - 1.0f) * m_vehicleData.engine.autobrakeSpeedFactor;
if ( m_currentState.wheelsInContact == 0 )
{
brake_val = 0;
}
}
throttle *= 0.1f;
}
}
else // consoles
{
if ( ( throttle > 0 ) && ( ( !torqueBoost && flAbsSpeed > (m_vehicleData.engine.maxSpeed * throttle) ) ||
( torqueBoost && flAbsSpeed > m_vehicleData.engine.boostMaxSpeed) ) )
{
throttle *= 0.1f;
}
}
// Check for reverse - both of these "governors" or horrible and need to be redone before we ship!
if ( ( throttle < 0 ) && ( !torqueBoost && ( flAbsSpeed > m_vehicleData.engine.maxRevSpeed ) ) )
{
throttle *= 0.1f;
}
if ( throttle != 0.0 )
{
m_vehicleFlags &= ~FVEHICLE_THROTTLE_STOPPED;
// calculate the force that propels the car
const float watt_per_hp = 745.0f;
const float seconds_per_minute = 60.0f;
float wheel_force_by_throttle = throttle *
m_vehicleData.engine.horsepower * (watt_per_hp * seconds_per_minute) *
m_vehicleData.engine.gearRatio[m_currentState.gear] * m_vehicleData.engine.axleRatio /
(m_vehicleData.engine.maxRPM * m_wheelRadius * (2 * IVP_PI));
if ( m_currentState.engineRPM >= m_vehicleData.engine.maxRPM )
{
wheel_force_by_throttle = 0;
}
int wheelIndex = 0;
for ( int i = 0; i < m_vehicleData.axleCount; i++ )
{
float axleFactor = m_vehicleData.axles[i].torqueFactor * m_torqueScale;
float boostFactor = 0.5f;
if ( torqueBoost && IsBoosting() )
{
// reduce the boost at low speeds and high turns since this usually just makes the tires spin
// this means you only get the full boost when travelling in a straight line at high speed
float speedFactor = RemapValClamped( flAbsSpeed, 0, m_vehicleData.engine.maxSpeed, 0.1f, 1.0f );
float turnFactor = 1.0f - (fabs(steeringVal) * 0.95f);
float dampedBoost = m_vehicleData.engine.boostForce * speedFactor * turnFactor;
if ( dampedBoost > boostFactor )
{
boostFactor = dampedBoost;
}
//Msg("Boost applied %.2f, speed %.2f, turn %.2f\n", boostFactor, speedFactor, turnFactor );
}
float axleTorque = boostFactor * wheel_force_by_throttle * axleFactor * ConvertDistanceToIVP( m_vehicleData.axles[i].wheels.radius );
for ( int w = 0; w < m_vehicleData.wheelsPerAxle; w++, wheelIndex++ )
{
float torqueVal = axleTorque;
m_pCarSystem->change_wheel_torque((IVP_POS_WHEEL)wheelIndex, torqueVal);
}
}
}
else if ( brake_val != 0 )
{
m_vehicleFlags &= ~FVEHICLE_THROTTLE_STOPPED;
// Brake to slow down the wheel.
float wheel_force_by_brake = brake_val * m_gravityLength * ( m_bodyMass + m_totalWheelMass );
float sign = m_currentState.speed >= 0.0f ? -1.0f : 1.0f;
int wheelIndex = 0;
for ( int i = 0; i < m_vehicleData.axleCount; i++ )
{
float torque_val = 0.5 * sign * wheel_force_by_brake * m_vehicleData.axles[i].brakeFactor * ConvertDistanceToIVP( m_vehicleData.axles[i].wheels.radius );
for ( int w = 0; w < m_vehicleData.wheelsPerAxle; w++, wheelIndex++ )
{
m_pCarSystem->change_wheel_torque( ( IVP_POS_WHEEL )wheelIndex, torque_val );
}
}
}
else if ( !(m_vehicleFlags & FVEHICLE_THROTTLE_STOPPED) )
{
m_vehicleFlags |= FVEHICLE_THROTTLE_STOPPED;
for ( int w = 0; w < m_wheelCount; w++ )
{
m_pCarSystem->change_wheel_torque((IVP_POS_WHEEL)w, 0);
}
}
// Update the throttle - primarily for the airboat!
m_pCarSystem->update_throttle( throttle );
}
//-----------------------------------------------------------------------------
// Purpose: Get debug rendering data from the ipion physics system.
//-----------------------------------------------------------------------------
void CVehicleController::GetCarSystemDebugData( vehicle_debugcarsystem_t &debugCarSystem )
{
IVP_CarSystemDebugData_t carSystemDebugData;
memset(&carSystemDebugData,0,sizeof(carSystemDebugData));
m_pCarSystem->GetCarSystemDebugData( carSystemDebugData );
// Raycast car wheel trace data.
for ( int iWheel = 0; iWheel < VEHICLE_DEBUGRENDERDATA_MAX_WHEELS; ++iWheel )
{
debugCarSystem.vecWheelRaycasts[iWheel][0].x = carSystemDebugData.wheelRaycasts[iWheel][0].k[0];
debugCarSystem.vecWheelRaycasts[iWheel][0].y = carSystemDebugData.wheelRaycasts[iWheel][0].k[1];
debugCarSystem.vecWheelRaycasts[iWheel][0].z = carSystemDebugData.wheelRaycasts[iWheel][0].k[2];
debugCarSystem.vecWheelRaycasts[iWheel][1].x = carSystemDebugData.wheelRaycasts[iWheel][1].k[0];
debugCarSystem.vecWheelRaycasts[iWheel][1].y = carSystemDebugData.wheelRaycasts[iWheel][1].k[1];
debugCarSystem.vecWheelRaycasts[iWheel][1].z = carSystemDebugData.wheelRaycasts[iWheel][1].k[2];
debugCarSystem.vecWheelRaycastImpacts[iWheel] = debugCarSystem.vecWheelRaycasts[iWheel][0] + ( carSystemDebugData.wheelRaycastImpacts[iWheel] *
( debugCarSystem.vecWheelRaycasts[iWheel][1] - debugCarSystem.vecWheelRaycasts[iWheel][0] ) );
}
ConvertPositionToHL( carSystemDebugData.backActuatorLeft, debugCarSystem.vecAxlePos[0] );
ConvertPositionToHL( carSystemDebugData.backActuatorRight, debugCarSystem.vecAxlePos[1] );
ConvertPositionToHL( carSystemDebugData.frontActuatorLeft, debugCarSystem.vecAxlePos[2] );
// vecAxlePos only has three elements so this line is illegal. The mapping of actuators
// to axles seems dodgy anyway.
//ConvertPositionToHL( carSystemDebugData.frontActuatorRight, debugCarSystem.vecAxlePos[3] );
}
//-----------------------------------------------------------------------------
// Save/load
//-----------------------------------------------------------------------------
void CVehicleController::WriteToTemplate( vphysics_save_cvehiclecontroller_t &controllerTemplate )
{
// Get rid of the handbrake flag. The car keeps the flag and will reset it fixing wheels,
// else the system thinks it already fixed the wheels on load and the car roles.
m_vehicleFlags &= ~FVEHICLE_HANDBRAKE_ON;
controllerTemplate.m_pCarBody = m_pCarBody;
controllerTemplate.m_wheelCount = m_wheelCount;
controllerTemplate.m_wheelRadius = m_wheelRadius;
controllerTemplate.m_bodyMass = m_bodyMass;
controllerTemplate.m_totalWheelMass = m_totalWheelMass;
controllerTemplate.m_gravityLength = m_gravityLength;
controllerTemplate.m_torqueScale = m_torqueScale;
controllerTemplate.m_vehicleFlags = m_vehicleFlags;
controllerTemplate.m_nTireType = m_nTireType;
controllerTemplate.m_nVehicleType = m_nVehicleType;
controllerTemplate.m_bTraceData = m_bTraceData;
controllerTemplate.m_bOccupied = m_bOccupied;
controllerTemplate.m_bEngineDisable = m_bEngineDisable;
memcpy( &controllerTemplate.m_currentState, &m_currentState, sizeof(m_currentState) );
memcpy( &controllerTemplate.m_vehicleData, &m_vehicleData, sizeof(m_vehicleData) );
for (int i = 0; i < VEHICLE_MAX_WHEEL_COUNT; ++i )
{
controllerTemplate.m_pWheels[i] = m_pWheels[i];
ConvertPositionToHL( m_wheelPosition_Bs[i], controllerTemplate.m_wheelPosition_Bs[i] );
ConvertPositionToHL( m_tracePosition_Bs[i], controllerTemplate.m_tracePosition_Bs[i] );
}
m_flVelocity[0] = m_flVelocity[1] = m_flVelocity[2] = 0.0f;
if ( m_pCarBody )
{
IVP_U_Float_Point &speed = m_pCarBody->GetObject()->get_core()->speed;
controllerTemplate.m_flVelocity[0] = speed.k[0];
controllerTemplate.m_flVelocity[1] = speed.k[1];
controllerTemplate.m_flVelocity[2] = speed.k[2];
}
}
// JAY: Keep this around for now while we still have a bunch of games saved with the old
// vehicle controls. We won't ship this, but it lets us debug
#define OLD_SAVED_GAME 1
#if OLD_SAVED_GAME
#define SET_DEFAULT(x,y) { if ( x == 0 ) x = y; }
#endif
void CVehicleController::InitFromTemplate( CPhysicsEnvironment *pEnv, void *pGameData,
IPhysicsGameTrace *pGameTrace, const vphysics_save_cvehiclecontroller_t &controllerTemplate )
{
m_pEnv = pEnv;
m_pGameTrace = pGameTrace;
m_pCarBody = controllerTemplate.m_pCarBody;
m_wheelCount = controllerTemplate.m_wheelCount;
m_wheelRadius = controllerTemplate.m_wheelRadius;
m_bodyMass = controllerTemplate.m_bodyMass;
m_totalWheelMass = controllerTemplate.m_totalWheelMass;
m_gravityLength = controllerTemplate.m_gravityLength;
m_torqueScale = controllerTemplate.m_torqueScale;
m_vehicleFlags = controllerTemplate.m_vehicleFlags;
m_nTireType = controllerTemplate.m_nTireType;
m_nVehicleType = controllerTemplate.m_nVehicleType;
m_bTraceData = controllerTemplate.m_bTraceData;
m_bOccupied = controllerTemplate.m_bOccupied;
m_bEngineDisable = controllerTemplate.m_bEngineDisable;
m_pCarSystem = NULL;
memcpy( &m_currentState, &controllerTemplate.m_currentState, sizeof(m_currentState) );
memcpy( &m_vehicleData, &controllerTemplate.m_vehicleData, sizeof(m_vehicleData) );
memcpy( &m_flVelocity, controllerTemplate.m_flVelocity, sizeof(m_flVelocity) );
#if OLD_SAVED_GAME
SET_DEFAULT( m_torqueScale, 1.0 );
SET_DEFAULT( m_vehicleData.steering.steeringRateSlow, 4.5 );
SET_DEFAULT( m_vehicleData.steering.steeringRateFast, 0.5 );
SET_DEFAULT( m_vehicleData.steering.steeringRestRateSlow, 3.0 );
SET_DEFAULT( m_vehicleData.steering.steeringRestRateFast, 1.8 );
SET_DEFAULT( m_vehicleData.steering.speedSlow, m_vehicleData.engine.maxSpeed*0.25 );
SET_DEFAULT( m_vehicleData.steering.speedFast, m_vehicleData.engine.maxSpeed*0.75 );
SET_DEFAULT( m_vehicleData.steering.degreesSlow, 50 );
SET_DEFAULT( m_vehicleData.steering.degreesFast, 18 );
SET_DEFAULT( m_vehicleData.steering.degreesBoost, 10 );
SET_DEFAULT( m_vehicleData.steering.turnThrottleReduceSlow, 0.3 );
SET_DEFAULT( m_vehicleData.steering.turnThrottleReduceFast, 3 );
SET_DEFAULT( m_vehicleData.steering.brakeSteeringRateFactor, 6 );
SET_DEFAULT( m_vehicleData.steering.throttleSteeringRestRateFactor, 2 );
SET_DEFAULT( m_vehicleData.steering.boostSteeringRestRateFactor, 1 );
SET_DEFAULT( m_vehicleData.steering.boostSteeringRateFactor, 1 );
SET_DEFAULT( m_vehicleData.steering.powerSlideAccel, 200 );
SET_DEFAULT( m_vehicleData.engine.autobrakeSpeedGain, 1.0 );
SET_DEFAULT( m_vehicleData.engine.autobrakeSpeedFactor, 2.0 );
#endif
for (int i = 0; i < VEHICLE_MAX_WHEEL_COUNT; ++i )
{
m_pWheels[i] = controllerTemplate.m_pWheels[i];
ConvertPositionToIVP( controllerTemplate.m_wheelPosition_Bs[i], m_wheelPosition_Bs[i] );
ConvertPositionToIVP( controllerTemplate.m_tracePosition_Bs[i], m_tracePosition_Bs[i] );
}
CreateIVPObjects( );
// HACKHACK: vehicle wheels don't have valid friction at startup, clearing the body's angular velocity keeps
// this fact from affecting the vehicle dynamics in any noticeable way
// using growFriction will re-establish the contact point with moveable objects, but the friction that
// occurs afterward is not the same across the save even when that is extended to include static objects
if ( m_pCarBody )
{
// clear angVel
m_pCarBody->SetVelocity( NULL, &vec3_origin );
m_pCarBody->GetObject()->get_core()->speed_change.set( m_flVelocity[0], m_flVelocity[1], m_flVelocity[2] );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CVehicleController::OnVehicleEnter( void )
{
m_bOccupied = true;
if ( m_nVehicleType == VEHICLE_TYPE_AIRBOAT_RAYCAST )
{
float flDampSpeed = 0.0f;
float flDampRotSpeed = 0.0f;
m_pCarBody->SetDamping( &flDampSpeed, &flDampRotSpeed );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CVehicleController::OnVehicleExit( void )
{
m_bOccupied = false;
// Reset the vehicle tires when exiting the vehicle.
if ( m_vehicleData.steering.isSkidAllowed )
{
int iWheel = 0;
for ( int iAxle = 0; iAxle < m_vehicleData.axleCount; ++iAxle )
{
for ( int iAxleWheel = 0; iAxleWheel < m_vehicleData.wheelsPerAxle; ++iAxleWheel, ++iWheel )
{
// Change back to normal tires.
if ( m_nTireType != VEHICLE_TIRE_NORMAL )
{
m_pWheels[iWheel]->SetMaterialIndex( m_vehicleData.axles[iAxle].wheels.materialIndex );
}
m_pCarSystem->fix_wheel( ( IVP_POS_WHEEL )iWheel, IVP_TRUE );
}
}
m_nTireType = VEHICLE_TIRE_NORMAL;
m_currentState.skidSpeed = 0.0f;
}
if ( m_nVehicleType == VEHICLE_TYPE_AIRBOAT_RAYCAST )
{
float flDampSpeed = 1.0f;
float flDampRotSpeed = 1.0f;
m_pCarBody->SetDamping( &flDampSpeed, &flDampRotSpeed );
}
SetEngineDisabled( false );
}
//-----------------------------------------------------------------------------
// Class factory
//-----------------------------------------------------------------------------
IPhysicsVehicleController *CreateVehicleController( CPhysicsEnvironment *pEnv, CPhysicsObject *pBodyObject, const vehicleparams_t &params, unsigned int nVehicleType, IPhysicsGameTrace *pGameTrace )
{
CVehicleController *pController = new CVehicleController( params, pEnv, nVehicleType, pGameTrace );
pController->InitCarSystem( pBodyObject );
return pController;
}
bool SavePhysicsVehicleController( const physsaveparams_t &params, CVehicleController *pVehicleController )
{
vphysics_save_cvehiclecontroller_t controllerTemplate;
memset( &controllerTemplate, 0, sizeof(controllerTemplate) );
pVehicleController->WriteToTemplate( controllerTemplate );
params.pSave->WriteAll( &controllerTemplate );
return true;
}
bool RestorePhysicsVehicleController( const physrestoreparams_t &params, CVehicleController **ppVehicleController )
{
*ppVehicleController = new CVehicleController;
vphysics_save_cvehiclecontroller_t controllerTemplate;
memset( &controllerTemplate, 0, sizeof(controllerTemplate) );
params.pRestore->ReadAll( &controllerTemplate );
(*ppVehicleController)->InitFromTemplate( static_cast<CPhysicsEnvironment *>(params.pEnvironment),
params.pGameData, params.pGameTrace, controllerTemplate );
return true;
}
Reference in New Issue View Git Blame Copy Permalink