tf2/tf2_src/vphysics/physics_vehicle.cpp

//========= 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;
}