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.
 
 
 
 
 
 

1045 lines
30 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "vcollide_parse.h"
#include "filesystem.h"
#include "engine/IStaticPropMgr.h"
#include "solidsetdefaults.h"
#include "engine/IEngineSound.h"
#include "vphysics_sound.h"
#include "movevars_shared.h"
#include "engine/ivmodelinfo.h"
#include "fx.h"
#include "tier0/vprof.h"
#include "c_world.h"
#include "vphysics/object_hash.h"
#include "vphysics/collision_set.h"
#include "soundenvelope.h"
#include "fx_water.h"
#include "positionwatcher.h"
#include "vphysics/constraints.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// file system interface
extern IFileSystem *filesystem;
ConVar cl_phys_timescale( "cl_phys_timescale", "1.0", FCVAR_CHEAT, "Sets the scale of time for client-side physics (ragdolls)" );
void PrecachePhysicsSounds( void );
//FIXME: Replicated from server end, consolidate?
extern IVEngineClient *engine;
class CCollisionEvent : public IPhysicsCollisionEvent, public IPhysicsCollisionSolver, public IPhysicsObjectEvent
{
public:
CCollisionEvent( void ) = default;
void ObjectSound( int index, vcollisionevent_t *pEvent );
void PreCollision( vcollisionevent_t *pEvent ) {}
void PostCollision( vcollisionevent_t *pEvent );
void Friction( IPhysicsObject *pObject, float energy, int surfaceProps, int surfacePropsHit, IPhysicsCollisionData *pData );
void BufferTouchEvents( bool enable ) { m_bBufferTouchEvents = enable; }
void StartTouch( IPhysicsObject *pObject1, IPhysicsObject *pObject2, IPhysicsCollisionData *pTouchData );
void EndTouch( IPhysicsObject *pObject1, IPhysicsObject *pObject2, IPhysicsCollisionData *pTouchData );
void FluidStartTouch( IPhysicsObject *pObject, IPhysicsFluidController *pFluid );
void FluidEndTouch( IPhysicsObject *pObject, IPhysicsFluidController *pFluid );
void PostSimulationFrame() {}
virtual void ObjectEnterTrigger( IPhysicsObject *pTrigger, IPhysicsObject *pObject ) {}
virtual void ObjectLeaveTrigger( IPhysicsObject *pTrigger, IPhysicsObject *pObject ) {}
float DeltaTimeSinceLastFluid( CBaseEntity *pEntity );
void FrameUpdate( void );
void UpdateFluidEvents( void );
void UpdateTouchEvents( void );
// IPhysicsCollisionSolver
int ShouldCollide( IPhysicsObject *pObj0, IPhysicsObject *pObj1, void *pGameData0, void *pGameData1 );
#if _DEBUG
int ShouldCollide_2( IPhysicsObject *pObj0, IPhysicsObject *pObj1, void *pGameData0, void *pGameData1 );
#endif
// debugging collision problem in TF2
int ShouldSolvePenetration( IPhysicsObject *pObj0, IPhysicsObject *pObj1, void *pGameData0, void *pGameData1, float dt );
bool ShouldFreezeObject( IPhysicsObject *pObject ) { return true; }
int AdditionalCollisionChecksThisTick( int currentChecksDone ) { return 0; }
bool ShouldFreezeContacts( IPhysicsObject **pObjectList, int objectCount ) { return true; }
// IPhysicsObjectEvent
virtual void ObjectWake( IPhysicsObject *pObject )
{
C_BaseEntity *pEntity = static_cast<C_BaseEntity *>(pObject->GetGameData());
if (pEntity && pEntity->HasDataObjectType(VPHYSICSWATCHER))
{
ReportVPhysicsStateChanged( pObject, pEntity, true );
}
}
virtual void ObjectSleep( IPhysicsObject *pObject )
{
C_BaseEntity *pEntity = static_cast<C_BaseEntity *>(pObject->GetGameData());
if ( pEntity && pEntity->HasDataObjectType( VPHYSICSWATCHER ) )
{
ReportVPhysicsStateChanged( pObject, pEntity, false );
}
}
friction_t *FindFriction( CBaseEntity *pObject );
void ShutdownFriction( friction_t &friction );
void UpdateFrictionSounds();
bool IsInCallback() { return m_inCallback > 0 ? true : false; }
private:
class CallbackContext
{
public:
CallbackContext(CCollisionEvent *pOuter)
{
m_pOuter = pOuter;
m_pOuter->m_inCallback++;
}
~CallbackContext()
{
m_pOuter->m_inCallback--;
}
private:
CCollisionEvent *m_pOuter;
};
friend class CallbackContext;
void AddTouchEvent( C_BaseEntity *pEntity0, C_BaseEntity *pEntity1, int touchType, const Vector &point, const Vector &normal );
void DispatchStartTouch( C_BaseEntity *pEntity0, C_BaseEntity *pEntity1, const Vector &point, const Vector &normal );
void DispatchEndTouch( C_BaseEntity *pEntity0, C_BaseEntity *pEntity1 );
friction_t m_current[8];
CUtlVector<fluidevent_t> m_fluidEvents;
CUtlVector<touchevent_t> m_touchEvents;
int m_inCallback;
bool m_bBufferTouchEvents;
};
CCollisionEvent g_Collisions;
bool PhysIsInCallback()
{
if ( (physenv && physenv->IsInSimulation()) || g_Collisions.IsInCallback() )
return true;
return false;
}
bool PhysicsDLLInit( CreateInterfaceFn physicsFactory )
{
if ((physics = (IPhysics *)physicsFactory( VPHYSICS_INTERFACE_VERSION, NULL )) == NULL ||
(physprops = (IPhysicsSurfaceProps *)physicsFactory( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, NULL )) == NULL ||
(physcollision = (IPhysicsCollision *)physicsFactory( VPHYSICS_COLLISION_INTERFACE_VERSION, NULL )) == NULL )
{
return false;
}
if ( IsX360() )
{
// Reduce timescale to save perf on 360
cl_phys_timescale.SetValue(0.9f);
}
PhysParseSurfaceData( physprops, filesystem );
return true;
}
#define DEFAULT_XBOX_CLIENT_VPHYSICS_TICK 0.025 // 25ms ticks on xbox ragdolls
void PhysicsLevelInit( void )
{
physenv = physics->CreateEnvironment();
assert( physenv );
#ifdef PORTAL
physenv_main = physenv;
#endif
{
MEM_ALLOC_CREDIT();
g_EntityCollisionHash = physics->CreateObjectPairHash();
}
// TODO: need to get the right factory function here
//physenv->SetDebugOverlay( appSystemFactory );
physenv->SetGravity( Vector(0, 0, -GetCurrentGravity() ) );
// 15 ms per tick
// NOTE: Always run client physics at this rate - helps keep ragdolls stable
physenv->SetSimulationTimestep( IsXbox() ? DEFAULT_XBOX_CLIENT_VPHYSICS_TICK : DEFAULT_TICK_INTERVAL );
physenv->SetCollisionEventHandler( &g_Collisions );
physenv->SetCollisionSolver( &g_Collisions );
g_PhysWorldObject = PhysCreateWorld_Shared( GetClientWorldEntity(), modelinfo->GetVCollide(1), g_PhysDefaultObjectParams );
staticpropmgr->CreateVPhysicsRepresentations( physenv, &g_SolidSetup, NULL );
}
void PhysicsReset()
{
if ( !physenv )
return;
physenv->ResetSimulationClock();
}
ConVar cl_ragdoll_collide( "cl_ragdoll_collide", "0" );
int CCollisionEvent::ShouldCollide( IPhysicsObject *pObj0, IPhysicsObject *pObj1, void *pGameData0, void *pGameData1 )
#if _DEBUG
{
int x0 = ShouldCollide_2(pObj0, pObj1, pGameData0, pGameData1);
int x1 = ShouldCollide_2(pObj1, pObj0, pGameData1, pGameData0);
Assert(x0==x1);
return x0;
}
int CCollisionEvent::ShouldCollide_2( IPhysicsObject *pObj0, IPhysicsObject *pObj1, void *pGameData0, void *pGameData1 )
#endif
{
CallbackContext callback(this);
C_BaseEntity *pEntity0 = static_cast<C_BaseEntity *>(pGameData0);
C_BaseEntity *pEntity1 = static_cast<C_BaseEntity *>(pGameData1);
if ( !pEntity0 || !pEntity1 )
return 1;
unsigned short gameFlags0 = pObj0->GetGameFlags();
unsigned short gameFlags1 = pObj1->GetGameFlags();
if ( pEntity0 == pEntity1 )
{
// allow all-or-nothing per-entity disable
if ( (gameFlags0 | gameFlags1) & FVPHYSICS_NO_SELF_COLLISIONS )
return 0;
IPhysicsCollisionSet *pSet = physics->FindCollisionSet( pEntity0->GetModelIndex() );
if ( pSet )
return pSet->ShouldCollide( pObj0->GetGameIndex(), pObj1->GetGameIndex() );
return 1;
}
// Obey collision group rules
Assert(GameRules());
if ( GameRules() )
{
if (!GameRules()->ShouldCollide( pEntity0->GetCollisionGroup(), pEntity1->GetCollisionGroup() ))
return 0;
}
if ( (pObj0->GetGameFlags() & FVPHYSICS_PART_OF_RAGDOLL) && (pObj1->GetGameFlags() & FVPHYSICS_PART_OF_RAGDOLL) )
{
if ( !cl_ragdoll_collide.GetBool() )
return 0;
}
// check contents
if ( !(pObj0->GetContents() & pEntity1->PhysicsSolidMaskForEntity()) || !(pObj1->GetContents() & pEntity0->PhysicsSolidMaskForEntity()) )
return 0;
if ( g_EntityCollisionHash->IsObjectPairInHash( pGameData0, pGameData1 ) )
return 0;
if ( g_EntityCollisionHash->IsObjectPairInHash( pObj0, pObj1 ) )
return 0;
#if 0
int solid0 = pEntity0->GetSolid();
int solid1 = pEntity1->GetSolid();
int nSolidFlags0 = pEntity0->GetSolidFlags();
int nSolidFlags1 = pEntity1->GetSolidFlags();
#endif
int movetype0 = pEntity0->GetMoveType();
int movetype1 = pEntity1->GetMoveType();
// entities with non-physical move parents or entities with MOVETYPE_PUSH
// are considered as "AI movers". They are unchanged by collision; they exert
// physics forces on the rest of the system.
bool aiMove0 = (movetype0==MOVETYPE_PUSH) ? true : false;
bool aiMove1 = (movetype1==MOVETYPE_PUSH) ? true : false;
if ( pEntity0->GetMoveParent() )
{
// if the object & its parent are both MOVETYPE_VPHYSICS, then this must be a special case
// like a prop_ragdoll_attached
if ( !(movetype0 == MOVETYPE_VPHYSICS && pEntity0->GetRootMoveParent()->GetMoveType() == MOVETYPE_VPHYSICS) )
{
aiMove0 = true;
}
}
if ( pEntity1->GetMoveParent() )
{
// if the object & its parent are both MOVETYPE_VPHYSICS, then this must be a special case.
if ( !(movetype1 == MOVETYPE_VPHYSICS && pEntity1->GetRootMoveParent()->GetMoveType() == MOVETYPE_VPHYSICS) )
{
aiMove1 = true;
}
}
// AI movers don't collide with the world/static/pinned objects or other AI movers
if ( (aiMove0 && !pObj1->IsMoveable()) ||
(aiMove1 && !pObj0->IsMoveable()) ||
(aiMove0 && aiMove1) )
return 0;
// two objects under shadow control should not collide. The AI will figure it out
if ( pObj0->GetShadowController() && pObj1->GetShadowController() )
return 0;
return 1;
}
int CCollisionEvent::ShouldSolvePenetration( IPhysicsObject *pObj0, IPhysicsObject *pObj1, void *pGameData0, void *pGameData1, float dt )
{
CallbackContext callback(this);
// solve it yourself here and return 0, or have the default implementation do it
if ( pGameData0 == pGameData1 )
{
if ( pObj0->GetGameFlags() & FVPHYSICS_PART_OF_RAGDOLL )
{
// this is a ragdoll, self penetrating
C_BaseEntity *pEnt = reinterpret_cast<C_BaseEntity *>(pGameData0);
C_BaseAnimating *pAnim = pEnt->GetBaseAnimating();
if ( pAnim && pAnim->m_pRagdoll )
{
IPhysicsConstraintGroup *pGroup = pAnim->m_pRagdoll->GetConstraintGroup();
if ( pGroup )
{
pGroup->SolvePenetration( pObj0, pObj1 );
return false;
}
}
}
}
return true;
}
// A class that implements an IClientSystem for physics
class CPhysicsSystem : public CAutoGameSystemPerFrame
{
public:
CPhysicsSystem( char const *name ) : CAutoGameSystemPerFrame( name )
{
}
// HACKHACK: PhysicsDLLInit() is called explicitly because it requires a parameter
virtual bool Init();
virtual void Shutdown();
// Level init, shutdown
virtual void LevelInitPreEntity();
virtual void LevelInitPostEntity();
// The level is shutdown in two parts
virtual void LevelShutdownPreEntity();
virtual void LevelShutdownPostEntity();
void AddImpactSound( void *pGameData, IPhysicsObject *pObject, int surfaceProps, int surfacePropsHit, float volume, float speed );
virtual void Update( float frametime );
void PhysicsSimulate();
private:
physicssound::soundlist_t m_impactSounds;
};
static CPhysicsSystem g_PhysicsSystem( "CPhysicsSystem" );
// singleton to hook into the client system
IGameSystem *PhysicsGameSystem( void )
{
return &g_PhysicsSystem;
}
// HACKHACK: PhysicsDLLInit() is called explicitly because it requires a parameter
bool CPhysicsSystem::Init()
{
return true;
}
void CPhysicsSystem::Shutdown()
{
}
// Level init, shutdown
void CPhysicsSystem::LevelInitPreEntity( void )
{
m_impactSounds.RemoveAll();
PrecachePhysicsSounds();
}
void CPhysicsSystem::LevelInitPostEntity( void )
{
PhysicsLevelInit();
}
// The level is shutdown in two parts
void CPhysicsSystem::LevelShutdownPreEntity()
{
if ( physenv )
{
// we may have deleted multiple objects including the world by now, so
// don't try to wake them up
physenv->SetQuickDelete( true );
}
}
void CPhysicsSystem::LevelShutdownPostEntity()
{
if ( physenv )
{
// environment destroys all objects
// entities are gone, so this is safe now
physics->DestroyEnvironment( physenv );
}
physics->DestroyObjectPairHash( g_EntityCollisionHash );
g_EntityCollisionHash = NULL;
physics->DestroyAllCollisionSets();
physenv = NULL;
g_PhysWorldObject = NULL;
}
void CPhysicsSystem::AddImpactSound( void *pGameData, IPhysicsObject *pObject, int surfaceProps, int surfacePropsHit, float volume, float speed )
{
physicssound::AddImpactSound( m_impactSounds, pGameData, SOUND_FROM_WORLD, CHAN_STATIC, pObject, surfaceProps, surfacePropsHit, volume, speed );
}
void CPhysicsSystem::Update( float frametime )
{
// THIS WAS MOVED TO POST-ENTITY SIM
//PhysicsSimulate();
}
void CPhysicsSystem::PhysicsSimulate()
{
VPROF_BUDGET( "CPhysicsSystem::PhysicsSimulate", VPROF_BUDGETGROUP_PHYSICS );
float frametime = gpGlobals->frametime;
if ( physenv )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s %d", __FUNCTION__, physenv->GetActiveObjectCount() );
g_Collisions.BufferTouchEvents( true );
#ifdef _DEBUG
physenv->DebugCheckContacts();
#endif
physenv->Simulate( frametime * cl_phys_timescale.GetFloat() );
int activeCount = physenv->GetActiveObjectCount();
IPhysicsObject **pActiveList = NULL;
if ( activeCount )
{
pActiveList = (IPhysicsObject **)stackalloc( sizeof(IPhysicsObject *)*activeCount );
physenv->GetActiveObjects( pActiveList );
for ( int i = 0; i < activeCount; i++ )
{
C_BaseEntity *pEntity = reinterpret_cast<C_BaseEntity *>(pActiveList[i]->GetGameData());
if ( pEntity )
{
if ( pEntity->CollisionProp()->DoesVPhysicsInvalidateSurroundingBox() )
{
pEntity->CollisionProp()->MarkSurroundingBoundsDirty();
}
pEntity->VPhysicsUpdate( pActiveList[i] );
}
}
}
g_Collisions.BufferTouchEvents( false );
g_Collisions.FrameUpdate();
}
physicssound::PlayImpactSounds( m_impactSounds );
}
void PhysicsSimulate()
{
g_PhysicsSystem.PhysicsSimulate();
}
void CCollisionEvent::ObjectSound( int index, vcollisionevent_t *pEvent )
{
IPhysicsObject *pObject = pEvent->pObjects[index];
if ( !pObject || pObject->IsStatic() )
return;
float speed = pEvent->collisionSpeed * pEvent->collisionSpeed;
int surfaceProps = pEvent->surfaceProps[index];
void *pGameData = pObject->GetGameData();
if ( pGameData )
{
float volume = speed * (1.0f/(320.0f*320.0f)); // max volume at 320 in/s
if ( volume > 1.0f )
volume = 1.0f;
if ( surfaceProps >= 0 )
{
g_PhysicsSystem.AddImpactSound( pGameData, pObject, surfaceProps, pEvent->surfaceProps[!index], volume, speed );
}
}
}
void CCollisionEvent::PostCollision( vcollisionevent_t *pEvent )
{
CallbackContext callback(this);
if ( pEvent->deltaCollisionTime > 0.1f && pEvent->collisionSpeed > 70 )
{
ObjectSound( 0, pEvent );
ObjectSound( 1, pEvent );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCollisionEvent::FrameUpdate( void )
{
UpdateFrictionSounds();
UpdateTouchEvents();
UpdateFluidEvents();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCollisionEvent::UpdateTouchEvents( void )
{
// Turn on buffering in case new touch events occur during processing
bool bOldTouchEvents = m_bBufferTouchEvents;
m_bBufferTouchEvents = true;
for ( int i = 0; i < m_touchEvents.Count(); i++ )
{
const touchevent_t &event = m_touchEvents[i];
if ( event.touchType == TOUCH_START )
{
DispatchStartTouch( event.pEntity0, event.pEntity1, event.endPoint, event.normal );
}
else
{
// TOUCH_END
DispatchEndTouch( event.pEntity0, event.pEntity1 );
}
}
m_touchEvents.RemoveAll();
m_bBufferTouchEvents = bOldTouchEvents;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEntity0 -
// *pEntity1 -
// touchType -
//-----------------------------------------------------------------------------
void CCollisionEvent::AddTouchEvent( C_BaseEntity *pEntity0, C_BaseEntity *pEntity1, int touchType, const Vector &point, const Vector &normal )
{
if ( !pEntity0 || !pEntity1 )
return;
int index = m_touchEvents.AddToTail();
touchevent_t &event = m_touchEvents[index];
event.pEntity0 = pEntity0;
event.pEntity1 = pEntity1;
event.touchType = touchType;
event.endPoint = point;
event.normal = normal;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObject1 -
// *pObject2 -
// *pTouchData -
//-----------------------------------------------------------------------------
void CCollisionEvent::StartTouch( IPhysicsObject *pObject1, IPhysicsObject *pObject2, IPhysicsCollisionData *pTouchData )
{
CallbackContext callback(this);
C_BaseEntity *pEntity1 = static_cast<C_BaseEntity *>(pObject1->GetGameData());
C_BaseEntity *pEntity2 = static_cast<C_BaseEntity *>(pObject2->GetGameData());
if ( !pEntity1 || !pEntity2 )
return;
Vector endPoint, normal;
pTouchData->GetContactPoint( endPoint );
pTouchData->GetSurfaceNormal( normal );
if ( !m_bBufferTouchEvents )
{
DispatchStartTouch( pEntity1, pEntity2, endPoint, normal );
}
else
{
AddTouchEvent( pEntity1, pEntity2, TOUCH_START, endPoint, normal );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEntity0 -
// *pEntity1 -
//-----------------------------------------------------------------------------
void CCollisionEvent::DispatchStartTouch( C_BaseEntity *pEntity0, C_BaseEntity *pEntity1, const Vector &point, const Vector &normal )
{
trace_t trace;
memset( &trace, 0, sizeof(trace) );
trace.endpos = point;
trace.plane.dist = DotProduct( point, normal );
trace.plane.normal = normal;
// NOTE: This sets up the touch list for both entities, no call to pEntity1 is needed
pEntity0->PhysicsMarkEntitiesAsTouchingEventDriven( pEntity1, trace );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObject1 -
// *pObject2 -
// *pTouchData -
//-----------------------------------------------------------------------------
void CCollisionEvent::EndTouch( IPhysicsObject *pObject1, IPhysicsObject *pObject2, IPhysicsCollisionData *pTouchData )
{
CallbackContext callback(this);
C_BaseEntity *pEntity1 = static_cast<C_BaseEntity *>(pObject1->GetGameData());
C_BaseEntity *pEntity2 = static_cast<C_BaseEntity *>(pObject2->GetGameData());
if ( !pEntity1 || !pEntity2 )
return;
if ( !m_bBufferTouchEvents )
{
DispatchEndTouch( pEntity1, pEntity2 );
}
else
{
AddTouchEvent( pEntity1, pEntity2, TOUCH_END, vec3_origin, vec3_origin );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEntity0 -
// *pEntity1 -
//-----------------------------------------------------------------------------
void CCollisionEvent::DispatchEndTouch( C_BaseEntity *pEntity0, C_BaseEntity *pEntity1 )
{
// frees the event-driven touchlinks
pEntity0->PhysicsNotifyOtherOfUntouch( pEntity0, pEntity1 );
pEntity1->PhysicsNotifyOtherOfUntouch( pEntity1, pEntity0 );
}
void CCollisionEvent::Friction( IPhysicsObject *pObject, float energy, int surfaceProps, int surfacePropsHit, IPhysicsCollisionData *pData )
{
CallbackContext callback(this);
if ( energy < 0.05f || surfaceProps < 0 )
return;
//Get our friction information
Vector vecPos, vecVel;
pData->GetContactPoint( vecPos );
pObject->GetVelocityAtPoint( vecPos, &vecVel );
CBaseEntity *pEntity = reinterpret_cast<CBaseEntity *>(pObject->GetGameData());
if ( pEntity )
{
friction_t *pFriction = g_Collisions.FindFriction( pEntity );
if ( (gpGlobals->maxClients > 1) && pFriction && pFriction->pObject)
{
// in MP mode play sound and effects once every 500 msecs,
// no ongoing updates, takes too much bandwidth
if ( (pFriction->flLastEffectTime + 0.5f) > gpGlobals->curtime)
{
pFriction->flLastUpdateTime = gpGlobals->curtime;
return;
}
}
PhysFrictionSound( pEntity, pObject, energy, surfaceProps, surfacePropsHit );
}
PhysFrictionEffect( vecPos, vecVel, energy, surfaceProps, surfacePropsHit );
}
friction_t *CCollisionEvent::FindFriction( CBaseEntity *pObject )
{
friction_t *pFree = NULL;
for ( int i = 0; i < ARRAYSIZE(m_current); i++ )
{
if ( !m_current[i].pObject && !pFree )
pFree = &m_current[i];
if ( m_current[i].pObject == pObject )
return &m_current[i];
}
return pFree;
}
void CCollisionEvent::ShutdownFriction( friction_t &friction )
{
// Msg( "Scrape Stop %s \n", STRING(friction.pObject->m_iClassname) );
CSoundEnvelopeController::GetController().SoundDestroy( friction.patch );
friction.patch = NULL;
friction.pObject = NULL;
}
void CCollisionEvent::UpdateFrictionSounds( void )
{
for ( int i = 0; i < ARRAYSIZE(m_current); i++ )
{
if ( m_current[i].patch )
{
if ( m_current[i].flLastUpdateTime < (gpGlobals->curtime-0.1f) )
{
// friction wasn't updated the last 100msec, assume fiction finished
ShutdownFriction( m_current[i] );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &matrix -
// &normal -
// Output : static int
//-----------------------------------------------------------------------------
static int BestAxisMatchingNormal( matrix3x4_t &matrix, const Vector &normal )
{
float bestDot = -1;
int best = 0;
for ( int i = 0; i < 3; i++ )
{
Vector tmp;
MatrixGetColumn( matrix, i, tmp );
float dot = fabs(DotProduct( tmp, normal ));
if ( dot > bestDot )
{
bestDot = dot;
best = i;
}
}
return best;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFluid -
// *pObject -
// *pEntity -
//-----------------------------------------------------------------------------
void PhysicsSplash( IPhysicsFluidController *pFluid, IPhysicsObject *pObject, CBaseEntity *pEntity )
{
//FIXME: For now just allow ragdolls for E3 - jdw
if ( ( pObject->GetGameFlags() & FVPHYSICS_PART_OF_RAGDOLL ) == false )
return;
Vector velocity;
pObject->GetVelocity( &velocity, NULL );
float impactSpeed = velocity.Length();
if ( impactSpeed < 25.0f )
return;
Vector normal;
float dist;
pFluid->GetSurfacePlane( &normal, &dist );
matrix3x4_t &matrix = pEntity->EntityToWorldTransform();
// Find the local axis that best matches the water surface normal
int bestAxis = BestAxisMatchingNormal( matrix, normal );
Vector tangent, binormal;
MatrixGetColumn( matrix, (bestAxis+1)%3, tangent );
binormal = CrossProduct( normal, tangent );
VectorNormalize( binormal );
tangent = CrossProduct( binormal, normal );
VectorNormalize( tangent );
// Now we have a basis tangent to the surface that matches the object's local orientation as well as possible
// compute an OBB using this basis
// Get object extents in basis
Vector tanPts[2], binPts[2];
tanPts[0] = physcollision->CollideGetExtent( pObject->GetCollide(), pEntity->GetAbsOrigin(), pEntity->GetAbsAngles(), -tangent );
tanPts[1] = physcollision->CollideGetExtent( pObject->GetCollide(), pEntity->GetAbsOrigin(), pEntity->GetAbsAngles(), tangent );
binPts[0] = physcollision->CollideGetExtent( pObject->GetCollide(), pEntity->GetAbsOrigin(), pEntity->GetAbsAngles(), -binormal );
binPts[1] = physcollision->CollideGetExtent( pObject->GetCollide(), pEntity->GetAbsOrigin(), pEntity->GetAbsAngles(), binormal );
// now compute the centered bbox
float mins[2], maxs[2], center[2], extents[2];
mins[0] = DotProduct( tanPts[0], tangent );
maxs[0] = DotProduct( tanPts[1], tangent );
mins[1] = DotProduct( binPts[0], binormal );
maxs[1] = DotProduct( binPts[1], binormal );
center[0] = 0.5 * (mins[0] + maxs[0]);
center[1] = 0.5 * (mins[1] + maxs[1]);
extents[0] = maxs[0] - center[0];
extents[1] = maxs[1] - center[1];
Vector centerPoint = center[0] * tangent + center[1] * binormal + dist * normal;
Vector axes[2];
axes[0] = (maxs[0] - center[0]) * tangent;
axes[1] = (maxs[1] - center[1]) * binormal;
// visualize OBB hit
/*
Vector corner1 = centerPoint - axes[0] - axes[1];
Vector corner2 = centerPoint + axes[0] - axes[1];
Vector corner3 = centerPoint + axes[0] + axes[1];
Vector corner4 = centerPoint - axes[0] + axes[1];
NDebugOverlay::Line( corner1, corner2, 0, 0, 255, false, 10 );
NDebugOverlay::Line( corner2, corner3, 0, 0, 255, false, 10 );
NDebugOverlay::Line( corner3, corner4, 0, 0, 255, false, 10 );
NDebugOverlay::Line( corner4, corner1, 0, 0, 255, false, 10 );
*/
Vector corner[4];
corner[0] = centerPoint - axes[0] - axes[1];
corner[1] = centerPoint + axes[0] - axes[1];
corner[2] = centerPoint + axes[0] + axes[1];
corner[3] = centerPoint - axes[0] + axes[1];
int contents = enginetrace->GetPointContents( centerPoint-Vector(0,0,2) );
bool bInSlime = ( contents & CONTENTS_SLIME ) ? true : false;
Vector color = vec3_origin;
float luminosity = 1.0f;
if ( !bInSlime )
{
// Get our lighting information
FX_GetSplashLighting( centerPoint + ( normal * 8.0f ), &color, &luminosity );
}
if ( impactSpeed > 150 )
{
if ( bInSlime )
{
FX_GunshotSlimeSplash( centerPoint, normal, random->RandomFloat( 8, 10 ) );
}
else
{
FX_GunshotSplash( centerPoint, normal, random->RandomFloat( 8, 10 ) );
}
}
else if ( !bInSlime )
{
FX_WaterRipple( centerPoint, 1.5f, &color, 1.5f, luminosity );
}
int splashes = 4;
Vector point;
for ( int i = 0; i < splashes; i++ )
{
point = RandomVector( -32.0f, 32.0f );
point[2] = 0.0f;
point += corner[i];
if ( impactSpeed > 150 )
{
if ( bInSlime )
{
FX_GunshotSlimeSplash( centerPoint, normal, random->RandomFloat( 4, 6 ) );
}
else
{
FX_GunshotSplash( centerPoint, normal, random->RandomFloat( 4, 6 ) );
}
}
else if ( !bInSlime )
{
FX_WaterRipple( point, random->RandomFloat( 0.25f, 0.5f ), &color, luminosity, random->RandomFloat( 0.5f, 1.0f ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCollisionEvent::UpdateFluidEvents( void )
{
for ( int i = m_fluidEvents.Count()-1; i >= 0; --i )
{
if ( (gpGlobals->curtime - m_fluidEvents[i].impactTime) > FLUID_TIME_MAX )
{
m_fluidEvents.FastRemove(i);
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEntity -
// Output : float
//-----------------------------------------------------------------------------
float CCollisionEvent::DeltaTimeSinceLastFluid( CBaseEntity *pEntity )
{
for ( int i = m_fluidEvents.Count()-1; i >= 0; --i )
{
if ( m_fluidEvents[i].hEntity.Get() == pEntity )
{
return gpGlobals->curtime - m_fluidEvents[i].impactTime;
}
}
int index = m_fluidEvents.AddToTail();
m_fluidEvents[index].hEntity = pEntity;
m_fluidEvents[index].impactTime = gpGlobals->curtime;
return FLUID_TIME_MAX;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObject -
// *pFluid -
//-----------------------------------------------------------------------------
void CCollisionEvent::FluidStartTouch( IPhysicsObject *pObject, IPhysicsFluidController *pFluid )
{
CallbackContext callback(this);
if ( ( pObject == NULL ) || ( pFluid == NULL ) )
return;
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pObject->GetGameData());
if ( pEntity )
{
float timeSinceLastCollision = DeltaTimeSinceLastFluid( pEntity );
if ( timeSinceLastCollision < 0.5f )
return;
PhysicsSplash( pFluid, pObject, pEntity );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObject -
// *pFluid -
//-----------------------------------------------------------------------------
void CCollisionEvent::FluidEndTouch( IPhysicsObject *pObject, IPhysicsFluidController *pFluid )
{
CallbackContext callback(this);
//FIXME: Do nothing for now
}
IPhysicsObject *GetWorldPhysObject ( void )
{
return g_PhysWorldObject;
}
void PhysFrictionSound( CBaseEntity *pEntity, IPhysicsObject *pObject, const char *pSoundName, HSOUNDSCRIPTHANDLE& handle, float flVolume )
{
if ( !pEntity )
return;
// cut out the quiet sounds
// UNDONE: Separate threshold for starting a sound vs. continuing?
flVolume = clamp( flVolume, 0.0f, 1.0f );
if ( flVolume > (1.0f/128.0f) )
{
friction_t *pFriction = g_Collisions.FindFriction( pEntity );
if ( !pFriction )
return;
CSoundParameters params;
if ( !CBaseEntity::GetParametersForSound( pSoundName, handle, params, NULL ) )
return;
if ( !pFriction->pObject )
{
// don't create really quiet scrapes
if ( params.volume * flVolume <= 0.1f )
return;
pFriction->pObject = pEntity;
CPASAttenuationFilter filter( pEntity, params.soundlevel );
int entindex = pEntity->entindex();
// clientside created entites doesn't have a valid entindex, let 'world' play the sound for them
if ( entindex < 0 )
entindex = 0;
pFriction->patch = CSoundEnvelopeController::GetController().SoundCreate(
filter, entindex, CHAN_BODY, pSoundName, params.soundlevel );
CSoundEnvelopeController::GetController().Play( pFriction->patch, params.volume * flVolume, params.pitch );
}
else
{
float pitch = (flVolume * (params.pitchhigh - params.pitchlow)) + params.pitchlow;
CSoundEnvelopeController::GetController().SoundChangeVolume( pFriction->patch, params.volume * flVolume, 0.1f );
CSoundEnvelopeController::GetController().SoundChangePitch( pFriction->patch, pitch, 0.1f );
}
pFriction->flLastUpdateTime = gpGlobals->curtime;
pFriction->flLastEffectTime = gpGlobals->curtime;
}
}
void PhysCleanupFrictionSounds( CBaseEntity *pEntity )
{
friction_t *pFriction = g_Collisions.FindFriction( pEntity );
if ( pFriction && pFriction->patch )
{
g_Collisions.ShutdownFriction( *pFriction );
}
}
float PhysGetNextSimTime()
{
return physenv->GetSimulationTime() + gpGlobals->frametime * cl_phys_timescale.GetFloat();
}
float PhysGetSyncCreateTime()
{
float nextTime = physenv->GetNextFrameTime();
float simTime = PhysGetNextSimTime();
if ( nextTime < simTime )
{
// The next simulation frame begins before the end of this frame
// so create physics objects at that time so that they will reach the current
// position at curtime. Otherwise the physics object will simulate forward from curtime
// and pop into the future a bit at this point of transition
return gpGlobals->curtime + nextTime - simTime;
}
return gpGlobals->curtime;
}