path: root/vphysics/physics_airboat.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: The airboat, a sporty nimble water craft.
//
//=============================================================================//

#include "cbase.h"
#include "physics_airboat.h"
#include "cmodel.h"
#include <ivp_ray_solver.hxx>


// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#ifdef _X360 
	#define AIRBOAT_STEERING_RATE_MIN			0.000225f
	#define AIRBOAT_STEERING_RATE_MAX			(10.0f * AIRBOAT_STEERING_RATE_MIN)
	#define AIRBOAT_STEERING_INTERVAL			1.5f
#else
	#define AIRBOAT_STEERING_RATE_MIN			0.00045f
	#define AIRBOAT_STEERING_RATE_MAX			(5.0f * AIRBOAT_STEERING_RATE_MIN)
	#define AIRBOAT_STEERING_INTERVAL			0.5f
#endif //_X360

#define AIRBOAT_ROT_DRAG					0.00004f
#define AIRBOAT_ROT_DAMPING					0.001f

// Mass-independent thrust values
#define AIRBOAT_THRUST_MAX					11.0f		// N / kg
#define AIRBOAT_THRUST_MAX_REVERSE			7.5f		// N / kg

// Mass-independent drag values
#define AIRBOAT_WATER_DRAG_LEFT_RIGHT		0.6f
#define AIRBOAT_WATER_DRAG_FORWARD_BACK		0.005f
#define AIRBOAT_WATER_DRAG_UP_DOWN			0.0025f

#define AIRBOAT_GROUND_DRAG_LEFT_RIGHT		2.0
#define AIRBOAT_GROUND_DRAG_FORWARD_BACK	1.0
#define AIRBOAT_GROUND_DRAG_UP_DOWN			0.8

#define AIRBOAT_DRY_FRICTION_SCALE		0.6f		// unitless, reduces our friction on all surfaces other than water

#define AIRBOAT_RAYCAST_DIST			0.35f		// m (~14in)
#define AIRBOAT_RAYCAST_DIST_WATER_LOW	0.1f		// m (~4in)
#define AIRBOAT_RAYCAST_DIST_WATER_HIGH	0.35f		// m (~16in)

// Amplitude of wave noise. Blend from max to min as speed increases.
#define AIRBOAT_WATER_NOISE_MIN			0.01		// m (~0.4in)
#define AIRBOAT_WATER_NOISE_MAX			0.03		// m (~1.2in)

// Frequency of wave noise. Blend from min to max as speed increases.
#define AIRBOAT_WATER_FREQ_MIN			1.5
#define AIRBOAT_WATER_FREQ_MAX			1.5

// Phase difference in wave noise between left and right pontoons
// Blend from max to min as speed increases.
#define AIRBOAT_WATER_PHASE_MIN			0.0			// s
#define AIRBOAT_WATER_PHASE_MAX			1.5			// s


#define AIRBOAT_GRAVITY					9.81f		// m/s2

// Pontoon indices
enum
{
	AIRBOAT_PONTOON_FRONT_LEFT = 0,
	AIRBOAT_PONTOON_FRONT_RIGHT,
	AIRBOAT_PONTOON_REAR_LEFT,
	AIRBOAT_PONTOON_REAR_RIGHT,
};


class IVP_Ray_Solver_Template;
class IVP_Ray_Hit;
class IVP_Event_Sim;


//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
class CAirboatFrictionData : public IPhysicsCollisionData
{
public:
	CAirboatFrictionData()
	{
		m_vecPoint.Init( 0, 0, 0 );
		m_vecNormal.Init( 0, 0, 0 );
		m_vecVelocity.Init( 0, 0, 0 );
	}

	virtual void GetSurfaceNormal( Vector &out )
	{
		out = m_vecPoint;
	}

	virtual void GetContactPoint( Vector &out )
	{
		out = m_vecNormal;
	}

	virtual void GetContactSpeed( Vector &out )
	{
		out = m_vecVelocity;
	}

public:
	Vector m_vecPoint;
	Vector m_vecNormal;
	Vector m_vecVelocity;
};


//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CPhysics_Airboat::CPhysics_Airboat( IVP_Environment *pEnv, const IVP_Template_Car_System *pCarSystem,
								    IPhysicsGameTrace *pGameTrace )
{
	InitRaycastCarBody( pCarSystem );
	InitRaycastCarEnvironment( pEnv, pCarSystem );
	InitRaycastCarWheels( pCarSystem );
	InitRaycastCarAxes( pCarSystem );	

	InitAirboat( pCarSystem );
	m_pGameTrace = pGameTrace;

    m_SteeringAngle = 0;
	m_bSteeringReversed = false;

	m_flThrust = 0;

	m_bAirborne = false;
	m_flAirTime = 0;
	m_bWeakJump = false;

	m_flPitchErrorPrev = 0;
	m_flRollErrorPrev = 0;
}


//-----------------------------------------------------------------------------
// Purpose: Deconstructor
//-----------------------------------------------------------------------------
CPhysics_Airboat::~CPhysics_Airboat()
{
    m_pAirboatBody->get_environment()->get_controller_manager()->remove_controller_from_environment( this, IVP_TRUE );
}


//-----------------------------------------------------------------------------
// Purpose: Setup the car system wheels.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::InitAirboat( const IVP_Template_Car_System *pCarSystem )
{
	for ( int iWheel = 0; iWheel < pCarSystem->n_wheels; ++iWheel )
	{
		m_pWheels[iWheel] = pCarSystem->car_wheel[iWheel];
		m_pWheels[iWheel]->enable_collision_detection( IVP_FALSE );
	}

	CPhysicsObject* pBodyObject = static_cast<CPhysicsObject*>(pCarSystem->car_body->client_data);

	pBodyObject->EnableGravity( false );

	// We do our own buoyancy simulation.
	pBodyObject->SetCallbackFlags( pBodyObject->GetCallbackFlags() & ~CALLBACK_DO_FLUID_SIMULATION );
}


