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