d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
175 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 94916a20ce
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '94916a20ce'
${ noResults }
source-engine/vphysics/physics_airboat.cpp

1796 lines
63 KiB
Raw Blame History

//========= 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 )
{
}