//-----------------------------------------------------------------------------
// Purpose: Get the raycast wheel.
//-----------------------------------------------------------------------------
IPhysicsObject *CPhysics_Airboat::GetWheel( int index )
{
	Assert( index >= 0 );
	Assert( index < n_wheels );

	return ( IPhysicsObject* )m_pWheels[index]->client_data;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysics_Airboat::SetWheelFriction( int iWheel, float flFriction )
{
	change_friction_of_wheel( IVP_POS_WHEEL( iWheel ), flFriction );
}


//-----------------------------------------------------------------------------
// Purpose: Returns an amount to add to the front pontoon raycasts to simulate wave noise.
// Input  : nPontoonIndex - Which pontoon we're dealing with (0 or 1).
//			flSpeedRatio - Speed as a ratio of max speed [0..1]
//-----------------------------------------------------------------------------
float CPhysics_Airboat::ComputeFrontPontoonWaveNoise( int nPontoonIndex, float flSpeedRatio )
{
	// Add in sinusoidal noise cause by undulating water. Reduce the amplitude of the noise at higher speeds.
	IVP_FLOAT flNoiseScale = RemapValClamped( 1.0 - flSpeedRatio, 0, 1, AIRBOAT_WATER_NOISE_MIN, AIRBOAT_WATER_NOISE_MAX );

	// Apply a phase shift between left and right pontoons to simulate waves passing under the boat.
	IVP_FLOAT flPhaseShift = 0;
	if ( flSpeedRatio < 0.3 )
	{
		// BUG: this allows a discontinuity in the waveform - use two superimposed sine waves instead?
		flPhaseShift = nPontoonIndex * AIRBOAT_WATER_PHASE_MAX;
	}

	// Increase the wave frequency as speed increases.
	IVP_FLOAT flFrequency = RemapValClamped( flSpeedRatio, 0, 1, AIRBOAT_WATER_FREQ_MIN, AIRBOAT_WATER_FREQ_MAX );

	//Msg( "Wave amp=%f, freq=%f, phase=%f\n", flNoiseScale, flFrequency, flPhaseShift );
	return flNoiseScale * sin( flFrequency * ( m_pCore->environment->get_current_time().get_seconds() + flPhaseShift ) );
}


//-----------------------------------------------------------------------------
// Purpose:: Convert data to HL2 measurements, and test direction of raycast.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::pre_raycasts_gameside( int nRaycastCount, IVP_Ray_Solver_Template *pRays,
											  Ray_t *pGameRays, IVP_Raycast_Airboat_Impact *pImpacts )
{
	IVP_FLOAT flForwardSpeedRatio = clamp( m_vecLocalVelocity.k[2] / 10.0f, 0.f, 1.0f );
	//Msg( "flForwardSpeedRatio = %f\n", flForwardSpeedRatio );

	IVP_FLOAT flSpeed = ( IVP_FLOAT )m_pCore->speed.real_length();
	IVP_FLOAT flSpeedRatio = clamp( flSpeed / 15.0f, 0.f, 1.0f );
	if ( !m_flThrust )
	{
		flForwardSpeedRatio *= 0.5;
	}

	// This is a little weird. We adjust the front pontoon ray lengths based on forward velocity,
	// but ONLY if both pontoons are in the water, which we won't know until we do the raycast.
	// So we do most of the work here, and cache some of the results to use them later.
	Vector vecStart[4];
	Vector vecDirection[4];
	Vector vecZero( 0.0f, 0.0f, 0.0f );

	int nFrontPontoonsInWater = 0;

	int iRaycast;
	for ( iRaycast = 0; iRaycast < nRaycastCount; ++iRaycast )
	{
		// Setup the ray.
		ConvertPositionToHL( pRays[iRaycast].ray_start_point, vecStart[iRaycast] );
		ConvertDirectionToHL( pRays[iRaycast].ray_normized_direction, vecDirection[iRaycast] );

		float flRayLength = IVP2HL( pRays[iRaycast].ray_length );

		// Check to see if that point is in water.
		pImpacts[iRaycast].bInWater = IVP_FALSE;
		if ( m_pGameTrace->VehiclePointInWater( vecStart[iRaycast] ) )
		{
			vecDirection[iRaycast].Negate();
			pImpacts[iRaycast].bInWater = IVP_TRUE;
		}

		Vector vecEnd = vecStart[iRaycast] + ( vecDirection[iRaycast] * flRayLength );

		// Adjust the trace if the pontoon is in the water.
		if ( m_pGameTrace->VehiclePointInWater( vecEnd ) )
		{
			// Reduce the ray length in the water.
			pRays[iRaycast].ray_length = AIRBOAT_RAYCAST_DIST_WATER_LOW;

			if ( iRaycast < 2 )
			{
				nFrontPontoonsInWater++;

				// Front pontoons.
				// Add a little sinusoidal noise to simulate waves.
				IVP_FLOAT flNoise = ComputeFrontPontoonWaveNoise( iRaycast, flSpeedRatio );
				pRays[iRaycast].ray_length += flNoise;
			}
			else
			{
				// Recalculate the end position in HL coordinates.
				flRayLength = IVP2HL( pRays[iRaycast].ray_length );
				vecEnd = vecStart[iRaycast] + ( vecDirection[iRaycast] * flRayLength );
			}
		}

		pGameRays[iRaycast].Init( vecStart[iRaycast], vecEnd, vecZero, vecZero );
	}

	// If both front pontoons are in the water, add in a bit of lift proportional to our
	// forward speed. We can't do this to only one of the front pontoons because it causes
	// some twist if we do.
	// FIXME: this does some redundant work (computes the wave noise again)
	if ( nFrontPontoonsInWater == 2 )
	{
		for ( int i = 0; i < 2; i++ )
		{
			// Front pontoons.
			// Raise it higher out of the water as we go faster forward.
			pRays[i].ray_length = RemapValClamped( flForwardSpeedRatio, 0, 1, AIRBOAT_RAYCAST_DIST_WATER_LOW, AIRBOAT_RAYCAST_DIST_WATER_HIGH );

			// Add a little sinusoidal noise to simulate waves.
			IVP_FLOAT flNoise = ComputeFrontPontoonWaveNoise( i, flSpeedRatio );
			pRays[i].ray_length += flNoise;

			// Recalculate the end position in HL coordinates.
			float flRayLength = IVP2HL( pRays[i].ray_length );
			Vector vecEnd = vecStart[i] + ( vecDirection[i] * flRayLength );

			pGameRays[i].Init( vecStart[i], vecEnd, vecZero, vecZero );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CPhysics_Airboat::GetWaterDepth( Ray_t *pGameRay, IPhysicsObject *pPhysAirboat )
{
	float flDepth = 0.0f;

	trace_t trace;

	Ray_t waterRay;
	Vector vecStart = pGameRay->m_Start;
	Vector vecEnd( vecStart.x, vecStart.y, vecStart.z + 1000.0f );
	Vector vecZero( 0.0f, 0.0f, 0.0f );
	waterRay.Init( vecStart, vecEnd, vecZero, vecZero );
	m_pGameTrace->VehicleTraceRayWithWater( waterRay, pPhysAirboat->GetGameData(), &trace ); 

	flDepth = 1000.0f * trace.fractionleftsolid;

	return flDepth;
}


//-----------------------------------------------------------------------------
// Purpose: Performs traces to figure out what is at each of the raycast points
//			and fills out the pImpacts array with that information.
// Input  : nRaycastCount - Number of elements in the arrays pointed to by pRays
//				and pImpacts. 
//			pRays - Holds the rays to trace with.
//			pImpacts - Receives the trace results.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::do_raycasts_gameside( int nRaycastCount, IVP_Ray_Solver_Template *pRays,
										     IVP_Raycast_Airboat_Impact *pImpacts )
{
	Assert( nRaycastCount >= 0 );
	Assert( nRaycastCount <= IVP_RAYCAST_AIRBOAT_MAX_WHEELS );

	Ray_t gameRays[IVP_RAYCAST_AIRBOAT_MAX_WHEELS];
	pre_raycasts_gameside( nRaycastCount, pRays, gameRays, pImpacts );

	// Do the raycasts and set impact data.
	trace_t trace;
	for ( int iRaycast = 0; iRaycast < nRaycastCount; ++iRaycast )
	{
		// Trace.
		if ( pImpacts[iRaycast].bInWater )
		{
			// The start position is underwater. Trace up to find the water surface.
			IPhysicsObject *pPhysAirboat = static_cast<IPhysicsObject*>( m_pAirboatBody->client_data );
			m_pGameTrace->VehicleTraceRay( gameRays[iRaycast], pPhysAirboat->GetGameData(), &trace ); 
			pImpacts[iRaycast].flDepth = GetWaterDepth( &gameRays[iRaycast], pPhysAirboat );
		}
		else
		{
			// Trace down to find the ground or water.
			IPhysicsObject *pPhysAirboat = static_cast<IPhysicsObject*>( m_pAirboatBody->client_data );
			m_pGameTrace->VehicleTraceRayWithWater( gameRays[iRaycast], pPhysAirboat->GetGameData(), &trace ); 
		}
		
		ConvertPositionToIVP( gameRays[iRaycast].m_Start + gameRays[iRaycast].m_StartOffset, m_CarSystemDebugData.wheelRaycasts[iRaycast][0] );
		ConvertPositionToIVP( gameRays[iRaycast].m_Start + gameRays[iRaycast].m_StartOffset + gameRays[iRaycast].m_Delta, m_CarSystemDebugData.wheelRaycasts[iRaycast][1] );
		m_CarSystemDebugData.wheelRaycastImpacts[iRaycast] = trace.fraction * gameRays[iRaycast].m_Delta.Length();

		// Set impact data.
		pImpacts[iRaycast].bImpactWater = IVP_FALSE;
		pImpacts[iRaycast].bImpact = IVP_FALSE;
		if ( trace.fraction != 1.0f )
		{
			pImpacts[iRaycast].bImpact = IVP_TRUE;

			// Set water surface flag.
			pImpacts[iRaycast].flDepth = 0.0f;
			if ( trace.contents & MASK_WATER )
			{
				pImpacts[iRaycast].bImpactWater = IVP_TRUE;
			}

			// Save impact surface data.
			ConvertPositionToIVP( trace.endpos, pImpacts[iRaycast].vecImpactPointWS );
			ConvertDirectionToIVP( trace.plane.normal, pImpacts[iRaycast].vecImpactNormalWS );

			// Save surface properties.
			const surfacedata_t *pSurfaceData = physprops->GetSurfaceData( trace.surface.surfaceProps );

			pImpacts[iRaycast].nSurfaceProps = trace.surface.surfaceProps;

			if (pImpacts[iRaycast].vecImpactNormalWS.k[1] < -0.707)
			{
				// dampening is 1/t, where t is how long it takes to come to a complete stop
				pImpacts[iRaycast].flDampening = pSurfaceData->physics.dampening;
				pImpacts[iRaycast].flFriction = pSurfaceData->physics.friction;
			}
			else
			{
				// This surface is too vertical -- no friction or damping from it.
				pImpacts[iRaycast].flDampening = pSurfaceData->physics.dampening;
				pImpacts[iRaycast].flFriction = pSurfaceData->physics.friction;
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Entry point for airboat simulation.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::do_simulation_controller( IVP_Event_Sim *pEventSim, IVP_U_Vector<IVP_Core> * )
{
    IVP_Ray_Solver_Template				raySolverTemplates[IVP_RAYCAST_AIRBOAT_MAX_WHEELS];
	IVP_Raycast_Airboat_Impact			impacts[IVP_RAYCAST_AIRBOAT_MAX_WHEELS];

	// Cache some data into members here so we only do the work once.
	m_pCore = m_pAirboatBody->get_core();
    const IVP_U_Matrix *matWorldFromCore = m_pCore->get_m_world_f_core_PSI();

	// Cache the speed.
	m_flSpeed = ( IVP_FLOAT )m_pCore->speed.real_length();

	// Cache the local velocity vector.
	matWorldFromCore->vimult3(&m_pCore->speed, &m_vecLocalVelocity);
    
	// Raycasts.
	PreRaycasts( raySolverTemplates, matWorldFromCore, impacts );
	do_raycasts_gameside( n_wheels, raySolverTemplates, impacts );
	if ( !PostRaycasts( raySolverTemplates, matWorldFromCore, impacts ) )
		return;

	UpdateAirborneState( impacts, pEventSim );

	// Enumerate the controllers attached to us.
	//for (int i = m_pCore->controllers_of_core.len() - 1; i >= 0; i--)
	//{
	//	IVP_Controller *pController = m_pCore->controllers_of_core.element_at(i);
	//}

    // Pontoons. Buoyancy or ground impacts.
	DoSimulationPontoons( impacts, pEventSim );

	// Drag due to water and ground friction.
	DoSimulationDrag( impacts, pEventSim );

	// Turbine (fan).
	DoSimulationTurbine( pEventSim );

	// Steering.
	DoSimulationSteering( pEventSim );	

	// Anti-pitch.
	DoSimulationKeepUprightPitch( impacts, pEventSim );

	// Anti-roll.
	DoSimulationKeepUprightRoll( impacts, pEventSim );

	// Additional gravity based on speed.
	DoSimulationGravity( pEventSim );
}


//-----------------------------------------------------------------------------
// Purpose: Initialize the rays to be cast from the vehicle wheel positions to
//          the "ground."
// Input  : pRaySolverTemplates - 
//			matWorldFromCore - 
//			pImpacts - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::PreRaycasts( IVP_Ray_Solver_Template *pRaySolverTemplates, 
									  const IVP_U_Matrix *matWorldFromCore,
									  IVP_Raycast_Airboat_Impact *pImpacts )
{
	int nPontoonPoints = n_wheels;
	for ( int iPoint = 0; iPoint < nPontoonPoints; ++iPoint )
	{
		IVP_Raycast_Airboat_Wheel *pPontoonPoint = get_wheel( IVP_POS_WHEEL( iPoint ) );
		if ( pPontoonPoint )
		{
			// Fill the in the ray solver template for the current wheel.
			IVP_Ray_Solver_Template &raySolverTemplate = pRaySolverTemplates[iPoint];

			// Transform the wheel "start" position from vehicle core-space to world-space.  This is
			// the raycast starting position.
			matWorldFromCore->vmult4( &pPontoonPoint->raycast_start_cs, &raySolverTemplate.ray_start_point );

			// Transform the shock (spring) direction from vehicle core-space to world-space.  This is
			// the raycast direction.
			matWorldFromCore->vmult3( &pPontoonPoint->raycast_dir_cs, &pImpacts[iPoint].raycast_dir_ws );
			raySolverTemplate.ray_normized_direction.set( &pImpacts[iPoint].raycast_dir_ws );

			// Set the length of the ray cast.
			raySolverTemplate.ray_length = AIRBOAT_RAYCAST_DIST;	

			// Set the ray solver template flags.  This defines which objects you wish to
			// collide against in the physics environment.
			raySolverTemplate.ray_flags = IVP_RAY_SOLVER_ALL;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Determines whether we are airborne and whether we just performed a
//			weak or strong jump. Weak jumps are jumps at below a threshold speed,
//			and disable the turbine and pitch controller.
// Input  : pImpacts - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::UpdateAirborneState( IVP_Raycast_Airboat_Impact *pImpacts, IVP_Event_Sim *pEventSim )
{
	int nCount = CountSurfaceContactPoints(pImpacts);
	if (!nCount)
	{
		if (!m_bAirborne)
		{
			m_bAirborne = true;
			m_flAirTime = 0;

			IVP_FLOAT flSpeed = ( IVP_FLOAT )m_pCore->speed.real_length();
			if (flSpeed < 11.0f)
			{
				//Msg("*** WEAK JUMP at %f!!!\n", flSpeed);
				m_bWeakJump = true;
			}
			else
			{
				//Msg("Strong JUMP at %f\n", flSpeed);
			}
		}
		else
		{
			m_flAirTime += pEventSim->delta_time;
		}
	}
	else
	{
		m_bAirborne = false;
		m_bWeakJump = false;
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CPhysics_Airboat::PostRaycasts( IVP_Ray_Solver_Template *pRaySolverTemplates, const IVP_U_Matrix *matWorldFromCore,
										IVP_Raycast_Airboat_Impact *pImpacts )
{
	bool bReturn = true;

	int nPontoonPoints = n_wheels;
	for( int iPoint = 0; iPoint < nPontoonPoints; ++iPoint )
	{
		// Get data at raycast position.
		IVP_Raycast_Airboat_Wheel *pPontoonPoint = get_wheel( IVP_POS_WHEEL( iPoint ) );
		IVP_Raycast_Airboat_Impact *pImpact = &pImpacts[iPoint];
		IVP_Ray_Solver_Template *pRaySolver = &pRaySolverTemplates[iPoint];
		if ( !pPontoonPoint || !pImpact || !pRaySolver )
			continue;

		// Copy the ray length back, it may have changed.
		pPontoonPoint->raycast_length = pRaySolver->ray_length;

		// Test for inverted raycast direction.
		if ( pImpact->bInWater )
		{
			pImpact->raycast_dir_ws.set_multiple( &pImpact->raycast_dir_ws, -1 );
		}

		// Impact.
		if ( pImpact->bImpact )
		{
			// Save impact distance.
			IVP_U_Point vecDelta;
			vecDelta.subtract( &pImpact->vecImpactPointWS, &pRaySolver->ray_start_point );
			pPontoonPoint->raycast_dist = vecDelta.real_length();

			// Get the inverse portion of the surface normal in the direction of the ray cast (shock - used in the shock simulation code for the sign
			// and percentage of force applied to the shock).
			pImpact->inv_normal_dot_dir = 1.1f / ( IVP_Inline_Math::fabsd( pImpact->raycast_dir_ws.dot_product( &pImpact->vecImpactNormalWS ) ) + 0.1f );

			// Set the wheel friction - ground friction (if any) + wheel friction.
			pImpact->friction_value = pImpact->flFriction * pPontoonPoint->friction_of_wheel;
		}
		// No impact.
		else
		{
			pPontoonPoint->raycast_dist = pPontoonPoint->raycast_length;

			pImpact->inv_normal_dot_dir = 1.0f;	    
			pImpact->moveable_object_hit_by_ray = NULL;
			pImpact->vecImpactNormalWS.set_multiple( &pImpact->raycast_dir_ws, -1 );
			pImpact->friction_value = 1.0f;
		}

		// Set the new wheel position (the impact point or the full ray distance).  Make this from the wheel not the ray trace position.
		pImpact->vecImpactPointWS.add_multiple( &pRaySolver->ray_start_point, &pImpact->raycast_dir_ws, pPontoonPoint->raycast_dist );

		// Get the speed (velocity) at the impact point.
		m_pCore->get_surface_speed_ws( &pImpact->vecImpactPointWS, &pImpact->surface_speed_wheel_ws );
		pImpact->projected_surface_speed_wheel_ws.set_orthogonal_part( &pImpact->surface_speed_wheel_ws, &pImpact->vecImpactNormalWS );

		matWorldFromCore->vmult3( &pPontoonPoint->axis_direction_cs, &pImpact->axis_direction_ws );
		pImpact->projected_axis_direction_ws.set_orthogonal_part( &pImpact->axis_direction_ws, &pImpact->vecImpactNormalWS );
		if ( pImpact->projected_axis_direction_ws.normize() == IVP_FAULT )
		{
			DevMsg( "CPhysics_Airboat::do_simulation_controller projected_axis_direction_ws.normize failed\n" );
			bReturn = false;
		}
	}

	return bReturn;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysics_Airboat::DoSimulationPontoons( IVP_Raycast_Airboat_Impact *pImpacts, IVP_Event_Sim *pEventSim )
{
	int nPontoonPoints = n_wheels;
	for ( int iPoint = 0; iPoint < nPontoonPoints; ++iPoint )
	{
		IVP_Raycast_Airboat_Wheel *pPontoonPoint = get_wheel( IVP_POS_WHEEL( iPoint ) );
		if ( !pPontoonPoint )
			continue;

		if ( pImpacts[iPoint].bImpact )
		{
			DoSimulationPontoonsGround( pPontoonPoint, &pImpacts[iPoint], pEventSim );
		}
		else if ( pImpacts[iPoint].bInWater )
		{
			DoSimulationPontoonsWater( pPontoonPoint, &pImpacts[iPoint], pEventSim );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Handle pontoons on ground.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::DoSimulationPontoonsGround( IVP_Raycast_Airboat_Wheel *pPontoonPoint, 
										             IVP_Raycast_Airboat_Impact *pImpact, IVP_Event_Sim *pEventSim )
{
	// Check to see if we hit anything, otherwise the no force on this point.
	IVP_DOUBLE flDiff = pPontoonPoint->raycast_dist - pPontoonPoint->raycast_length;
	if ( flDiff >= 0 ) 
		return;
	
	IVP_FLOAT flSpringConstant, flSpringRelax, flSpringCompress;
	flSpringConstant = pPontoonPoint->spring_constant;
	flSpringRelax = pPontoonPoint->spring_damp_relax;
	flSpringCompress = pPontoonPoint->spring_damp_compress;
	
	IVP_DOUBLE flForce = -flDiff * flSpringConstant;
	IVP_FLOAT flInvNormalDotDir = clamp(pImpact->inv_normal_dot_dir, 0.0f, 3.0f);
	flForce *= flInvNormalDotDir;
	
	IVP_U_Float_Point vecSpeedDelta; 
	vecSpeedDelta.subtract( &pImpact->projected_surface_speed_wheel_ws, &pImpact->surface_speed_wheel_ws );
	
	IVP_DOUBLE flSpeed = vecSpeedDelta.dot_product( &pImpact->raycast_dir_ws );
	if ( flSpeed > 0 )
	{
		flForce -= flSpringRelax * flSpeed;
	}
	else
	{
		flForce -= flSpringCompress * flSpeed;
	}
	
	if ( flForce < 0 )
	{
		flForce = 0.0f;
	}

	// NOTE: Spring constants are all mass-independent, so no need to multiply by mass here.	
	IVP_DOUBLE flImpulse = flForce * pEventSim->delta_time;
	
	IVP_U_Float_Point vecImpulseWS; 
	vecImpulseWS.set_multiple( &pImpact->vecImpactNormalWS, flImpulse );
	m_pCore->push_core_ws( &pImpact->vecImpactPointWS, &vecImpulseWS );
}


//-----------------------------------------------------------------------------
// Purpose: Handle pontoons on water.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::DoSimulationPontoonsWater( IVP_Raycast_Airboat_Wheel *pPontoonPoint, 
										            IVP_Raycast_Airboat_Impact *pImpact, IVP_Event_Sim *pEventSim )
{
	#define AIRBOAT_BUOYANCY_SCALAR	1.6f
	#define PONTOON_AREA_2D 2.8f			// 2 pontoons x 16 in x 136 in = 4352 sq inches = 2.8 sq meters
	#define PONTOON_HEIGHT 0.41f			// 16 inches high = 0.41 meters

	float flDepth = clamp( pImpact->flDepth, 0.f, PONTOON_HEIGHT );
	//Msg("depth: %f\n", pImpact->flDepth);

	// Depth is in inches, so multiply by 0.0254 meters/inch
	IVP_FLOAT flSubmergedVolume = PONTOON_AREA_2D * flDepth * 0.0254;

	// Buoyancy forces are equal to the mass of the water displaced, which is 1000 kg/m^3
	// There are 4 pontoon points, so each one can exert 1/4th of the total buoyancy force.
	IVP_FLOAT flForce = AIRBOAT_BUOYANCY_SCALAR * 0.25f * m_pCore->get_mass() * flSubmergedVolume * 1000.0f;
	IVP_DOUBLE flImpulse = flForce * pEventSim->delta_time;
	
	IVP_U_Float_Point vecImpulseWS; 
	vecImpulseWS.set( 0, -1, 0 );
	vecImpulseWS.mult( flImpulse );
	m_pCore->push_core_ws( &pImpact->vecImpactPointWS, &vecImpulseWS );

//	Vector vecPoint;
//	Vector vecDir(0, 0, 1);
//
//	ConvertPositionToHL( pImpact->vecImpactPointWS, vecPoint );
//	CPhysicsEnvironment *pEnv = (CPhysicsEnvironment *)m_pAirboatBody->get_core()->environment->client_data;
//	IVPhysicsDebugOverlay *debugoverlay = pEnv->GetDebugOverlay();
//	debugoverlay->AddLineOverlay(vecPoint, vecPoint + vecDir * 128, 255, 0, 255, false, 10.0 );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::PerformFrictionNotification( float flEliminatedEnergy, float dt, int nSurfaceProp, IPhysicsCollisionData *pCollisionData )
{
	CPhysicsObject *pPhysAirboat = static_cast<CPhysicsObject*>( m_pAirboatBody->client_data );
	if ( ( pPhysAirboat->CallbackFlags() & CALLBACK_GLOBAL_FRICTION ) == 0 )
		return;

	IPhysicsCollisionEvent *pEventHandler = pPhysAirboat->GetVPhysicsEnvironment()->GetCollisionEventHandler();
	if ( !pEventHandler )
		return;

	// scrape with an estimate for the energy per unit mass
	// This assumes that the game is interested in some measure of vibration
	// for sound effects.  This also assumes that more massive objects require
	// more energy to vibrate.
	flEliminatedEnergy *= dt / pPhysAirboat->GetMass();
	if ( flEliminatedEnergy > 0.05f )
	{
		pEventHandler->Friction( pPhysAirboat, flEliminatedEnergy, pPhysAirboat->GetMaterialIndexInternal(), nSurfaceProp, pCollisionData );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Drag due to water and ground friction.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::DoSimulationDrag( IVP_Raycast_Airboat_Impact *pImpacts, 
										   IVP_Event_Sim *pEventSim )
{
    const IVP_U_Matrix *matWorldFromCore = m_pCore->get_m_world_f_core_PSI();
	IVP_FLOAT flSpeed = ( IVP_FLOAT )m_pCore->speed.real_length();

	// Used to make airboat sliding sounds
	CAirboatFrictionData frictionData;
	ConvertDirectionToHL( m_pCore->speed, frictionData.m_vecVelocity ); 

	// Count the pontoons in the water.
	int nPontoonPoints = n_wheels;
	int nPointsInWater = 0;
	int nPointsOnGround = 0;
	float flGroundFriction = 0;
	float flAverageDampening = 0.0f;
	int *pSurfacePropCount = (int *)stackalloc( n_wheels * sizeof(int) );
	int *pSurfaceProp  = (int *)stackalloc( n_wheels * sizeof(int) );
	memset( pSurfacePropCount, 0, n_wheels * sizeof(int) );
	memset( pSurfaceProp, 0xFF, n_wheels * sizeof(int) );
	int nSurfacePropCount = 0;
	int nMaxSurfacePropIdx = 0;
	for( int iPoint = 0; iPoint < nPontoonPoints; ++iPoint )
	{
		// Get data at raycast position.
		IVP_Raycast_Airboat_Impact *pImpact = &pImpacts[iPoint];
		if ( !pImpact || !pImpact->bImpact )
			continue;

		if ( pImpact->bImpactWater )
		{
			flAverageDampening += pImpact->flDampening;
			nPointsInWater++;
		}
		else
		{
			flGroundFriction += pImpact->flFriction;
			nPointsOnGround++;

			// This logic is used to determine which surface prop we hit the most.
			int i;
			for ( i = 0; i < nSurfacePropCount; ++i )
			{
				if ( pSurfaceProp[i] == pImpact->nSurfaceProps )
					break;
			}

			if ( i == nSurfacePropCount )
			{
				++nSurfacePropCount;
			}
			pSurfaceProp[i] = pImpact->nSurfaceProps;
			if ( ++pSurfacePropCount[i] > pSurfacePropCount[nMaxSurfacePropIdx] )
			{
				nMaxSurfacePropIdx = i;
			}

			Vector frictionPoint, frictionNormal;
			ConvertPositionToHL( pImpact->vecImpactPointWS, frictionPoint );
			ConvertDirectionToHL( pImpact->vecImpactNormalWS, frictionNormal );
			frictionData.m_vecPoint += frictionPoint;
			frictionData.m_vecNormal += frictionNormal;
		}
	}

	int nSurfaceProp = pSurfaceProp[nMaxSurfacePropIdx];
	if ( nPointsOnGround > 0 )
	{
		frictionData.m_vecPoint /= nPointsOnGround;
		frictionData.m_vecNormal /= nPointsOnGround;
		VectorNormalize( frictionData.m_vecNormal );
	}

	if ( nPointsInWater > 0 )
	{
		flAverageDampening /= nPointsInWater;
	}

	//IVP_FLOAT flDebugSpeed = ( IVP_FLOAT )m_pCore->speed.real_length();
	//Msg("(water=%d/land=%d) speed=%f (%f %f %f)\n", nPointsInWater, nPointsOnGround, flDebugSpeed, vecAirboatDirLS.k[0], vecAirboatDirLS.k[1], vecAirboatDirLS.k[2]);

	if ( nPointsInWater )
	{
		// Apply the drag force opposite to the direction of motion in local space.
		IVP_U_Float_Point vecAirboatNegDirLS;
		vecAirboatNegDirLS.set_negative( &m_vecLocalVelocity );

		// Water drag is directional -- the pontoons resist left/right motion much more than forward/back.
		IVP_U_Float_Point vecDragLS;
		vecDragLS.set( AIRBOAT_WATER_DRAG_LEFT_RIGHT * vecAirboatNegDirLS.k[0],
					   AIRBOAT_WATER_DRAG_UP_DOWN * vecAirboatNegDirLS.k[1],
					   AIRBOAT_WATER_DRAG_FORWARD_BACK * vecAirboatNegDirLS.k[2] );

		vecDragLS.mult( flSpeed * m_pCore->get_mass() * pEventSim->delta_time );
		// dvs TODO: apply flAverageDampening here

		// Convert the drag force to world space and apply the drag.
		IVP_U_Float_Point vecDragWS;
		matWorldFromCore->vmult3(&vecDragLS, &vecDragWS);
		m_pCore->center_push_core_multiple_ws( &vecDragWS );
	}

	//
	// Calculate ground friction drag:
	//
	if ( nPointsOnGround && ( flSpeed > 0 ))
	{
		// Calculate the average friction across all contact points.
		flGroundFriction /= (float)nPointsOnGround;

		// Apply the drag force opposite to the direction of motion.
		IVP_U_Float_Point vecAirboatNegDir;
		vecAirboatNegDir.set_negative( &m_pCore->speed );

		IVP_FLOAT flFrictionDrag = m_pCore->get_mass() * AIRBOAT_GRAVITY * AIRBOAT_DRY_FRICTION_SCALE * flGroundFriction;
		flFrictionDrag /= flSpeed;

		IPhysicsObject *pPhysAirboat = static_cast<IPhysicsObject*>( m_pAirboatBody->client_data );
		float flEliminatedEnergy = pPhysAirboat->GetEnergy();

		// Apply the drag force opposite to the direction of motion in local space.
		IVP_U_Float_Point vecAirboatNegDirLS;
		vecAirboatNegDirLS.set_negative( &m_vecLocalVelocity );

		// Ground drag is directional -- the pontoons resist left/right motion much more than forward/back.
		IVP_U_Float_Point vecDragLS;
		vecDragLS.set( AIRBOAT_GROUND_DRAG_LEFT_RIGHT * vecAirboatNegDirLS.k[0],
					   AIRBOAT_GROUND_DRAG_UP_DOWN * vecAirboatNegDirLS.k[1],
					   AIRBOAT_GROUND_DRAG_FORWARD_BACK * vecAirboatNegDirLS.k[2] );

		vecDragLS.mult( flFrictionDrag * pEventSim->delta_time );
		// dvs TODO: apply flAverageDampening here

		// Convert the drag force to world space and apply the drag.
		IVP_U_Float_Point vecDragWS;
		matWorldFromCore->vmult3(&vecDragLS, &vecDragWS);
		m_pCore->center_push_core_multiple_ws( &vecDragWS );

		// Figure out how much energy was eliminated by friction.
		flEliminatedEnergy -= pPhysAirboat->GetEnergy();
		PerformFrictionNotification( flEliminatedEnergy, pEventSim->delta_time, nSurfaceProp, &frictionData );
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysics_Airboat::DoSimulationTurbine( IVP_Event_Sim *pEventSim )
{
	// Reduce the turbine power during weak jumps to avoid unrealistic air control.
	// Also, reduce reverse thrust while airborne.
	float flThrust = m_flThrust;
	if ((m_bWeakJump) || (m_bAirborne && (flThrust < 0)))
	{
		flThrust *= 0.5;
	}

	// Get the forward vector in world-space.
	IVP_U_Float_Point vecForwardWS; 
    const IVP_U_Matrix *matWorldFromCore = m_pCore->get_m_world_f_core_PSI();
	matWorldFromCore->get_col( IVP_COORDINATE_INDEX( index_z ), &vecForwardWS );

	//Msg("thrust: %f\n", m_flThrust);
	if ( ( vecForwardWS.k[1] < -0.5 ) && ( flThrust > 0 ) )
	{
		// Driving up a slope. Reduce upward thrust to prevent ludicrous climbing of steep surfaces.
		float flFactor = 1 + vecForwardWS.k[1];
		//Msg("FWD: y=%f, factor=%f\n", vecForwardWS.k[1], flFactor);
		flThrust *= flFactor;
	}
	else if ( ( vecForwardWS.k[1] > 0.5 ) && ( flThrust < 0 ) )
	{
		// Reversing up a slope. Reduce upward thrust to prevent ludicrous climbing of steep surfaces.
		float flFactor = 1 - vecForwardWS.k[1];
		//Msg("REV: y=%f, factor=%f\n", vecForwardWS.k[1], flFactor);
		flThrust *= flFactor;
	}

	// Forward (Front/Back) force
	IVP_U_Float_Point vecImpulse;
	vecImpulse.set_multiple( &vecForwardWS, flThrust * m_pCore->get_mass() * pEventSim->delta_time );

	m_pCore->center_push_core_multiple_ws( &vecImpulse );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysics_Airboat::DoSimulationSteering( IVP_Event_Sim *pEventSim )
{
	// Calculate the steering direction: forward or reverse.
	// Don't mess with the steering direction while we're steering, unless thrust is applied.
	// This prevents the steering from reversing because we started drifting backwards.
	if ( ( m_SteeringAngle == 0 ) || ( m_flThrust != 0 ) )
	{
		if ( !m_bAnalogSteering )
		{
			// If we're applying reverse thrust, steering is always reversed.
			if ( m_flThrust < 0 )
			{
				m_bSteeringReversed = true;
			}
			// Else if we are applying forward thrust or moving forward, use forward steering.
			else if ( ( m_flThrust > 0 ) || ( m_vecLocalVelocity.k[2] > 0 ) )
			{
				m_bSteeringReversed = false;
			}
		}
		else
		{
			// Create a dead zone through the middle of the joystick where we don't reverse thrust.
			// If we're applying reverse thrust, steering is always reversed.
			if ( m_flThrust < -2.0f )
			{
				m_bSteeringReversed = true;
			}
			// Else if we are applying forward thrust or moving forward, use forward steering.
			else if ( ( m_flThrust > 2.0f ) || ( m_vecLocalVelocity.k[2] > 0 ) )
			{
				m_bSteeringReversed = false;
			}
		}
	}

	// Calculate the steering force.
	IVP_FLOAT flForceSteering = 0.0f;
	if ( fabsf( m_SteeringAngle ) > 0.01 )
	{
		// Get the sign of the steering force.
		IVP_FLOAT flSteeringSign = m_SteeringAngle < 0.0f ? -1.0f : 1.0f;
		if ( m_bSteeringReversed )
		{
			flSteeringSign *= -1.0f;
		}

		// If we changed steering sign or went from not steering to steering, reset the steer time
		// to blend the new steering force in over time.
		IVP_FLOAT flPrevSteeringSign = m_flPrevSteeringAngle < 0.0f ? -1.0f : 1.0f;
		if ( ( fabs( m_flPrevSteeringAngle ) < 0.01 ) || ( flSteeringSign != flPrevSteeringSign ) )
		{
			m_flSteerTime = 0;
		}

		float flSteerScale = 0.f;
		if ( !m_bAnalogSteering )
		{
			// Ramp the steering force up over two seconds.
			flSteerScale = RemapValClamped( m_flSteerTime, 0, AIRBOAT_STEERING_INTERVAL, AIRBOAT_STEERING_RATE_MIN, AIRBOAT_STEERING_RATE_MAX );
		}
		else	// consoles
		{
			// Analog steering
			flSteerScale = RemapValClamped( fabs(m_SteeringAngle), 0, AIRBOAT_STEERING_INTERVAL, AIRBOAT_STEERING_RATE_MIN, AIRBOAT_STEERING_RATE_MAX );
		}

		flForceSteering = flSteerScale * m_pCore->get_mass() * pEventSim->i_delta_time;
		flForceSteering *= -flSteeringSign;

		m_flSteerTime += pEventSim->delta_time;
	}

	//Msg("steer force=%f\n", flForceSteering);

	m_flPrevSteeringAngle = m_SteeringAngle * ( m_bSteeringReversed ? -1.0 : 1.0 );

	// Get the sign of the drag forces.
	IVP_FLOAT flRotSpeedSign = m_pCore->rot_speed.k[1] < 0.0f ? -1.0f : 1.0f;

	// Apply drag proportional to the square of the angular velocity.
	IVP_FLOAT flRotationalDrag = AIRBOAT_ROT_DRAG * m_pCore->rot_speed.k[1] * m_pCore->rot_speed.k[1] * m_pCore->get_mass() * pEventSim->i_delta_time;
	flRotationalDrag *= flRotSpeedSign;

	// Apply dampening proportional to angular velocity.
	IVP_FLOAT flRotationalDamping = AIRBOAT_ROT_DAMPING * fabs(m_pCore->rot_speed.k[1]) * m_pCore->get_mass() * pEventSim->i_delta_time;
	flRotationalDamping *= flRotSpeedSign;

	// Calculate the net rotational force.
	IVP_FLOAT flForceRotational = flForceSteering + flRotationalDrag + flRotationalDamping;

	// Apply it.
	IVP_U_Float_Point vecRotImpulse;
	vecRotImpulse.set( 0, -1, 0 );
	vecRotImpulse.mult( flForceRotational );
	m_pCore->rot_push_core_cs( &vecRotImpulse );
}


//-----------------------------------------------------------------------------
// Purpose: Adds extra gravity unless we are performing a strong jump.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::DoSimulationGravity( IVP_Event_Sim *pEventSim )
{
	return;

	if ( !m_bAirborne || m_bWeakJump )
	{
		IVP_U_Float_Point vecGravity;
		vecGravity.set( 0, AIRBOAT_GRAVITY / 2.0f, 0 );
		vecGravity.mult( m_pCore->get_mass() * pEventSim->delta_time );
		m_pCore->center_push_core_multiple_ws( &vecGravity );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Returns the number of pontoon raycast points that were found to contact
//			the ground or water.
//-----------------------------------------------------------------------------
int CPhysics_Airboat::CountSurfaceContactPoints( IVP_Raycast_Airboat_Impact *pImpacts )
{
	int nContacts = 0;
	int nPontoonPoints = n_wheels;
	for ( int iPoint = 0; iPoint < nPontoonPoints; iPoint++ )
	{
		// Get data at raycast position.
		IVP_Raycast_Airboat_Impact *pImpact = &pImpacts[iPoint];
		if ( !pImpact )
			continue;

		if ( pImpact->bImpact )
		{
			nContacts++;
		}
	}

	return nContacts;
}


//-----------------------------------------------------------------------------
// Purpose: Prevents us from nosing down dramatically during jumps, which
//			increases our maximum jump distance.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::DoSimulationKeepUprightPitch( IVP_Raycast_Airboat_Impact *pImpacts, IVP_Event_Sim *pEventSim )
{
	// Disable pitch control during weak jumps. This reduces the unreal 'floaty' sensation.
	if (m_bWeakJump)
	{
		return;
	}

	// Reference vector in core space.
	// Pitch back by 10 degrees while airborne.
	IVP_U_Float_Point vecUpCS; 
	vecUpCS.set( 0, -cos(DEG2RAD(10)), sin(DEG2RAD(10)));

	// Calculate the goal vector in core space. We will try to align the reference
	// vector with the goal vector.
	IVP_U_Float_Point vecGoalAxisWS;
	vecGoalAxisWS.set( 0, -1, 0 );
    const IVP_U_Matrix *matWorldFromCore = m_pCore->get_m_world_f_core_PSI();
	IVP_U_Float_Point vecGoalAxisCS;
	matWorldFromCore->vimult3( &vecGoalAxisWS, &vecGoalAxisCS );

	// Eliminate roll control
	vecGoalAxisCS.k[0] = vecUpCS.k[0];
	vecGoalAxisCS.normize();

	// Get an axis to rotate around.
	IVP_U_Float_Point vecRotAxisCS;
	vecRotAxisCS.calc_cross_product( &vecUpCS, &vecGoalAxisCS );

	// Get the amount that we need to rotate.
	// atan2() is well defined, so do a Dot & Cross instead of asin(Cross)
	IVP_FLOAT cosine = vecUpCS.dot_product( &vecGoalAxisCS );
	IVP_FLOAT sine = vecRotAxisCS.real_length_plus_normize();
	IVP_FLOAT angle = atan2( sine, cosine );

	//Msg("angle: %.2f, axis: (%.2f %.2f %.2f)\n", RAD2DEG(angle), vecRotAxisCS.k[0], vecRotAxisCS.k[1], vecRotAxisCS.k[2]);

	// Don't keep upright if any pontoons are contacting a surface.
	if ( CountSurfaceContactPoints( pImpacts ) > 0 )
	{
		m_flPitchErrorPrev = angle;
		return;
	}
	
	// Don't do any correction if we're within 15 degrees of the goal orientation.
	//if ( fabs( angle ) < DEG2RAD( 15 ) )
	//{
	//	m_flPitchErrorPrev = angle;
	//	return;
	//}

	//Msg("CORRECTING\n");

	// Generate an angular impulse describing the rotation.
	IVP_U_Float_Point vecAngularImpulse;
	vecAngularImpulse.set_multiple( &vecRotAxisCS, m_pCore->get_mass() * ( 0.1f * angle + 0.04f * pEventSim->i_delta_time * ( angle - m_flPitchErrorPrev ) ) );

	// Save the last error value for calculating the derivative.
	m_flPitchErrorPrev = angle;

	// Clamp the impulse at a maximum length.
	IVP_FLOAT len = vecAngularImpulse.real_length_plus_normize();
	if ( len > ( DEG2RAD( 1.5 ) * m_pCore->get_mass() ) )
	{
		len = DEG2RAD( 1.5 ) * m_pCore->get_mass();
	}
	vecAngularImpulse.mult( len );

	// Apply the rotation.
	m_pCore->rot_push_core_cs( &vecAngularImpulse );

#if DRAW_AIRBOAT_KEEP_UPRIGHT_PITCH_VECTORS
	CPhysicsEnvironment *pEnv = (CPhysicsEnvironment *)m_pAirboatBody->get_core()->environment->client_data;
	IVPhysicsDebugOverlay *debugoverlay = pEnv->GetDebugOverlay();

	IVP_U_Float_Point vecPosIVP = m_pCore->get_position_PSI();
	Vector vecPosHL;
	ConvertPositionToHL(vecPosIVP, vecPosHL);

	Vector vecGoalAxisHL;
	ConvertDirectionToHL(vecGoalAxisWS, vecGoalAxisHL);

	IVP_U_Float_Point vecUpWS;
	matWorldFromCore->vmult3( &vecUpCS, &vecUpWS );
	Vector vecCurHL;
	ConvertDirectionToHL(vecUpWS, vecCurHL);

	static IVP_FLOAT flLastLen = 0;
	IVP_FLOAT flDebugLen = vecAngularImpulse.real_length();
	if ( flLastLen && ( fabs( flDebugLen - flLastLen ) > DEG2RAD( 1 )  * m_pCore->get_mass() ) )
	{
		debugoverlay->AddLineOverlay(vecPosHL, vecPosHL + Vector(0, 0, 10) * flDebugLen, 255, 0, 255, false, 100.0 );
	}
	else
	{
		debugoverlay->AddLineOverlay(vecPosHL, vecPosHL + Vector(0, 0, 10) * flDebugLen, 255, 255, 255, false, 100.0 );
	}
	debugoverlay->AddLineOverlay(vecPosHL + Vector(0, 0, 10) * flDebugLen, vecPosHL + Vector(0, 0, 10) * flDebugLen + vecGoalAxisHL * 10, 0, 255, 0, false, 100.0 );
	debugoverlay->AddLineOverlay(vecPosHL + Vector(0, 0, 10) * flDebugLen, vecPosHL + Vector(0, 0, 10) * flDebugLen + vecCurHL * 10, 255, 0, 0, false, 100.0 );
	flLastLen = flDebugLen;
#endif
}


//-----------------------------------------------------------------------------
// Purpose: Roll stabilizer when airborne.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::DoSimulationKeepUprightRoll( IVP_Raycast_Airboat_Impact *pImpacts, IVP_Event_Sim *pEventSim )
{
	// Reference vector in core space.
	// Pitch back by 10 degrees while airborne.
	IVP_U_Float_Point vecUpCS; 
	vecUpCS.set( 0, -cos(DEG2RAD(10)), sin(DEG2RAD(10)));

	// Calculate the goal vector in core space. We will try to align the reference
	// vector with the goal vector.
	IVP_U_Float_Point vecGoalAxisWS;
	vecGoalAxisWS.set( 0, -1, 0 );
    const IVP_U_Matrix *matWorldFromCore = m_pCore->get_m_world_f_core_PSI();
	IVP_U_Float_Point vecGoalAxisCS;
	matWorldFromCore->vimult3( &vecGoalAxisWS, &vecGoalAxisCS );

	// Eliminate pitch control
	vecGoalAxisCS.k[1] = vecUpCS.k[1];
	vecGoalAxisCS.normize();

	// Get an axis to rotate around.
	IVP_U_Float_Point vecRotAxisCS;
	vecRotAxisCS.calc_cross_product( &vecUpCS, &vecGoalAxisCS );

	// Get the amount that we need to rotate.
	// atan2() is well defined, so do a Dot & Cross instead of asin(Cross)
	IVP_FLOAT cosine = vecUpCS.dot_product( &vecGoalAxisCS );
	IVP_FLOAT sine = vecRotAxisCS.real_length_plus_normize();
	IVP_FLOAT angle = atan2( sine, cosine );

	//Msg("angle: %.2f, axis: (%.2f %.2f %.2f)\n", RAD2DEG(angle), vecRotAxisCS.k[0], vecRotAxisCS.k[1], vecRotAxisCS.k[2]);

	// Don't keep upright if any pontoons are contacting a surface.
	if ( CountSurfaceContactPoints( pImpacts ) > 0 )
	{
		m_flRollErrorPrev = angle;
		return;
	}
	
	// Don't do any correction if we're within 10 degrees of the goal orientation.
	if ( fabs( angle ) < DEG2RAD( 10 ) )
	{
		m_flRollErrorPrev = angle;
		return;
	}

	//Msg("CORRECTING\n");

	// Generate an angular impulse describing the rotation.
	IVP_U_Float_Point vecAngularImpulse;
	vecAngularImpulse.set_multiple( &vecRotAxisCS, m_pCore->get_mass() * ( 0.2f * angle + 0.3f * pEventSim->i_delta_time * ( angle - m_flRollErrorPrev ) ) );

	// Save the last error value for calculating the derivative.
	m_flRollErrorPrev = angle;

	// Clamp the impulse at a maximum length.
	IVP_FLOAT len = vecAngularImpulse.real_length_plus_normize();
	if ( len > ( DEG2RAD( 2 ) * m_pCore->get_mass() ) )
	{
		len = DEG2RAD( 2 ) * m_pCore->get_mass();
	}
	vecAngularImpulse.mult( len );
	m_pCore->rot_push_core_cs( &vecAngularImpulse );

	// Debugging visualization.
#if DRAW_AIRBOAT_KEEP_UPRIGHT_ROLL_VECTORS
	CPhysicsEnvironment *pEnv = (CPhysicsEnvironment *)m_pAirboatBody->get_core()->environment->client_data;
	IVPhysicsDebugOverlay *debugoverlay = pEnv->GetDebugOverlay();

	IVP_U_Float_Point vecPosIVP = m_pCore->get_position_PSI();
	Vector vecPosHL;
	ConvertPositionToHL(vecPosIVP, vecPosHL);

	Vector vecGoalAxisHL;
	ConvertDirectionToHL(vecGoalAxisWS, vecGoalAxisHL);

	IVP_U_Float_Point vecUpWS;
	matWorldFromCore->vmult3( &vecUpCS, &vecUpWS );
	Vector vecCurHL;
	ConvertDirectionToHL(vecUpWS, vecCurHL);

	static IVP_FLOAT flLastLen = 0;
	IVP_FLOAT flDebugLen = vecAngularImpulse.real_length();
	if ( flLastLen && ( fabs( flDebugLen - flLastLen ) > ( DEG2RAD( 0.25 ) * m_pCore->get_mass() ) )
	{
		debugoverlay->AddLineOverlay(vecPosHL, vecPosHL + Vector(0, 0, 10) * flDebugLen, 255, 0, 255, false, 100.0 );
	}
	else
	{
		debugoverlay->AddLineOverlay(vecPosHL, vecPosHL + Vector(0, 0, 10) * flDebugLen, 255, 255, 255, false, 100.0 );
	}
	debugoverlay->AddLineOverlay(vecPosHL + Vector(0, 0, 10) * flDebugLen, vecPosHL + Vector(0, 0, 10) * flDebugLen + vecGoalAxisHL * 10, 0, 255, 0, false, 100.0 );
	debugoverlay->AddLineOverlay(vecPosHL + Vector(0, 0, 10) * flDebugLen, vecPosHL + Vector(0, 0, 10) * flDebugLen + vecCurHL * 10, 255, 0, 0, false, 100.0 );
	flLastLen = flDebugLen;
#endif
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : wheel_nr - 
//			s_angle - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::do_steering_wheel(IVP_POS_WHEEL wheel_nr, IVP_FLOAT s_angle)
{
    IVP_Raycast_Airboat_Wheel *wheel = get_wheel(wheel_nr);
	
    wheel->axis_direction_cs.set_to_zero();
    wheel->axis_direction_cs.k[ index_x ] = 1.0f;
    wheel->axis_direction_cs.rotate( IVP_COORDINATE_INDEX(index_y), s_angle);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
//			spring_constant - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_spring_constant(IVP_POS_WHEEL pos, IVP_FLOAT spring_constant)
{
    IVP_Raycast_Airboat_Wheel *wheel = get_wheel(pos);
    wheel->spring_constant = spring_constant;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
//			spring_dampening - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_spring_dampening(IVP_POS_WHEEL pos, IVP_FLOAT spring_dampening)
{
    IVP_Raycast_Airboat_Wheel *wheel = get_wheel(pos);
    wheel->spring_damp_relax = spring_dampening;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
//			spring_dampening - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_spring_dampening_compression(IVP_POS_WHEEL pos, IVP_FLOAT spring_dampening)
{
    IVP_Raycast_Airboat_Wheel *wheel = get_wheel(pos);
    wheel->spring_damp_compress = spring_dampening;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
//			pre_tension_length - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_spring_pre_tension(IVP_POS_WHEEL pos, IVP_FLOAT pre_tension_length)
{
    IVP_Raycast_Airboat_Wheel *wheel = get_wheel(pos);
    wheel->spring_len = gravity_y_direction * (wheel->distance_orig_hp_to_hp - pre_tension_length);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
//			spring_length - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_spring_length(IVP_POS_WHEEL pos, IVP_FLOAT spring_length)
{
    IVP_Raycast_Airboat_Wheel *wheel = get_wheel(pos);
    wheel->spring_len = spring_length;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
//			torque - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_wheel_torque(IVP_POS_WHEEL pos, IVP_FLOAT torque)
{
    IVP_Raycast_Airboat_Wheel *wheel = get_wheel(pos);
    wheel->torque = torque;

	// Wake the physics object if need be!
	m_pAirboatBody->get_environment()->get_controller_manager()->ensure_controller_in_simulation( this );
}

IVP_FLOAT CPhysics_Airboat::get_wheel_torque(IVP_POS_WHEEL pos)
{
	return get_wheel(pos)->torque;
}


//-----------------------------------------------------------------------------
// Purpose:
// Throttle input is -1 to 1.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::update_throttle( IVP_FLOAT flThrottle )
{
	// Forward
	if ( fabs( flThrottle ) < 0.01f )
	{
		m_flThrust = 0.0f;
	}
	else if ( flThrottle > 0.0f )
	{
		m_flThrust = AIRBOAT_THRUST_MAX * flThrottle;
	}
	else if ( flThrottle < 0.0f )
	{
		m_flThrust = AIRBOAT_THRUST_MAX_REVERSE * flThrottle;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
//			stop_wheel - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::fix_wheel(IVP_POS_WHEEL pos, IVP_BOOL stop_wheel)
{
    IVP_Raycast_Airboat_Wheel *wheel = get_wheel(pos);
    wheel->wheel_is_fixed = stop_wheel;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
//			friction - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_friction_of_wheel( IVP_POS_WHEEL pos, IVP_FLOAT friction )
{
	IVP_Raycast_Airboat_Wheel *wheel = get_wheel(pos);
	wheel->friction_of_wheel = friction;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
//			stabi_constant - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_stabilizer_constant(IVP_POS_AXIS pos, IVP_FLOAT stabi_constant)
{
   IVP_Raycast_Airboat_Axle *pAxle = get_axle( pos );
   pAxle->stabilizer_constant = stabi_constant;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : fast_turn_factor_ - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_fast_turn_factor( IVP_FLOAT fast_turn_factor_ )
{
	//fast_turn_factor = fast_turn_factor_;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : force - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::change_body_downforce(IVP_FLOAT force)
{
    down_force = force;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Output : IVP_CONTROLLER_PRIORITY
//-----------------------------------------------------------------------------
IVP_CONTROLLER_PRIORITY CPhysics_Airboat::get_controller_priority()
{
    return IVP_CP_CONSTRAINTS_MAX;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : steering_angle_in - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::do_steering( IVP_FLOAT steering_angle_in, bool bAnalog )
{
	// Check for a change.
    if (  m_SteeringAngle == steering_angle_in) 
		return;

	MEM_ALLOC_CREDIT();

	// Set the new steering angle.
	m_bAnalogSteering = bAnalog;
    m_SteeringAngle = steering_angle_in;

	// Make sure the simulation is awake - we just go input.
    m_pAirboatBody->get_environment()->get_controller_manager()->ensure_controller_in_simulation( this );

	// Steer each wheel.
    for ( int iWheel = 0; iWheel < wheels_per_axis; ++iWheel )
	{
		do_steering_wheel( IVP_POS_WHEEL( iWheel ), m_SteeringAngle );
    }
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pos - 
// Output : IVP_DOUBLE
//-----------------------------------------------------------------------------
IVP_DOUBLE CPhysics_Airboat::get_wheel_angular_velocity(IVP_POS_WHEEL pos)
{
    IVP_Raycast_Airboat_Wheel *wheel = get_wheel(pos);
    return wheel->wheel_angular_velocity;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : index - 
// Output : IVP_DOUBLE
//-----------------------------------------------------------------------------
IVP_DOUBLE CPhysics_Airboat::get_body_speed(IVP_COORDINATE_INDEX index)
{
    // return (IVP_FLOAT)car_body->get_geom_center_speed();
    IVP_U_Float_Point *vec_ws = &m_pAirboatBody->get_core()->speed;
    // works well as we do not use merged cores
    const IVP_U_Matrix *mat_ws = m_pAirboatBody->get_core()->get_m_world_f_core_PSI();
    IVP_U_Point orientation;
    mat_ws->get_col(index, &orientation);

    return orientation.dot_product(vec_ws);
};


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
IVP_DOUBLE CPhysics_Airboat::get_orig_front_wheel_distance()
{
    IVP_U_Float_Point *left_wheel_cs = &this->get_wheel(IVP_FRONT_LEFT)->hp_cs;
    IVP_U_Float_Point *right_wheel_cs = &this->get_wheel(IVP_FRONT_RIGHT)->hp_cs;

    IVP_DOUBLE dist = left_wheel_cs->k[this->index_x] - right_wheel_cs->k[this->index_x];

    return IVP_Inline_Math::fabsd(dist); // was fabs, which was a sml call
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
IVP_DOUBLE CPhysics_Airboat::get_orig_axles_distance()
{
    IVP_U_Float_Point *front_wheel_cs = &this->get_wheel(IVP_FRONT_LEFT)->hp_cs;
    IVP_U_Float_Point *rear_wheel_cs = &this->get_wheel(IVP_REAR_LEFT)->hp_cs;

    IVP_DOUBLE dist = front_wheel_cs->k[this->index_z] - rear_wheel_cs->k[this->index_z];

    return IVP_Inline_Math::fabsd(dist); // was fabs, which was a sml call
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *array_of_skid_info_out - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::get_skid_info( IVP_Wheel_Skid_Info *array_of_skid_info_out)
{
	for ( int w = 0; w < n_wheels; w++)
	{
		IVP_Wheel_Skid_Info &info = array_of_skid_info_out[w];
		//IVP_Constraint_Car_Object *wheel = car_constraint_solver->wheel_objects.element_at(w);
		info.last_contact_position_ws.set_to_zero(); // = wheel->last_contact_position_ws;
		info.last_skid_value = 0.0f; // wheel->last_skid_value;
		info.last_skid_time = 0.0f; //wheel->last_skid_time;
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysics_Airboat::InitRaycastCarEnvironment( IVP_Environment *pEnvironment, 
													        const IVP_Template_Car_System *pCarSystemTemplate )
{
	// Copies of the car system template component indices and handedness.
    index_x = pCarSystemTemplate->index_x;
    index_y = pCarSystemTemplate->index_y;
    index_z = pCarSystemTemplate->index_z;
    is_left_handed = pCarSystemTemplate->is_left_handed;

	IVP_Standard_Gravity_Controller *pGravityController = new IVP_Standard_Gravity_Controller();
	IVP_U_Point vecGravity( 0.0f, AIRBOAT_GRAVITY, 0.0f );
	pGravityController->grav_vec.set( &vecGravity );

	BEGIN_IVP_ALLOCATION();

	m_pAirboatBody->get_core()->add_core_controller( pGravityController );
	
	// Add this controller to the physics environment and setup the objects gravity.
    pEnvironment->get_controller_manager()->announce_controller_to_environment( this );

	END_IVP_ALLOCATION();

	extra_gravity = pCarSystemTemplate->extra_gravity_force_value;    

	// This works because gravity is still int the same direction, just smaller.
    if ( pEnvironment->get_gravity()->k[index_y] > 0 )
	{
		gravity_y_direction = 1.0f;
    }
	else
	{
		gravity_y_direction = -1.0f;
    }
    normized_gravity_ws.set( pEnvironment->get_gravity() );
    normized_gravity_ws.normize();
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysics_Airboat::InitRaycastCarBody( const IVP_Template_Car_System *pCarSystemTemplate )
{
	// Car body attributes.
    n_wheels = pCarSystemTemplate->n_wheels;
    n_axis = pCarSystemTemplate->n_axis;
    wheels_per_axis = n_wheels / n_axis;

	// Add the car body "core" to the list of raycast car controller "cores."
    m_pAirboatBody = pCarSystemTemplate->car_body;
    this->vector_of_cores.add( m_pAirboatBody->get_core() );

	// Init extra downward force applied to car.    
    down_force_vertical_offset = pCarSystemTemplate->body_down_force_vertical_offset;
    down_force = 0.0f;

	// Initialize.
	for ( int iAxis = 0; iAxis < 3; ++iAxis )
	{
		m_pAirboatBody->get_core()->rot_speed.k[iAxis] = 0.0f;
		m_pAirboatBody->get_core()->speed.k[iAxis] = 0.0f;
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysics_Airboat::InitRaycastCarWheels( const IVP_Template_Car_System *pCarSystemTemplate )
{
    IVP_U_Matrix m_core_f_object;
    m_pAirboatBody->calc_m_core_f_object( &m_core_f_object );

	// Initialize the car wheel system.
    for ( int iWheel = 0; iWheel < n_wheels; iWheel++ )
	{
		// Get and clear out memory for the current raycast wheel.
		IVP_Raycast_Airboat_Wheel *pRaycastWheel = get_wheel( IVP_POS_WHEEL( iWheel ) );
		P_MEM_CLEAR( pRaycastWheel );

		// Put the wheel in car space.
		m_core_f_object.vmult4( &pCarSystemTemplate->wheel_pos_Bos[iWheel], &pRaycastWheel->hp_cs );
		m_core_f_object.vmult4( &pCarSystemTemplate->trace_pos_Bos[iWheel], &pRaycastWheel->raycast_start_cs );
		
		// Add in the raycast start offset.
		pRaycastWheel->raycast_length = AIRBOAT_RAYCAST_DIST;
		pRaycastWheel->raycast_dir_cs.set_to_zero();
		pRaycastWheel->raycast_dir_cs.k[index_y] = gravity_y_direction;

		// Spring (Shocks) data.
		pRaycastWheel->spring_len = -pCarSystemTemplate->spring_pre_tension[iWheel];

		pRaycastWheel->spring_direction_cs.set_to_zero();
		pRaycastWheel->spring_direction_cs.k[index_y] = gravity_y_direction;
		
		pRaycastWheel->spring_constant = pCarSystemTemplate->spring_constant[iWheel];
		pRaycastWheel->spring_damp_relax = pCarSystemTemplate->spring_dampening[iWheel];
		pRaycastWheel->spring_damp_compress = pCarSystemTemplate->spring_dampening_compression[iWheel];

		// Wheel data.
		pRaycastWheel->friction_of_wheel = 1.0f;//pCarSystemTemplate->friction_of_wheel[iWheel];
		pRaycastWheel->wheel_radius = pCarSystemTemplate->wheel_radius[iWheel];
		pRaycastWheel->inv_wheel_radius = 1.0f / pCarSystemTemplate->wheel_radius[iWheel];

		do_steering_wheel( IVP_POS_WHEEL( iWheel ), 0.0f );
		
		pRaycastWheel->wheel_is_fixed = IVP_FALSE;	
		pRaycastWheel->max_rotation_speed = pCarSystemTemplate->wheel_max_rotation_speed[iWheel>>1];

		pRaycastWheel->wheel_is_fixed = IVP_TRUE;
    }
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPhysics_Airboat::InitRaycastCarAxes( const IVP_Template_Car_System *pCarSystemTemplate )
{
    m_SteeringAngle = -1.0f;			// make sure next call is not optimized
    this->do_steering( 0.0f, false );	// make sure next call gets through

    for ( int iAxis = 0; iAxis < n_axis; iAxis++ )
	{
		IVP_Raycast_Airboat_Axle *pAxle = get_axle( IVP_POS_AXIS( iAxis ) );
		pAxle->stabilizer_constant = pCarSystemTemplate->stabilizer_constant[iAxis];
    }    
}


//-----------------------------------------------------------------------------
// Purpose: Debug data for use in vphysics and the engine to visualize car data.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::SetCarSystemDebugData( const IVP_CarSystemDebugData_t &carSystemDebugData )
{
	// Wheels (raycast data only!)
	for ( int iWheel = 0; iWheel < IVP_RAYCAST_AIRBOAT_MAX_WHEELS; ++iWheel )
	{
		m_CarSystemDebugData.wheelRaycasts[iWheel][0] = carSystemDebugData.wheelRaycasts[iWheel][0];
		m_CarSystemDebugData.wheelRaycasts[iWheel][1] = carSystemDebugData.wheelRaycasts[iWheel][1];
		m_CarSystemDebugData.wheelRaycastImpacts[iWheel] = carSystemDebugData.wheelRaycastImpacts[iWheel];
	}
}


//-----------------------------------------------------------------------------
// Purpose: Debug data for use in vphysics and the engine to visualize car data.
//-----------------------------------------------------------------------------
void CPhysics_Airboat::GetCarSystemDebugData( IVP_CarSystemDebugData_t &carSystemDebugData )
{
	// Wheels (raycast data only!)
	for ( int iWheel = 0; iWheel < IVP_RAYCAST_AIRBOAT_MAX_WHEELS; ++iWheel )
	{
		carSystemDebugData.wheelRaycasts[iWheel][0] = m_CarSystemDebugData.wheelRaycasts[iWheel][0];
		carSystemDebugData.wheelRaycasts[iWheel][1] = m_CarSystemDebugData.wheelRaycasts[iWheel][1];
		carSystemDebugData.wheelRaycastImpacts[iWheel] = m_CarSystemDebugData.wheelRaycastImpacts[iWheel];
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Output : IVP_U_Vector<IVP_Core>
//-----------------------------------------------------------------------------
IVP_U_Vector<IVP_Core> *CPhysics_Airboat::get_associated_controlled_cores( void )
{ 
	return &vector_of_cores; 
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *core - 
//-----------------------------------------------------------------------------
void CPhysics_Airboat::core_is_going_to_be_deleted_event( IVP_Core *core )
{ 
	P_DELETE_THIS(this); 
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : i - 
// Output : IVP_Raycast_Airboat_Axle
//-----------------------------------------------------------------------------
IVP_Raycast_Airboat_Axle *CPhysics_Airboat::get_axle( IVP_POS_AXIS i )
{ 
	return &m_aAirboatAxles[i]; 
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : i - 
// Output : IVP_Raycast_Airboat_Wheel
//-----------------------------------------------------------------------------
IVP_Raycast_Airboat_Wheel *CPhysics_Airboat::get_wheel( IVP_POS_WHEEL i )
{ 
	return &m_aAirboatWheels[i]; 
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
IVP_Controller_Raycast_Airboat_Vector_of_Cores_1::IVP_Controller_Raycast_Airboat_Vector_of_Cores_1():
							IVP_U_Vector<IVP_Core>( &elem_buffer[0],1 ) 
{
}