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.
 
 
 
 
 
 

2933 lines
84 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Interface layer for ipion IVP physics.
//
// $Workfile: $
// $Date: $
// $NoKeywords: $
//===========================================================================//
#include "cbase.h"
#include "coordsize.h"
#include "entitylist.h"
#include "vcollide_parse.h"
#include "soundenvelope.h"
#include "game.h"
#include "utlvector.h"
#include "init_factory.h"
#include "igamesystem.h"
#include "hierarchy.h"
#include "IEffects.h"
#include "engine/IEngineSound.h"
#include "world.h"
#include "decals.h"
#include "physics_fx.h"
#include "vphysics_sound.h"
#include "vphysics/vehicles.h"
#include "vehicle_sounds.h"
#include "movevars_shared.h"
#include "physics_saverestore.h"
#include "solidsetdefaults.h"
#include "tier0/vprof.h"
#include "engine/IStaticPropMgr.h"
#include "physics_prop_ragdoll.h"
#if HL2_EPISODIC
#include "particle_parse.h"
#endif
#include "vphysics/object_hash.h"
#include "vphysics/collision_set.h"
#include "vphysics/friction.h"
#include "fmtstr.h"
#include "physics_npc_solver.h"
#include "physics_collisionevent.h"
#include "vphysics/performance.h"
#include "positionwatcher.h"
#include "tier1/callqueue.h"
#include "vphysics/constraints.h"
#ifdef PORTAL
#include "portal_physics_collisionevent.h"
#include "physicsshadowclone.h"
#include "PortalSimulation.h"
void PortalPhysFrame( float deltaTime ); //small wrapper for PhysFrame that simulates all 3 environments at once
#endif
void PrecachePhysicsSounds( void );
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
ConVar phys_speeds( "phys_speeds", "0" );
// defined in phys_constraint
extern IPhysicsConstraintEvent *g_pConstraintEvents;
CEntityList *g_pShadowEntities = NULL;
#ifdef PORTAL
CEntityList *g_pShadowEntities_Main = NULL;
#endif
// local variables
static float g_PhysAverageSimTime;
CCallQueue g_PostSimulationQueue;
// local routines
static IPhysicsObject *PhysCreateWorld( CBaseEntity *pWorld );
static void PhysFrame( float deltaTime );
static bool IsDebris( int collisionGroup );
void TimescaleChanged( IConVar *var, const char *pOldString, float flOldValue )
{
if ( physenv )
{
physenv->ResetSimulationClock();
}
}
ConVar phys_timescale( "phys_timescale", "1", 0, "Scale time for physics", TimescaleChanged );
#if _DEBUG
ConVar phys_dontprintint( "phys_dontprintint", "1", FCVAR_NONE, "Don't print inter-penetration warnings." );
#endif
#ifdef PORTAL
CPortal_CollisionEvent g_Collisions;
#else
CCollisionEvent g_Collisions;
#endif
IPhysicsCollisionSolver * const g_pCollisionSolver = &g_Collisions;
IPhysicsCollisionEvent * const g_pCollisionEventHandler = &g_Collisions;
IPhysicsObjectEvent * const g_pObjectEventHandler = &g_Collisions;
struct vehiclescript_t
{
string_t scriptName;
vehicleparams_t params;
vehiclesounds_t sounds;
};
class CPhysicsHook : public CBaseGameSystemPerFrame
{
public:
virtual const char *Name() { return "CPhysicsHook"; }
virtual bool Init();
virtual void LevelInitPreEntity();
virtual void LevelInitPostEntity();
virtual void LevelShutdownPreEntity();
virtual void LevelShutdownPostEntity();
virtual void FrameUpdatePostEntityThink();
virtual void PreClientUpdate();
bool FindOrAddVehicleScript( const char *pScriptName, vehicleparams_t *pVehicle, vehiclesounds_t *pSounds );
void FlushVehicleScripts()
{
m_vehicleScripts.RemoveAll();
}
bool ShouldSimulate()
{
return (physenv && !m_bPaused) ? true : false;
}
physicssound::soundlist_t m_impactSounds;
CUtlVector<physicssound::breaksound_t> m_breakSounds;
CUtlVector<masscenteroverride_t> m_massCenterOverrides;
CUtlVector<vehiclescript_t> m_vehicleScripts;
float m_impactSoundTime;
bool m_bPaused;
bool m_isFinalTick;
};
CPhysicsHook g_PhysicsHook;
//-----------------------------------------------------------------------------
// Singleton access
//-----------------------------------------------------------------------------
IGameSystem* PhysicsGameSystem()
{
return &g_PhysicsHook;
}
//-----------------------------------------------------------------------------
// Purpose: The physics hook callback implementations
//-----------------------------------------------------------------------------
bool CPhysicsHook::Init( void )
{
factorylist_t factories;
// Get the list of interface factories to extract the physics DLL's factory
FactoryList_Retrieve( factories );
if ( !factories.physicsFactory )
return false;
if ((physics = (IPhysics *)factories.physicsFactory( VPHYSICS_INTERFACE_VERSION, NULL )) == NULL ||
(physcollision = (IPhysicsCollision *)factories.physicsFactory( VPHYSICS_COLLISION_INTERFACE_VERSION, NULL )) == NULL ||
(physprops = (IPhysicsSurfaceProps *)factories.physicsFactory( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, NULL )) == NULL
)
return false;
PhysParseSurfaceData( physprops, filesystem );
m_isFinalTick = true;
m_impactSoundTime = 0;
m_vehicleScripts.EnsureCapacity(4);
return true;
}
// a little debug wrapper to help fix bugs when entity pointers get trashed
#if 0
struct physcheck_t
{
IPhysicsObject *pPhys;
char string[512];
};
CUtlVector< physcheck_t > physCheck;
void PhysCheckAdd( IPhysicsObject *pPhys, const char *pString )
{
physcheck_t tmp;
tmp.pPhys = pPhys;
Q_strncpy( tmp.string, pString ,sizeof(tmp.string));
physCheck.AddToTail( tmp );
}
const char *PhysCheck( IPhysicsObject *pPhys )
{
for ( int i = 0; i < physCheck.Size(); i++ )
{
if ( physCheck[i].pPhys == pPhys )
return physCheck[i].string;
}
return "unknown";
}
#endif
void CPhysicsHook::LevelInitPreEntity()
{
physenv = physics->CreateEnvironment();
physics_performanceparams_t params;
params.Defaults();
params.maxCollisionsPerObjectPerTimestep = 10;
physenv->SetPerformanceSettings( &params );
#ifdef PORTAL
physenv_main = physenv;
#endif
{
g_EntityCollisionHash = physics->CreateObjectPairHash();
}
factorylist_t factories;
FactoryList_Retrieve( factories );
physenv->SetDebugOverlay( factories.engineFactory );
physenv->EnableDeleteQueue( true );
physenv->SetCollisionSolver( &g_Collisions );
physenv->SetCollisionEventHandler( &g_Collisions );
physenv->SetConstraintEventHandler( g_pConstraintEvents );
physenv->EnableConstraintNotify( true ); // callback when an object gets deleted that is attached to a constraint
physenv->SetObjectEventHandler( &g_Collisions );
physenv->SetSimulationTimestep( DEFAULT_TICK_INTERVAL ); // 15 ms per tick
// HL Game gravity, not real-world gravity
physenv->SetGravity( Vector( 0, 0, -GetCurrentGravity() ) );
g_PhysAverageSimTime = 0;
g_PhysWorldObject = PhysCreateWorld( GetWorldEntity() );
g_pShadowEntities = new CEntityList;
#ifdef PORTAL
g_pShadowEntities_Main = g_pShadowEntities;
#endif
PrecachePhysicsSounds();
m_bPaused = true;
}
void CPhysicsHook::LevelInitPostEntity()
{
m_bPaused = false;
}
void CPhysicsHook::LevelShutdownPreEntity()
{
if ( !physenv )
return;
physenv->SetQuickDelete( true );
}
void CPhysicsHook::LevelShutdownPostEntity()
{
if ( !physenv )
return;
g_pPhysSaveRestoreManager->ForgetAllModels();
g_Collisions.LevelShutdown();
physics->DestroyEnvironment( physenv );
physenv = NULL;
physics->DestroyObjectPairHash( g_EntityCollisionHash );
g_EntityCollisionHash = NULL;
physics->DestroyAllCollisionSets();
g_PhysWorldObject = NULL;
delete g_pShadowEntities;
g_pShadowEntities = NULL;
m_impactSounds.RemoveAll();
m_breakSounds.RemoveAll();
m_massCenterOverrides.Purge();
FlushVehicleScripts();
}
bool CPhysicsHook::FindOrAddVehicleScript( const char *pScriptName, vehicleparams_t *pVehicle, vehiclesounds_t *pSounds )
{
bool bLoadedSounds = false;
int index = -1;
for ( int i = 0; i < m_vehicleScripts.Count(); i++ )
{
if ( !Q_stricmp(m_vehicleScripts[i].scriptName.ToCStr(), pScriptName) )
{
index = i;
bLoadedSounds = true;
break;
}
}
if ( index < 0 )
{
byte *pFile = UTIL_LoadFileForMe( pScriptName, NULL );
if ( pFile )
{
// new script, parse it and write to the table
index = m_vehicleScripts.AddToTail();
m_vehicleScripts[index].scriptName = AllocPooledString(pScriptName);
m_vehicleScripts[index].sounds.Init();
IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( (char *)pFile );
while ( !pParse->Finished() )
{
const char *pBlock = pParse->GetCurrentBlockName();
if ( !strcmpi( pBlock, "vehicle" ) )
{
pParse->ParseVehicle( &m_vehicleScripts[index].params, NULL );
}
else if ( !Q_stricmp( pBlock, "vehicle_sounds" ) )
{
bLoadedSounds = true;
CVehicleSoundsParser soundParser;
pParse->ParseCustom( &m_vehicleScripts[index].sounds, &soundParser );
}
else
{
pParse->SkipBlock();
}
}
physcollision->VPhysicsKeyParserDestroy( pParse );
UTIL_FreeFile( pFile );
}
}
if ( index >= 0 )
{
if ( pVehicle )
{
*pVehicle = m_vehicleScripts[index].params;
}
if ( pSounds )
{
// We must pass back valid data here!
if ( bLoadedSounds == false )
return false;
*pSounds = m_vehicleScripts[index].sounds;
}
return true;
}
return false;
}
// called after entities think
void CPhysicsHook::FrameUpdatePostEntityThink( )
{
VPROF_BUDGET( "CPhysicsHook::FrameUpdatePostEntityThink", VPROF_BUDGETGROUP_PHYSICS );
// Tracker 24846: If game is paused, don't simulate vphysics
float interval = ( gpGlobals->frametime > 0.0f ) ? TICK_INTERVAL : 0.0f;
// update the physics simulation, not we don't use gpGlobals->frametime, since that can be 30 msec or 15 msec
// depending on whether IsSimulatingOnAlternateTicks is true or not
if ( CBaseEntity::IsSimulatingOnAlternateTicks() )
{
m_isFinalTick = false;
#ifdef PORTAL //slight detour if we're the portal mod
PortalPhysFrame( interval );
#else
PhysFrame( interval );
#endif
}
m_isFinalTick = true;
#ifdef PORTAL //slight detour if we're the portal mod
PortalPhysFrame( interval );
#else
PhysFrame( interval );
#endif
}
void CPhysicsHook::PreClientUpdate()
{
m_impactSoundTime += gpGlobals->frametime;
if ( m_impactSoundTime > 0.05f )
{
physicssound::PlayImpactSounds( m_impactSounds );
m_impactSoundTime = 0.0f;
physicssound::PlayBreakSounds( m_breakSounds );
}
}
bool PhysIsFinalTick()
{
return g_PhysicsHook.m_isFinalTick;
}
IPhysicsObject *PhysCreateWorld( CBaseEntity *pWorld )
{
staticpropmgr->CreateVPhysicsRepresentations( physenv, &g_SolidSetup, pWorld );
return PhysCreateWorld_Shared( pWorld, modelinfo->GetVCollide(1), g_PhysDefaultObjectParams );
}
// vehicle wheels can only collide with things that can't get stuck in them during game physics
// because they aren't in the game physics world at present
static bool WheelCollidesWith( IPhysicsObject *pObj, CBaseEntity *pEntity )
{
#if defined( INVASION_DLL )
if ( pEntity->GetCollisionGroup() == TFCOLLISION_GROUP_OBJECT )
return false;
#endif
// Cull against interactive debris
if ( pEntity->GetCollisionGroup() == COLLISION_GROUP_INTERACTIVE_DEBRIS )
return false;
// Hit physics ents
if ( pEntity->GetMoveType() == MOVETYPE_PUSH || pEntity->GetMoveType() == MOVETYPE_VPHYSICS || pObj->IsStatic() )
return true;
return false;
}
CCollisionEvent::CCollisionEvent()
{
m_inCallback = 0;
m_bBufferTouchEvents = false;
m_lastTickFrictionError = 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 check(this);
CBaseEntity *pEntity0 = static_cast<CBaseEntity *>(pGameData0);
CBaseEntity *pEntity1 = static_cast<CBaseEntity *>(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;
}
// objects that are both constrained to the world don't collide with each other
if ( (gameFlags0 & gameFlags1) & FVPHYSICS_CONSTRAINT_STATIC )
{
return 0;
}
// Special collision rules for vehicle wheels
// Their entity collides with stuff using the normal rules, but they
// have different rules than the vehicle body for various reasons.
// sort of a hack because we don't have spheres to represent them in the game
// world for speculative collisions.
if ( pObj0->GetCallbackFlags() & CALLBACK_IS_VEHICLE_WHEEL )
{
if ( !WheelCollidesWith( pObj1, pEntity1 ) )
return false;
}
if ( pObj1->GetCallbackFlags() & CALLBACK_IS_VEHICLE_WHEEL )
{
if ( !WheelCollidesWith( pObj0, pEntity0 ) )
return false;
}
if ( pEntity0->ForceVPhysicsCollide( pEntity1 ) || pEntity1->ForceVPhysicsCollide( pEntity0 ) )
return 1;
if ( pEntity0->edict() && pEntity1->edict() )
{
// don't collide with your owner
if ( pEntity0->GetOwnerEntity() == pEntity1 || pEntity1->GetOwnerEntity() == pEntity0 )
return 0;
}
if ( pEntity0->GetMoveParent() || pEntity1->GetMoveParent() )
{
CBaseEntity *pParent0 = pEntity0->GetRootMoveParent();
CBaseEntity *pParent1 = pEntity1->GetRootMoveParent();
// NOTE: Don't let siblings/parents collide. If you want this behavior, do it
// with constraints, not hierarchy!
if ( pParent0 == pParent1 )
return 0;
if ( g_EntityCollisionHash->IsObjectPairInHash( pParent0, pParent1 ) )
return 0;
IPhysicsObject *p0 = pParent0->VPhysicsGetObject();
IPhysicsObject *p1 = pParent1->VPhysicsGetObject();
if ( p0 && p1 )
{
if ( g_EntityCollisionHash->IsObjectPairInHash( p0, p1 ) )
return 0;
}
}
int solid0 = pEntity0->GetSolid();
int solid1 = pEntity1->GetSolid();
int nSolidFlags0 = pEntity0->GetSolidFlags();
int nSolidFlags1 = pEntity1->GetSolidFlags();
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;
// BRJ 1/24/03
// You can remove the assert if it's problematic; I *believe* this condition
// should be met, but I'm not sure.
//Assert ( (solid0 != SOLID_NONE) && (solid1 != SOLID_NONE) );
if ( (solid0 == SOLID_NONE) || (solid1 == SOLID_NONE) )
return 0;
// not solid doesn't collide with anything
if ( (nSolidFlags0|nSolidFlags1) & FSOLID_NOT_SOLID )
{
// might be a vphysics trigger, collide with everything but "not solid"
if ( pObj0->IsTrigger() && !(nSolidFlags1 & FSOLID_NOT_SOLID) )
return 1;
if ( pObj1->IsTrigger() && !(nSolidFlags0 & FSOLID_NOT_SOLID) )
return 1;
return 0;
}
if ( (nSolidFlags0 & FSOLID_TRIGGER) &&
!(solid1 == SOLID_VPHYSICS || solid1 == SOLID_BSP || movetype1 == MOVETYPE_VPHYSICS) )
return 0;
if ( (nSolidFlags1 & FSOLID_TRIGGER) &&
!(solid0 == SOLID_VPHYSICS || solid0 == SOLID_BSP || movetype0 == MOVETYPE_VPHYSICS) )
return 0;
if ( !g_pGameRules->ShouldCollide( pEntity0->GetCollisionGroup(), pEntity1->GetCollisionGroup() ) )
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;
return 1;
}
bool FindMaxContact( IPhysicsObject *pObject, float minForce, IPhysicsObject **pOtherObject, Vector *contactPos, Vector *pForce )
{
float mass = pObject->GetMass();
float maxForce = minForce;
*pOtherObject = NULL;
IPhysicsFrictionSnapshot *pSnapshot = pObject->CreateFrictionSnapshot();
while ( pSnapshot->IsValid() )
{
IPhysicsObject *pOther = pSnapshot->GetObject(1);
if ( pOther->IsMoveable() && pOther->GetMass() > mass )
{
float force = pSnapshot->GetNormalForce();
if ( force > maxForce )
{
*pOtherObject = pOther;
pSnapshot->GetContactPoint( *contactPos );
pSnapshot->GetSurfaceNormal( *pForce );
*pForce *= force;
}
}
pSnapshot->NextFrictionData();
}
pObject->DestroyFrictionSnapshot( pSnapshot );
if ( *pOtherObject )
return true;
return false;
}
bool CCollisionEvent::ShouldFreezeObject( IPhysicsObject *pObject )
{
extern bool PropIsGib(CBaseEntity *pEntity);
// for now, don't apply a per-object limit to ai MOVETYPE_PUSH objects
// NOTE: If this becomes a problem (too many collision checks this tick) we should add a path
// to inform the logic in VPhysicsUpdatePusher() about the limit being applied so
// that it doesn't falsely block the object when it's simply been temporarily frozen
// for performance reasons
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pObject->GetGameData());
if ( pEntity )
{
if (pEntity->GetMoveType() == MOVETYPE_PUSH )
return false;
// don't limit vehicle collisions either, limit can make breaking through a pile of breakable
// props very hitchy
if (pEntity->GetServerVehicle() && !(pObject->GetCallbackFlags() & CALLBACK_IS_VEHICLE_WHEEL))
return false;
}
// if we're freezing a debris object, then it's probably due to some kind of solver issue
// usually this is a large object resting on the debris object in question which is not
// very stable.
// After doing the experiment of constraining the dynamic range of mass while solving friction
// contacts, I like the results of this tradeoff better. So damage or remove the debris object
// wherever possible once we hit this case:
if ( IsDebris( pEntity->GetCollisionGroup()) && !pEntity->IsNPC() )
{
IPhysicsObject *pOtherObject = NULL;
Vector contactPos;
Vector force;
// find the contact with the moveable object applying the most contact force
if ( FindMaxContact( pObject, pObject->GetMass() * 10, &pOtherObject, &contactPos, &force ) )
{
CBaseEntity *pOther = static_cast<CBaseEntity *>(pOtherObject->GetGameData());
// this object can take damage, crush it
if ( pEntity->m_takedamage > DAMAGE_EVENTS_ONLY )
{
CTakeDamageInfo dmgInfo( pOther, pOther, force, contactPos, force.Length() * 0.1f, DMG_CRUSH );
PhysCallbackDamage( pEntity, dmgInfo );
}
else
{
// can't be damaged, so do something else:
if ( PropIsGib(pEntity) )
{
// it's always safe to delete gibs, so kill this one to avoid simulation problems
PhysCallbackRemove( pEntity->NetworkProp() );
}
else
{
// not a gib, create a solver:
// UNDONE: Add a property to override this in gameplay critical scenarios?
g_PostSimulationQueue.QueueCall( EntityPhysics_CreateSolver, pOther, pEntity, true, 1.0f );
}
}
}
}
return true;
}
bool CCollisionEvent::ShouldFreezeContacts( IPhysicsObject **pObjectList, int objectCount )
{
if ( m_lastTickFrictionError > gpGlobals->tickcount || m_lastTickFrictionError < (gpGlobals->tickcount-1) )
{
DevWarning("Performance Warning: large friction system (%d objects)!!!\n", objectCount );
#if _DEBUG
for ( int i = 0; i < objectCount; i++ )
{
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pObjectList[i]->GetGameData());
pEntity->m_debugOverlays |= OVERLAY_ABSBOX_BIT | OVERLAY_PIVOT_BIT;
}
#endif
}
m_lastTickFrictionError = gpGlobals->tickcount;
return false;
}
// NOTE: these are fully edge triggered events
// called when an object wakes up (starts simulating)
void CCollisionEvent::ObjectWake( IPhysicsObject *pObject )
{
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pObject->GetGameData());
if ( pEntity && pEntity->HasDataObjectType( VPHYSICSWATCHER ) )
{
ReportVPhysicsStateChanged( pObject, pEntity, true );
}
}
// called when an object goes to sleep (no longer simulating)
void CCollisionEvent::ObjectSleep( IPhysicsObject *pObject )
{
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pObject->GetGameData());
if ( pEntity && pEntity->HasDataObjectType( VPHYSICSWATCHER ) )
{
ReportVPhysicsStateChanged( pObject, pEntity, false );
}
}
bool PhysShouldCollide( IPhysicsObject *pObj0, IPhysicsObject *pObj1 )
{
void *pGameData0 = pObj0->GetGameData();
void *pGameData1 = pObj1->GetGameData();
if ( !pGameData0 || !pGameData1 )
return false;
return g_Collisions.ShouldCollide( pObj0, pObj1, pGameData0, pGameData1 ) ? true : false;
}
bool PhysIsInCallback()
{
if ( (physenv && physenv->IsInSimulation()) || g_Collisions.IsInCallback() )
return true;
return false;
}
static void ReportPenetration( CBaseEntity *pEntity, float duration )
{
if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
{
if ( g_pDeveloper->GetInt() > 1 )
{
pEntity->m_debugOverlays |= OVERLAY_ABSBOX_BIT;
}
pEntity->AddTimedOverlay( UTIL_VarArgs("VPhysics Penetration Error (%s)!", pEntity->GetDebugName()), duration );
}
}
static bool IsDebris( int collisionGroup )
{
switch ( collisionGroup )
{
case COLLISION_GROUP_DEBRIS:
case COLLISION_GROUP_INTERACTIVE_DEBRIS:
case COLLISION_GROUP_DEBRIS_TRIGGER:
return true;
default:
break;
}
return false;
}
static void UpdateEntityPenetrationFlag( CBaseEntity *pEntity, bool isPenetrating )
{
if ( !pEntity )
return;
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int count = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
for ( int i = 0; i < count; i++ )
{
if ( !pList[i]->IsStatic() )
{
if ( isPenetrating )
{
PhysSetGameFlags( pList[i], FVPHYSICS_PENETRATING );
}
else
{
PhysClearGameFlags( pList[i], FVPHYSICS_PENETRATING );
}
}
}
}
void CCollisionEvent::GetListOfPenetratingEntities( CBaseEntity *pSearch, CUtlVector<CBaseEntity *> &list )
{
for ( int i = m_penetrateEvents.Count()-1; i >= 0; --i )
{
if ( m_penetrateEvents[i].hEntity0 == pSearch && m_penetrateEvents[i].hEntity1.Get() != NULL )
{
list.AddToTail( m_penetrateEvents[i].hEntity1 );
}
else if ( m_penetrateEvents[i].hEntity1 == pSearch && m_penetrateEvents[i].hEntity0.Get() != NULL )
{
list.AddToTail( m_penetrateEvents[i].hEntity0 );
}
}
}
void CCollisionEvent::UpdatePenetrateEvents( void )
{
for ( int i = m_penetrateEvents.Count()-1; i >= 0; --i )
{
CBaseEntity *pEntity0 = m_penetrateEvents[i].hEntity0;
CBaseEntity *pEntity1 = m_penetrateEvents[i].hEntity1;
if ( m_penetrateEvents[i].collisionState == COLLSTATE_TRYDISABLE )
{
if ( pEntity0 && pEntity1 )
{
IPhysicsObject *pObj0 = pEntity0->VPhysicsGetObject();
if ( pObj0 )
{
PhysForceEntityToSleep( pEntity0, pObj0 );
}
IPhysicsObject *pObj1 = pEntity1->VPhysicsGetObject();
if ( pObj1 )
{
PhysForceEntityToSleep( pEntity1, pObj1 );
}
m_penetrateEvents[i].collisionState = COLLSTATE_DISABLED;
continue;
}
// missing entity or object, clear event
}
else if ( m_penetrateEvents[i].collisionState == COLLSTATE_TRYNPCSOLVER )
{
if ( pEntity0 && pEntity1 )
{
CAI_BaseNPC *pNPC = pEntity0->MyNPCPointer();
CBaseEntity *pBlocker = pEntity1;
if ( !pNPC )
{
pNPC = pEntity1->MyNPCPointer();
Assert(pNPC);
pBlocker = pEntity0;
}
NPCPhysics_CreateSolver( pNPC, pBlocker, true, 1.0f );
}
// transferred to solver, clear event
}
else if ( m_penetrateEvents[i].collisionState == COLLSTATE_TRYENTITYSOLVER )
{
if ( pEntity0 && pEntity1 )
{
if ( !IsDebris(pEntity1->GetCollisionGroup()) || pEntity1->GetMoveType() != MOVETYPE_VPHYSICS )
{
CBaseEntity *pTmp = pEntity0;
pEntity0 = pEntity1;
pEntity1 = pTmp;
}
EntityPhysics_CreateSolver( pEntity0, pEntity1, true, 1.0f );
}
// transferred to solver, clear event
}
else if ( gpGlobals->curtime - m_penetrateEvents[i].timeStamp > 1.0 )
{
if ( m_penetrateEvents[i].collisionState == COLLSTATE_DISABLED )
{
if ( pEntity0 && pEntity1 )
{
IPhysicsObject *pObj0 = pEntity0->VPhysicsGetObject();
IPhysicsObject *pObj1 = pEntity1->VPhysicsGetObject();
if ( pObj0 && pObj1 )
{
m_penetrateEvents[i].collisionState = COLLSTATE_ENABLED;
continue;
}
}
}
// haven't penetrated for 1 second, so remove
}
else
{
// recent timestamp, don't remove the event yet
continue;
}
// done, clear event
m_penetrateEvents.FastRemove(i);
UpdateEntityPenetrationFlag( pEntity0, false );
UpdateEntityPenetrationFlag( pEntity1, false );
}
}
penetrateevent_t &CCollisionEvent::FindOrAddPenetrateEvent( CBaseEntity *pEntity0, CBaseEntity *pEntity1 )
{
int index = -1;
for ( int i = m_penetrateEvents.Count()-1; i >= 0; --i )
{
if ( m_penetrateEvents[i].hEntity0.Get() == pEntity0 && m_penetrateEvents[i].hEntity1.Get() == pEntity1 )
{
index = i;
break;
}
}
if ( index < 0 )
{
index = m_penetrateEvents.AddToTail();
penetrateevent_t &event = m_penetrateEvents[index];
event.hEntity0 = pEntity0;
event.hEntity1 = pEntity1;
event.startTime = gpGlobals->curtime;
event.collisionState = COLLSTATE_ENABLED;
UpdateEntityPenetrationFlag( pEntity0, true );
UpdateEntityPenetrationFlag( pEntity1, true );
}
penetrateevent_t &event = m_penetrateEvents[index];
event.timeStamp = gpGlobals->curtime;
return event;
}
static ConVar phys_penetration_error_time( "phys_penetration_error_time", "10", 0, "Controls the duration of vphysics penetration error boxes." );
static bool CanResolvePenetrationWithNPC( CBaseEntity *pEntity, IPhysicsObject *pObject )
{
if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS )
{
// hinged objects won't be able to be pushed out anyway, so don't try the npc solver
if ( !pObject->IsHinged() && !pObject->IsAttachedToConstraint(true) )
{
if ( pObject->IsMoveable() || pEntity->GetServerVehicle() )
return true;
}
}
return false;
}
int CCollisionEvent::ShouldSolvePenetration( IPhysicsObject *pObj0, IPhysicsObject *pObj1, void *pGameData0, void *pGameData1, float dt )
{
CallbackContext check(this);
// Pointers to the entity for each physics object
CBaseEntity *pEntity0 = static_cast<CBaseEntity *>(pGameData0);
CBaseEntity *pEntity1 = static_cast<CBaseEntity *>(pGameData1);
// this can get called as entities are being constructed on the other side of a game load or level transition
// Some entities may not be fully constructed, so don't call into their code until the level is running
if ( g_PhysicsHook.m_bPaused )
return true;
// solve it yourself here and return 0, or have the default implementation do it
if ( pEntity0 > pEntity1 )
{
// swap sort
CBaseEntity *pTmp = pEntity0;
pEntity0 = pEntity1;
pEntity1 = pTmp;
IPhysicsObject *pTmpObj = pObj0;
pObj0 = pObj1;
pObj1 = pTmpObj;
}
if ( pEntity0 == pEntity1 )
{
if ( pObj0->GetGameFlags() & FVPHYSICS_PART_OF_RAGDOLL )
{
DevMsg(2, "Solving ragdoll self penetration! %s (%s) (%d v %d)\n", pObj0->GetName(), pEntity0->GetDebugName(), pObj0->GetGameIndex(), pObj1->GetGameIndex() );
ragdoll_t *pRagdoll = Ragdoll_GetRagdoll( pEntity0 );
pRagdoll->pGroup->SolvePenetration( pObj0, pObj1 );
return false;
}
}
penetrateevent_t &event = FindOrAddPenetrateEvent( pEntity0, pEntity1 );
float eventTime = gpGlobals->curtime - event.startTime;
// NPC vs. physics object. Create a game DLL solver and remove this event
if ( (pEntity0->MyNPCPointer() && CanResolvePenetrationWithNPC(pEntity1, pObj1)) ||
(pEntity1->MyNPCPointer() && CanResolvePenetrationWithNPC(pEntity0, pObj0)) )
{
event.collisionState = COLLSTATE_TRYNPCSOLVER;
}
if ( (IsDebris( pEntity0->GetCollisionGroup() ) && !pObj1->IsStatic()) || (IsDebris( pEntity1->GetCollisionGroup() ) && !pObj0->IsStatic()) )
{
if ( eventTime > 0.5f )
{
//Msg("Debris stuck in non-static!\n");
event.collisionState = COLLSTATE_TRYENTITYSOLVER;
}
}
#if _DEBUG
if ( phys_dontprintint.GetBool() == false )
{
const char *pName1 = STRING(pEntity0->GetModelName());
const char *pName2 = STRING(pEntity1->GetModelName());
if ( pEntity0 == pEntity1 )
{
int index0 = physcollision->CollideIndex( pObj0->GetCollide() );
int index1 = physcollision->CollideIndex( pObj1->GetCollide() );
DevMsg(1, "***Inter-penetration on %s (%d & %d) (%.0f, %.0f)\n", pName1?pName1:"(null)", index0, index1, gpGlobals->curtime, eventTime );
}
else
{
DevMsg(1, "***Inter-penetration between %s(%s) AND %s(%s) (%.0f, %.0f)\n", pName1?pName1:"(null)", pEntity0->GetDebugName(), pName2?pName2:"(null)", pEntity1->GetDebugName(), gpGlobals->curtime, eventTime );
}
}
#endif
if ( eventTime > 3 )
{
// don't report penetrations on ragdolls with themselves, or outside of developer mode
if ( g_pDeveloper->GetInt() && pEntity0 != pEntity1 )
{
ReportPenetration( pEntity0, phys_penetration_error_time.GetFloat() );
ReportPenetration( pEntity1, phys_penetration_error_time.GetFloat() );
}
event.startTime = gpGlobals->curtime;
// don't put players or game physics controlled objects to sleep
if ( !pEntity0->IsPlayer() && !pEntity1->IsPlayer() && !pObj0->GetShadowController() && !pObj1->GetShadowController() )
{
// two objects have been stuck for more than 3 seconds, try disabling simulation
event.collisionState = COLLSTATE_TRYDISABLE;
return false;
}
}
return true;
}
void CCollisionEvent::FluidStartTouch( IPhysicsObject *pObject, IPhysicsFluidController *pFluid )
{
CallbackContext check(this);
if ( ( pObject == NULL ) || ( pFluid == NULL ) )
return;
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pObject->GetGameData());
if ( !pEntity )
return;
pEntity->AddEFlags( EFL_TOUCHING_FLUID );
pEntity->OnEntityEvent( ENTITY_EVENT_WATER_TOUCH, (void*)pFluid->GetContents() );
float timeSinceLastCollision = DeltaTimeSinceLastFluid( pEntity );
if ( timeSinceLastCollision < 0.5f )
return;
// UNDONE: Use this for splash logic instead?
// UNDONE: Use angular term too - push splashes in rotAxs cross normal direction?
Vector normal;
float dist;
pFluid->GetSurfacePlane( &normal, &dist );
Vector vel;
AngularImpulse angVel;
pObject->GetVelocity( &vel, &angVel );
Vector unitVel = vel;
VectorNormalize( unitVel );
// normal points out of the surface, we want the direction that points in
float dragScale = pFluid->GetDensity() * physenv->GetSimulationTimestep();
normal = -normal;
float linearScale = 0.5f * DotProduct( unitVel, normal ) * pObject->CalculateLinearDrag( normal ) * dragScale;
linearScale = clamp( linearScale, 0.0f, 1.0f );
vel *= -linearScale;
// UNDONE: Figure out how much of the surface area has crossed the water surface and scale angScale by that
// For now assume 25%
Vector rotAxis = angVel;
VectorNormalize(rotAxis);
float angScale = 0.25f * pObject->CalculateAngularDrag( angVel ) * dragScale;
angScale = clamp( angScale, 0.0f, 1.0f );
angVel *= -angScale;
// compute the splash before we modify the velocity
PhysicsSplash( pFluid, pObject, pEntity );
// now damp out some motion toward the surface
pObject->AddVelocity( &vel, &angVel );
}
void CCollisionEvent::FluidEndTouch( IPhysicsObject *pObject, IPhysicsFluidController *pFluid )
{
CallbackContext check(this);
if ( ( pObject == NULL ) || ( pFluid == NULL ) )
return;
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pObject->GetGameData());
if ( !pEntity )
return;
float timeSinceLastCollision = DeltaTimeSinceLastFluid( pEntity );
if ( timeSinceLastCollision >= 0.5f )
{
PhysicsSplash( pFluid, pObject, pEntity );
}
pEntity->RemoveEFlags( EFL_TOUCHING_FLUID );
pEntity->OnEntityEvent( ENTITY_EVENT_WATER_UNTOUCH, (void*)pFluid->GetContents() );
}
class CSkipKeys : public IVPhysicsKeyHandler
{
public:
virtual void ParseKeyValue( void *pData, const char *pKey, const char *pValue ) {}
virtual void SetDefaults( void *pData ) {}
};
void PhysSolidOverride( solid_t &solid, string_t overrideScript )
{
if ( overrideScript != NULL_STRING)
{
// parser destroys this data
bool collisions = solid.params.enableCollisions;
char pTmpString[4096];
// write a header for a solid_t
Q_strncpy( pTmpString, "solid { ", sizeof(pTmpString) );
// suck out the comma delimited tokens and turn them into quoted key/values
char szToken[256];
const char *pStr = nexttoken(szToken, STRING(overrideScript), ',');
while ( szToken[0] != 0 )
{
Q_strncat( pTmpString, "\"", sizeof(pTmpString), COPY_ALL_CHARACTERS );
Q_strncat( pTmpString, szToken, sizeof(pTmpString), COPY_ALL_CHARACTERS );
Q_strncat( pTmpString, "\" ", sizeof(pTmpString), COPY_ALL_CHARACTERS );
pStr = nexttoken(szToken, pStr, ',');
}
// terminate the script
Q_strncat( pTmpString, "}", sizeof(pTmpString), COPY_ALL_CHARACTERS );
// parse that sucker
IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( pTmpString );
CSkipKeys tmp;
pParse->ParseSolid( &solid, &tmp );
physcollision->VPhysicsKeyParserDestroy( pParse );
// parser destroys this data
solid.params.enableCollisions = collisions;
}
}
void PhysSetMassCenterOverride( masscenteroverride_t &override )
{
if ( override.entityName != NULL_STRING )
{
g_PhysicsHook.m_massCenterOverrides.AddToTail( override );
}
}
// NOTE: This will remove the entry from the list as well
int PhysGetMassCenterOverrideIndex( string_t name )
{
if ( name != NULL_STRING && g_PhysicsHook.m_massCenterOverrides.Count() )
{
for ( int i = 0; i < g_PhysicsHook.m_massCenterOverrides.Count(); i++ )
{
if ( g_PhysicsHook.m_massCenterOverrides[i].entityName == name )
{
return i;
}
}
}
return -1;
}
void PhysGetMassCenterOverride( CBaseEntity *pEntity, vcollide_t *pCollide, solid_t &solidOut )
{
int index = PhysGetMassCenterOverrideIndex( pEntity->GetEntityName() );
if ( index >= 0 )
{
masscenteroverride_t &override = g_PhysicsHook.m_massCenterOverrides[index];
Vector massCenterWS = override.center;
switch ( override.alignType )
{
case masscenteroverride_t::ALIGN_POINT:
VectorITransform( massCenterWS, pEntity->EntityToWorldTransform(), solidOut.massCenterOverride );
break;
case masscenteroverride_t::ALIGN_AXIS:
{
Vector massCenterLocal, defaultMassCenterWS;
physcollision->CollideGetMassCenter( pCollide->solids[solidOut.index], &massCenterLocal );
VectorTransform( massCenterLocal, pEntity->EntityToWorldTransform(), defaultMassCenterWS );
massCenterWS += override.axis *
( DotProduct(defaultMassCenterWS,override.axis) - DotProduct( override.axis, override.center ) );
VectorITransform( massCenterWS, pEntity->EntityToWorldTransform(), solidOut.massCenterOverride );
}
break;
}
g_PhysicsHook.m_massCenterOverrides.FastRemove( index );
if ( solidOut.massCenterOverride.Length() > DIST_EPSILON )
{
solidOut.params.massCenterOverride = &solidOut.massCenterOverride;
}
}
}
float PhysGetEntityMass( CBaseEntity *pEntity )
{
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int physCount = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
float otherMass = 0;
for ( int i = 0; i < physCount; i++ )
{
otherMass += pList[i]->GetMass();
}
return otherMass;
}
typedef void (*EntityCallbackFunction) ( CBaseEntity *pEntity );
void IterateActivePhysicsEntities( EntityCallbackFunction func )
{
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++ )
{
CBaseEntity *pEntity = reinterpret_cast<CBaseEntity *>(pActiveList[i]->GetGameData());
if ( pEntity )
{
func( pEntity );
}
}
}
}
static void CallbackHighlight( CBaseEntity *pEntity )
{
pEntity->m_debugOverlays |= OVERLAY_ABSBOX_BIT | OVERLAY_PIVOT_BIT;
}
static void CallbackReport( CBaseEntity *pEntity )
{
const char *pName = STRING(pEntity->GetEntityName());
if ( !Q_strlen(pName) )
{
pName = STRING(pEntity->GetModelName());
}
Msg( "%s - %s\n", pEntity->GetClassname(), pName );
}
CON_COMMAND(physics_highlight_active, "Turns on the absbox for all active physics objects")
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
IterateActivePhysicsEntities( CallbackHighlight );
}
CON_COMMAND(physics_report_active, "Lists all active physics objects")
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
IterateActivePhysicsEntities( CallbackReport );
}
CON_COMMAND_F(surfaceprop, "Reports the surface properties at the cursor", FCVAR_CHEAT )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
CBasePlayer *pPlayer = UTIL_GetCommandClient();
trace_t tr;
Vector forward;
pPlayer->EyeVectors( &forward );
UTIL_TraceLine(pPlayer->EyePosition(), pPlayer->EyePosition() + forward * MAX_COORD_RANGE,
MASK_SHOT_HULL|CONTENTS_GRATE|CONTENTS_DEBRIS, pPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.DidHit() )
{
const model_t *pModel = modelinfo->GetModel( tr.m_pEnt->GetModelIndex() );
const char *pModelName = STRING(tr.m_pEnt->GetModelName());
if ( tr.DidHitWorld() && tr.hitbox > 0 )
{
ICollideable *pCollide = staticpropmgr->GetStaticPropByIndex( tr.hitbox-1 );
pModel = pCollide->GetCollisionModel();
pModelName = modelinfo->GetModelName( pModel );
}
CFmtStr modelStuff;
if ( pModel )
{
modelStuff.sprintf("%s.%s ", modelinfo->IsTranslucent( pModel ) ? "Translucent" : "Opaque",
modelinfo->IsTranslucentTwoPass( pModel ) ? " Two-pass." : "" );
}
// Calculate distance to surface that was hit
Vector vecVelocity = tr.startpos - tr.endpos;
int length = vecVelocity.Length();
Msg("Hit surface \"%s\" (entity %s, model \"%s\" %s), texture \"%s\"\n", physprops->GetPropName( tr.surface.surfaceProps ), tr.m_pEnt->GetClassname(), pModelName, modelStuff.Access(), tr.surface.name);
Msg("Distance to surface: %d\n", length );
}
}
static void OutputVPhysicsDebugInfo( CBaseEntity *pEntity )
{
if ( pEntity )
{
Msg("Entity %s (%s) %s Collision Group %d\n", pEntity->GetClassname(), pEntity->GetDebugName(), pEntity->IsNavIgnored() ? "NAV IGNORE" : "", pEntity->GetCollisionGroup() );
CUtlVector<CBaseEntity *> list;
g_Collisions.GetListOfPenetratingEntities( pEntity, list );
for ( int i = 0; i < list.Count(); i++ )
{
Msg(" penetration with entity %s (%s)\n", list[i]->GetDebugName(), STRING(list[i]->GetModelName()) );
}
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int physCount = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
if ( physCount )
{
if ( physCount > 1 )
{
for ( int i = 0; i < physCount; i++ )
{
Msg("Object %d (of %d) =========================\n", i+1, physCount );
pList[i]->OutputDebugInfo();
}
}
else
{
pList[0]->OutputDebugInfo();
}
}
}
}
class CConstraintFloodEntry
{
public:
CConstraintFloodEntry() : isMarked(false), isConstraint(false) {}
CUtlVector<CBaseEntity *> linkList;
bool isMarked;
bool isConstraint;
};
class CConstraintFloodList
{
public:
CConstraintFloodList()
{
SetDefLessFunc( m_list );
m_list.EnsureCapacity(64);
m_entryList.EnsureCapacity(64);
}
bool IsWorldEntity( CBaseEntity *pEnt )
{
if ( pEnt->edict() )
return pEnt->IsWorld();
return false;
}
void AddLink( CBaseEntity *pEntity, CBaseEntity *pLink, bool bIsConstraint )
{
if ( !pEntity || !pLink || IsWorldEntity(pEntity) || IsWorldEntity(pLink) )
return;
int listIndex = m_list.Find(pEntity);
if ( listIndex == m_list.InvalidIndex() )
{
int entryIndex = m_entryList.AddToTail();
m_entryList[entryIndex].isConstraint = bIsConstraint;
listIndex = m_list.Insert( pEntity, entryIndex );
}
int entryIndex = m_list.Element(listIndex);
CConstraintFloodEntry &entry = m_entryList.Element(entryIndex);
Assert( entry.isConstraint == bIsConstraint );
if ( entry.linkList.Find(pLink) < 0 )
{
entry.linkList.AddToTail( pLink );
}
}
void BuildGraphFromEntity( CBaseEntity *pEntity, CUtlVector<CBaseEntity *> &constraintList )
{
int listIndex = m_list.Find(pEntity);
if ( listIndex != m_list.InvalidIndex() )
{
int entryIndex = m_list.Element(listIndex);
CConstraintFloodEntry &entry = m_entryList.Element(entryIndex);
if ( !entry.isMarked )
{
if ( entry.isConstraint )
{
Assert( constraintList.Find(pEntity) < 0);
constraintList.AddToTail( pEntity );
}
entry.isMarked = true;
for ( int i = 0; i < entry.linkList.Count(); i++ )
{
// now recursively traverse the graph from here
BuildGraphFromEntity( entry.linkList[i], constraintList );
}
}
}
}
CUtlMap<CBaseEntity *, int> m_list;
CUtlVector<CConstraintFloodEntry> m_entryList;
};
// traverses the graph of attachments (currently supports springs & constraints) starting at an entity
// Then turns on debug info for each link in the graph (springs/constraints are links)
static void DebugConstraints( CBaseEntity *pEntity )
{
extern bool GetSpringAttachments( CBaseEntity *pEntity, CBaseEntity *pAttach[2], IPhysicsObject *pAttachVPhysics[2] );
extern bool GetConstraintAttachments( CBaseEntity *pEntity, CBaseEntity *pAttach[2], IPhysicsObject *pAttachVPhysics[2] );
extern void DebugConstraint(CBaseEntity *pEntity);
if ( !pEntity )
return;
CBaseEntity *pAttach[2];
IPhysicsObject *pAttachVPhysics[2];
CConstraintFloodList list;
for ( CBaseEntity *pList = gEntList.FirstEnt(); pList != NULL; pList = gEntList.NextEnt(pList) )
{
if ( GetConstraintAttachments(pList, pAttach, pAttachVPhysics) || GetSpringAttachments(pList, pAttach, pAttachVPhysics) )
{
list.AddLink( pList, pAttach[0], true );
list.AddLink( pList, pAttach[1], true );
list.AddLink( pAttach[0], pList, false );
list.AddLink( pAttach[1], pList, false );
}
}
CUtlVector<CBaseEntity *> constraints;
list.BuildGraphFromEntity( pEntity, constraints );
for ( int i = 0; i < constraints.Count(); i++ )
{
if ( !GetConstraintAttachments(constraints[i], pAttach, pAttachVPhysics) )
{
GetSpringAttachments(constraints[i], pAttach, pAttachVPhysics);
}
const char *pName0 = "world";
const char *pName1 = "world";
const char *pModel0 = "";
const char *pModel1 = "";
int index0 = 0;
int index1 = 0;
if ( pAttach[0] )
{
pName0 = pAttach[0]->GetClassname();
pModel0 = STRING(pAttach[0]->GetModelName());
index0 = pAttachVPhysics[0]->GetGameIndex();
}
if ( pAttach[1] )
{
pName1 = pAttach[1]->GetClassname();
pModel1 = STRING(pAttach[1]->GetModelName());
index1 = pAttachVPhysics[1]->GetGameIndex();
}
Msg("**********************\n%s connects %s(%s:%d) to %s(%s:%d)\n", constraints[i]->GetClassname(), pName0, pModel0, index0, pName1, pModel1, index1 );
DebugConstraint(constraints[i]);
constraints[i]->m_debugOverlays |= OVERLAY_BBOX_BIT | OVERLAY_TEXT_BIT;
}
}
static void MarkVPhysicsDebug( CBaseEntity *pEntity )
{
if ( pEntity )
{
IPhysicsObject *pPhysics = pEntity->VPhysicsGetObject();
if ( pPhysics )
{
unsigned short callbacks = pPhysics->GetCallbackFlags();
callbacks ^= CALLBACK_MARKED_FOR_TEST;
pPhysics->SetCallbackFlags( callbacks );
}
}
}
void PhysicsCommand( const CCommand &args, void (*func)( CBaseEntity *pEntity ) )
{
if ( args.ArgC() < 2 )
{
CBasePlayer *pPlayer = UTIL_GetCommandClient();
trace_t tr;
Vector forward;
pPlayer->EyeVectors( &forward );
UTIL_TraceLine(pPlayer->EyePosition(), pPlayer->EyePosition() + forward * MAX_COORD_RANGE,
MASK_SHOT_HULL|CONTENTS_GRATE|CONTENTS_DEBRIS, pPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.DidHit() )
{
func( tr.m_pEnt );
}
}
else
{
CBaseEntity *pEnt = NULL;
while ( ( pEnt = gEntList.FindEntityGeneric( pEnt, args[1] ) ) != NULL )
{
func( pEnt );
}
}
}
CON_COMMAND(physics_constraints, "Highlights constraint system graph for an entity")
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
PhysicsCommand( args, DebugConstraints );
}
CON_COMMAND(physics_debug_entity, "Dumps debug info for an entity")
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
PhysicsCommand( args, OutputVPhysicsDebugInfo );
}
CON_COMMAND(physics_select, "Dumps debug info for an entity")
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
PhysicsCommand( args, MarkVPhysicsDebug );
}
CON_COMMAND( physics_budget, "Times the cost of each active object" )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
int activeCount = physenv->GetActiveObjectCount();
IPhysicsObject **pActiveList = NULL;
CUtlVector<CBaseEntity *> ents;
if ( activeCount )
{
int i;
pActiveList = (IPhysicsObject **)stackalloc( sizeof(IPhysicsObject *)*activeCount );
physenv->GetActiveObjects( pActiveList );
for ( i = 0; i < activeCount; i++ )
{
CBaseEntity *pEntity = reinterpret_cast<CBaseEntity *>(pActiveList[i]->GetGameData());
if ( pEntity )
{
int index = -1;
for ( int j = 0; j < ents.Count(); j++ )
{
if ( pEntity == ents[j] )
{
index = j;
break;
}
}
if ( index >= 0 )
continue;
ents.AddToTail( pEntity );
}
}
stackfree( pActiveList );
if ( !ents.Count() )
return;
CUtlVector<float> times;
float totalTime = 0.f;
g_Collisions.BufferTouchEvents( true );
float full = engine->Time();
physenv->Simulate( DEFAULT_TICK_INTERVAL );
full = engine->Time() - full;
float lastTime = full;
times.SetSize( ents.Count() );
// NOTE: This is just a heuristic. Attempt to estimate cost by putting each object to sleep in turn.
// note that simulation may wake the objects again and some costs scale with sets of objects/constraints/etc
// so these are only generally useful for broad questions, not real metrics!
for ( i = 0; i < ents.Count(); i++ )
{
for ( int j = 0; j < i; j++ )
{
PhysForceEntityToSleep( ents[j], ents[j]->VPhysicsGetObject() );
}
float start = engine->Time();
physenv->Simulate( DEFAULT_TICK_INTERVAL );
float end = engine->Time();
float elapsed = end - start;
float avgTime = lastTime - elapsed;
times[i] = clamp( avgTime, 0.00001f, 1.0f );
totalTime += times[i];
lastTime = elapsed;
}
totalTime = MAX( totalTime, 0.001 );
for ( i = 0; i < ents.Count(); i++ )
{
float fraction = times[i] / totalTime;
Msg( "%s (%s): %.3fms (%.3f%%) @ %s\n", ents[i]->GetClassname(), ents[i]->GetDebugName(), fraction * totalTime * 1000.0f, fraction * 100.0f, VecToString(ents[i]->GetAbsOrigin()) );
}
g_Collisions.BufferTouchEvents( false );
}
}
#ifdef PORTAL
ConVar sv_fullsyncclones("sv_fullsyncclones", "1", FCVAR_CHEAT );
void PortalPhysFrame( float deltaTime ) //small wrapper for PhysFrame that simulates all environments at once
{
CPortalSimulator::PrePhysFrame();
if( sv_fullsyncclones.GetBool() )
CPhysicsShadowClone::FullSyncAllClones();
g_Collisions.BufferTouchEvents( true );
PhysFrame( deltaTime );
g_Collisions.PortalPostSimulationFrame();
g_Collisions.BufferTouchEvents( false );
g_Collisions.FrameUpdate();
CPortalSimulator::PostPhysFrame();
}
#endif
// Advance physics by time (in seconds)
void PhysFrame( float deltaTime )
{
static int lastObjectCount = 0;
entitem_t *pItem;
if ( !g_PhysicsHook.ShouldSimulate() )
return;
// Trap interrupts and clock changes
if ( deltaTime > 1.0f || deltaTime < 0.0f )
{
deltaTime = 0;
Msg( "Reset physics clock\n" );
}
else if ( deltaTime > 0.1f ) // limit incoming time to 100ms
{
deltaTime = 0.1f;
}
float simRealTime = 0;
deltaTime *= phys_timescale.GetFloat();
// !!!HACKHACK -- hard limit scaled time to avoid spending too much time in here
// Limit to 100 ms
if ( deltaTime > 0.100f )
deltaTime = 0.100f;
bool bProfile = phys_speeds.GetBool();
if ( bProfile )
{
simRealTime = engine->Time();
}
#ifdef _DEBUG
physenv->DebugCheckContacts();
#endif
#ifndef PORTAL //instead of wrapping 1 simulation with this, portal needs to wrap 3
g_Collisions.BufferTouchEvents( true );
#endif
physenv->Simulate( deltaTime );
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++ )
{
CBaseEntity *pEntity = reinterpret_cast<CBaseEntity *>(pActiveList[i]->GetGameData());
if ( pEntity )
{
if ( pEntity->CollisionProp()->DoesVPhysicsInvalidateSurroundingBox() )
{
pEntity->CollisionProp()->MarkSurroundingBoundsDirty();
}
pEntity->VPhysicsUpdate( pActiveList[i] );
}
}
stackfree( pActiveList );
}
for ( pItem = g_pShadowEntities->m_pItemList; pItem; pItem = pItem->pNext )
{
CBaseEntity *pEntity = pItem->hEnt.Get();
if ( !pEntity )
{
Msg( "Dangling pointer to physics entity!!!\n" );
continue;
}
IPhysicsObject *pPhysics = pEntity->VPhysicsGetObject();
// apply updates
if ( pPhysics && !pPhysics->IsAsleep() )
{
pEntity->VPhysicsShadowUpdate( pPhysics );
}
}
if ( bProfile )
{
simRealTime = engine->Time() - simRealTime;
if ( simRealTime < 0 )
simRealTime = 0;
g_PhysAverageSimTime *= 0.8;
g_PhysAverageSimTime += (simRealTime * 0.2);
if ( lastObjectCount != 0 || activeCount != 0 )
{
Msg( "Physics: %3d objects, %4.1fms / AVG: %4.1fms\n", activeCount, simRealTime * 1000, g_PhysAverageSimTime * 1000 );
}
lastObjectCount = activeCount;
}
#ifndef PORTAL //instead of wrapping 1 simulation with this, portal needs to wrap 3
g_Collisions.BufferTouchEvents( false );
g_Collisions.FrameUpdate();
#endif
}
void PhysAddShadow( CBaseEntity *pEntity )
{
g_pShadowEntities->AddEntity( pEntity );
}
void PhysRemoveShadow( CBaseEntity *pEntity )
{
g_pShadowEntities->DeleteEntity( pEntity );
}
bool PhysHasShadow( CBaseEntity *pEntity )
{
EHANDLE hTestEnt = pEntity;
entitem_t *pCurrent = g_pShadowEntities->m_pItemList;
while( pCurrent )
{
if( pCurrent->hEnt == hTestEnt )
{
return true;
}
pCurrent = pCurrent->pNext;
}
return false;
}
void PhysEnableFloating( IPhysicsObject *pObject, bool bEnable )
{
if ( pObject != NULL )
{
unsigned short flags = pObject->GetCallbackFlags();
if ( bEnable )
{
flags |= CALLBACK_DO_FLUID_SIMULATION;
}
else
{
flags &= ~CALLBACK_DO_FLUID_SIMULATION;
}
pObject->SetCallbackFlags( flags );
}
}
//-----------------------------------------------------------------------------
// CollisionEvent system
//-----------------------------------------------------------------------------
// NOTE: PreCollision/PostCollision ALWAYS come in matched pairs!!!
void CCollisionEvent::PreCollision( vcollisionevent_t *pEvent )
{
CallbackContext check(this);
m_gameEvent.Init( pEvent );
// gather the pre-collision data that the game needs to track
for ( int i = 0; i < 2; i++ )
{
IPhysicsObject *pObject = pEvent->pObjects[i];
if ( pObject )
{
if ( pObject->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
{
CBaseEntity *pOtherEntity = reinterpret_cast<CBaseEntity *>(pEvent->pObjects[!i]->GetGameData());
if ( pOtherEntity && !pOtherEntity->IsPlayer() )
{
Vector velocity;
AngularImpulse angVel;
// HACKHACK: If we totally clear this out, then Havok will think the objects
// are penetrating and generate forces to separate them
// so make it fairly small and have a tiny collision instead.
pObject->GetVelocity( &velocity, &angVel );
float len = VectorNormalize(velocity);
len = MAX( len, 10 );
velocity *= len;
len = VectorNormalize(angVel);
len = MAX( len, 1 );
angVel *= len;
pObject->SetVelocity( &velocity, &angVel );
}
}
pObject->GetVelocity( &m_gameEvent.preVelocity[i], &m_gameEvent.preAngularVelocity[i] );
}
}
}
void CCollisionEvent::PostCollision( vcollisionevent_t *pEvent )
{
CallbackContext check(this);
bool isShadow[2] = {false,false};
int i;
for ( i = 0; i < 2; i++ )
{
IPhysicsObject *pObject = pEvent->pObjects[i];
if ( pObject )
{
CBaseEntity *pEntity = reinterpret_cast<CBaseEntity *>(pObject->GetGameData());
if ( !pEntity )
return;
// UNDONE: This is here to trap crashes due to NULLing out the game data on delete
m_gameEvent.pEntities[i] = pEntity;
unsigned int flags = pObject->GetCallbackFlags();
pObject->GetVelocity( &m_gameEvent.postVelocity[i], NULL );
if ( flags & CALLBACK_SHADOW_COLLISION )
{
isShadow[i] = true;
}
// Shouldn't get impacts with triggers
Assert( !pObject->IsTrigger() );
}
}
// copy off the post-collision variable data
m_gameEvent.collisionSpeed = pEvent->collisionSpeed;
m_gameEvent.pInternalData = pEvent->pInternalData;
// special case for hitting self, only make one non-shadow call
if ( m_gameEvent.pEntities[0] == m_gameEvent.pEntities[1] )
{
if ( pEvent->isCollision && m_gameEvent.pEntities[0] )
{
m_gameEvent.pEntities[0]->VPhysicsCollision( 0, &m_gameEvent );
}
return;
}
if ( isShadow[0] && isShadow[1] )
{
pEvent->isCollision = false;
}
for ( i = 0; i < 2; i++ )
{
if ( pEvent->isCollision )
{
m_gameEvent.pEntities[i]->VPhysicsCollision( i, &m_gameEvent );
}
if ( pEvent->isShadowCollision && isShadow[i] )
{
m_gameEvent.pEntities[i]->VPhysicsShadowCollision( i, &m_gameEvent );
}
}
}
void PhysForceEntityToSleep( CBaseEntity *pEntity, IPhysicsObject *pObject )
{
// UNDONE: Check to see if the object is touching the player first?
// Might get the player stuck?
if ( !pObject || !pObject->IsMoveable() )
return;
DevMsg(2, "Putting entity to sleep: %s\n", pEntity->GetClassname() );
MEM_ALLOC_CREDIT();
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int physCount = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
for ( int i = 0; i < physCount; i++ )
{
PhysForceClearVelocity( pList[i] );
pList[i]->Sleep();
}
}
void CCollisionEvent::Friction( IPhysicsObject *pObject, float energy, int surfaceProps, int surfacePropsHit, IPhysicsCollisionData *pData )
{
CallbackContext check(this);
//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 ( 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;
}
}
pEntity->VPhysicsFriction( 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::UpdateRemoveObjects()
{
Assert(!PhysIsInCallback());
for ( int i = 0 ; i < m_removeObjects.Count(); i++ )
{
UTIL_Remove(m_removeObjects[i]);
}
m_removeObjects.RemoveAll();
}
void CCollisionEvent::PostSimulationFrame()
{
UpdateDamageEvents();
g_PostSimulationQueue.CallQueued();
UpdateRemoveObjects();
}
void CCollisionEvent::FlushQueuedOperations()
{
int loopCount = 0;
while ( loopCount < 20 )
{
int count = m_triggerEvents.Count() + m_touchEvents.Count() + m_damageEvents.Count() + m_removeObjects.Count() + g_PostSimulationQueue.Count();
if ( !count )
break;
// testing, if this assert fires it proves we've fixed the crash
// after that the assert + warning can safely be removed
Assert(0);
Warning("Physics queue not empty, error!\n");
loopCount++;
UpdateTouchEvents();
UpdateDamageEvents();
g_PostSimulationQueue.CallQueued();
UpdateRemoveObjects();
}
}
void CCollisionEvent::FrameUpdate( void )
{
UpdateFrictionSounds();
UpdateTouchEvents();
UpdatePenetrateEvents();
UpdateFluidEvents();
UpdateDamageEvents(); // if there was no PSI in physics, we'll still need to do some of these because collisions are solved in between PSIs
g_PostSimulationQueue.CallQueued();
UpdateRemoveObjects();
// There are some queued operations that must complete each frame, iterate until these are done
FlushQueuedOperations();
}
// the delete list is getting flushed, clean up ours
void PhysOnCleanupDeleteList()
{
g_Collisions.FlushQueuedOperations();
if ( physenv )
{
physenv->CleanupDeleteList();
}
}
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);
}
}
}
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;
}
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] );
}
}
}
}
void CCollisionEvent::DispatchStartTouch( CBaseEntity *pEntity0, CBaseEntity *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 );
}
void CCollisionEvent::DispatchEndTouch( CBaseEntity *pEntity0, CBaseEntity *pEntity1 )
{
// frees the event-driven touchlinks
pEntity0->PhysicsNotifyOtherOfUntouch( pEntity0, pEntity1 );
pEntity1->PhysicsNotifyOtherOfUntouch( pEntity1, pEntity0 );
}
void CCollisionEvent::UpdateTouchEvents( void )
{
int i;
// Turn on buffering in case new touch events occur during processing
bool bOldTouchEvents = m_bBufferTouchEvents;
m_bBufferTouchEvents = true;
for ( 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();
for ( i = 0; i < m_triggerEvents.Count(); i++ )
{
m_currentTriggerEvent = m_triggerEvents[i];
if ( m_currentTriggerEvent.bStart )
{
m_currentTriggerEvent.pTriggerEntity->StartTouch( m_currentTriggerEvent.pEntity );
}
else
{
m_currentTriggerEvent.pTriggerEntity->EndTouch( m_currentTriggerEvent.pEntity );
}
}
m_triggerEvents.RemoveAll();
m_currentTriggerEvent.Clear();
m_bBufferTouchEvents = bOldTouchEvents;
}
void CCollisionEvent::UpdateDamageEvents( void )
{
for ( int i = 0; i < m_damageEvents.Count(); i++ )
{
damageevent_t &event = m_damageEvents[i];
// Track changes in the entity's life state
int iEntBits = event.pEntity->IsAlive() ? 0x0001 : 0;
iEntBits |= event.pEntity->IsMarkedForDeletion() ? 0x0002 : 0;
iEntBits |= (event.pEntity->GetSolidFlags() & FSOLID_NOT_SOLID) ? 0x0004 : 0;
#if 0
// Go ahead and compute the current static stress when hit by a large object (with a force high enough to do damage).
// That way you die from the impact rather than the stress of the object resting on you whenever possible.
// This makes the damage effects cleaner.
if ( event.pInflictorPhysics && event.pInflictorPhysics->GetMass() > VPHYSICS_LARGE_OBJECT_MASS )
{
CBaseCombatCharacter *pCombat = event.pEntity->MyCombatCharacterPointer();
if ( pCombat )
{
vphysics_objectstress_t stressOut;
event.info.AddDamage( pCombat->CalculatePhysicsStressDamage( &stressOut, pCombat->VPhysicsGetObject() ) );
}
}
#endif
event.pEntity->TakeDamage( event.info );
int iEntBits2 = event.pEntity->IsAlive() ? 0x0001 : 0;
iEntBits2 |= event.pEntity->IsMarkedForDeletion() ? 0x0002 : 0;
iEntBits2 |= (event.pEntity->GetSolidFlags() & FSOLID_NOT_SOLID) ? 0x0004 : 0;
if ( event.bRestoreVelocity && iEntBits != iEntBits2 )
{
// UNDONE: Use ratio of masses to blend in a little of the collision response?
// UNDONE: Damage for future events is already computed - it would be nice to
// go back and recompute it now that the values have
// been adjusted
RestoreDamageInflictorState( event.pInflictorPhysics );
}
}
m_damageEvents.RemoveAll();
m_damageInflictors.RemoveAll();
}
void CCollisionEvent::RestoreDamageInflictorState( int inflictorStateIndex, float velocityBlend )
{
inflictorstate_t &state = m_damageInflictors[inflictorStateIndex];
if ( state.restored )
return;
// so we only restore this guy once
state.restored = true;
if ( velocityBlend > 0 )
{
Vector velocity;
AngularImpulse angVel;
state.pInflictorPhysics->GetVelocity( &velocity, &angVel );
state.savedVelocity = state.savedVelocity*velocityBlend + velocity*(1-velocityBlend);
state.savedAngularVelocity = state.savedAngularVelocity*velocityBlend + angVel*(1-velocityBlend);
state.pInflictorPhysics->SetVelocity( &state.savedVelocity, &state.savedAngularVelocity );
}
if ( state.nextIndex >= 0 )
{
RestoreDamageInflictorState( state.nextIndex, velocityBlend );
}
}
void CCollisionEvent::RestoreDamageInflictorState( IPhysicsObject *pInflictor )
{
if ( !pInflictor )
return;
int index = FindDamageInflictor( pInflictor );
if ( index >= 0 )
{
inflictorstate_t &state = m_damageInflictors[index];
if ( !state.restored )
{
float velocityBlend = 1.0;
float inflictorMass = state.pInflictorPhysics->GetMass();
if ( inflictorMass < VPHYSICS_LARGE_OBJECT_MASS && !(state.pInflictorPhysics->GetGameFlags() & FVPHYSICS_DMG_SLICE) )
{
float otherMass = state.otherMassMax > 0 ? state.otherMassMax : 1;
float massRatio = inflictorMass / otherMass;
massRatio = clamp( massRatio, 0.1f, 10.0f );
if ( massRatio < 1 )
{
velocityBlend = RemapVal( massRatio, 0.1, 1, 0, 0.5 );
}
else
{
velocityBlend = RemapVal( massRatio, 1.0, 10, 0.5, 1 );
}
}
RestoreDamageInflictorState( index, velocityBlend );
}
}
}
bool CCollisionEvent::GetInflictorVelocity( IPhysicsObject *pInflictor, Vector &velocity, AngularImpulse &angVelocity )
{
int index = FindDamageInflictor( pInflictor );
if ( index >= 0 )
{
inflictorstate_t &state = m_damageInflictors[index];
velocity = state.savedVelocity;
angVelocity = state.savedAngularVelocity;
return true;
}
return false;
}
bool PhysGetDamageInflictorVelocityStartOfFrame( IPhysicsObject *pInflictor, Vector &velocity, AngularImpulse &angVelocity )
{
return g_Collisions.GetInflictorVelocity( pInflictor, velocity, angVelocity );
}
void CCollisionEvent::AddTouchEvent( CBaseEntity *pEntity0, CBaseEntity *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;
}
void CCollisionEvent::AddDamageEvent( CBaseEntity *pEntity, const CTakeDamageInfo &info, IPhysicsObject *pInflictorPhysics, bool bRestoreVelocity, const Vector &savedVel, const AngularImpulse &savedAngVel )
{
if ( pEntity->IsMarkedForDeletion() )
return;
int iTimeBasedDamage = g_pGameRules->Damage_GetTimeBased();
if ( !( info.GetDamageType() & (DMG_BURN | DMG_DROWN | iTimeBasedDamage | DMG_PREVENT_PHYSICS_FORCE) ) )
{
Assert( info.GetDamageForce() != vec3_origin && info.GetDamagePosition() != vec3_origin );
}
int index = m_damageEvents.AddToTail();
damageevent_t &event = m_damageEvents[index];
event.pEntity = pEntity;
event.info = info;
event.pInflictorPhysics = pInflictorPhysics;
event.bRestoreVelocity = bRestoreVelocity;
if ( !pInflictorPhysics || !pInflictorPhysics->IsMoveable() )
{
event.bRestoreVelocity = false;
}
if ( event.bRestoreVelocity )
{
float otherMass = pEntity->VPhysicsGetObject()->GetMass();
int inflictorIndex = FindDamageInflictor(pInflictorPhysics);
if ( inflictorIndex >= 0 )
{
// if this is a bigger mass, save that info
inflictorstate_t &state = m_damageInflictors[inflictorIndex];
if ( otherMass > state.otherMassMax )
{
state.otherMassMax = otherMass;
}
}
else
{
AddDamageInflictor( pInflictorPhysics, otherMass, savedVel, savedAngVel, true );
}
}
}
//-----------------------------------------------------------------------------
// Impulse events
//-----------------------------------------------------------------------------
static void PostSimulation_ImpulseEvent( IPhysicsObject *pObject, const Vector &centerForce, const AngularImpulse &centerTorque )
{
pObject->ApplyForceCenter( centerForce );
pObject->ApplyTorqueCenter( centerTorque );
}
void PostSimulation_SetVelocityEvent( IPhysicsObject *pPhysicsObject, const Vector &vecVelocity )
{
pPhysicsObject->SetVelocity( &vecVelocity, NULL );
}
void CCollisionEvent::AddRemoveObject(IServerNetworkable *pRemove)
{
if ( pRemove && m_removeObjects.Find(pRemove) == -1 )
{
m_removeObjects.AddToTail(pRemove);
}
}
int CCollisionEvent::FindDamageInflictor( IPhysicsObject *pInflictorPhysics )
{
// UNDONE: Linear search? Probably ok with a low count here
for ( int i = m_damageInflictors.Count()-1; i >= 0; --i )
{
const inflictorstate_t &state = m_damageInflictors[i];
if ( state.pInflictorPhysics == pInflictorPhysics )
return i;
}
return -1;
}
int CCollisionEvent::AddDamageInflictor( IPhysicsObject *pInflictorPhysics, float otherMass, const Vector &savedVel, const AngularImpulse &savedAngVel, bool addList )
{
// NOTE: Save off the state of the object before collision
// restore if the impact is a kill
// UNDONE: Should we absorb some energy here?
// NOTE: we can't save a delta because there could be subsequent post-fatal collisions
int addIndex = m_damageInflictors.AddToTail();
{
inflictorstate_t &state = m_damageInflictors[addIndex];
state.pInflictorPhysics = pInflictorPhysics;
state.savedVelocity = savedVel;
state.savedAngularVelocity = savedAngVel;
state.otherMassMax = otherMass;
state.restored = false;
state.nextIndex = -1;
}
if ( addList )
{
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pInflictorPhysics->GetGameData());
if ( pEntity )
{
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int physCount = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
if ( physCount > 1 )
{
int currentIndex = addIndex;
for ( int i = 0; i < physCount; i++ )
{
if ( pList[i] != pInflictorPhysics )
{
Vector vel;
AngularImpulse angVel;
pList[i]->GetVelocity( &vel, &angVel );
int next = AddDamageInflictor( pList[i], otherMass, vel, angVel, false );
m_damageInflictors[currentIndex].nextIndex = next;
currentIndex = next;
}
}
}
}
}
return addIndex;
}
void CCollisionEvent::LevelShutdown( void )
{
for ( int i = 0; i < ARRAYSIZE(m_current); i++ )
{
if ( m_current[i].patch )
{
ShutdownFriction( m_current[i] );
}
}
}
void CCollisionEvent::StartTouch( IPhysicsObject *pObject1, IPhysicsObject *pObject2, IPhysicsCollisionData *pTouchData )
{
CallbackContext check(this);
CBaseEntity *pEntity1 = static_cast<CBaseEntity *>(pObject1->GetGameData());
CBaseEntity *pEntity2 = static_cast<CBaseEntity *>(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 );
}
}
static int CountPhysicsObjectEntityContacts( IPhysicsObject *pObject, CBaseEntity *pEntity )
{
IPhysicsFrictionSnapshot *pSnapshot = pObject->CreateFrictionSnapshot();
int count = 0;
while ( pSnapshot->IsValid() )
{
IPhysicsObject *pOther = pSnapshot->GetObject(1);
CBaseEntity *pOtherEntity = static_cast<CBaseEntity *>(pOther->GetGameData());
if ( pOtherEntity == pEntity )
count++;
pSnapshot->NextFrictionData();
}
pObject->DestroyFrictionSnapshot( pSnapshot );
return count;
}
void CCollisionEvent::EndTouch( IPhysicsObject *pObject1, IPhysicsObject *pObject2, IPhysicsCollisionData *pTouchData )
{
CallbackContext check(this);
CBaseEntity *pEntity1 = static_cast<CBaseEntity *>(pObject1->GetGameData());
CBaseEntity *pEntity2 = static_cast<CBaseEntity *>(pObject2->GetGameData());
if ( !pEntity1 || !pEntity2 )
return;
// contact point deleted, but entities are still touching?
IPhysicsObject *list[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int count = pEntity1->VPhysicsGetObjectList( list, ARRAYSIZE(list) );
int contactCount = 0;
for ( int i = 0; i < count; i++ )
{
contactCount += CountPhysicsObjectEntityContacts( list[i], pEntity2 );
// still touching
if ( contactCount > 1 )
return;
}
// should have exactly one contact point (the one getting deleted here)
//Assert( contactCount == 1 );
Vector endPoint, normal;
pTouchData->GetContactPoint( endPoint );
pTouchData->GetSurfaceNormal( normal );
if ( !m_bBufferTouchEvents )
{
DispatchEndTouch( pEntity1, pEntity2 );
}
else
{
AddTouchEvent( pEntity1, pEntity2, TOUCH_END, vec3_origin, vec3_origin );
}
}
// UNDONE: This is functional, but minimally.
void CCollisionEvent::ObjectEnterTrigger( IPhysicsObject *pTrigger, IPhysicsObject *pObject )
{
CBaseEntity *pTriggerEntity = static_cast<CBaseEntity *>(pTrigger->GetGameData());
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pObject->GetGameData());
if ( pTriggerEntity && pEntity )
{
// UNDONE: Don't buffer these until we can solve generating touches at object creation time
if ( 0 && m_bBufferTouchEvents )
{
int index = m_triggerEvents.AddToTail();
m_triggerEvents[index].Init( pTriggerEntity, pTrigger, pEntity, pObject, true );
}
else
{
CallbackContext check(this);
m_currentTriggerEvent.Init( pTriggerEntity, pTrigger, pEntity, pObject, true );
pTriggerEntity->StartTouch( pEntity );
m_currentTriggerEvent.Clear();
}
}
}
void CCollisionEvent::ObjectLeaveTrigger( IPhysicsObject *pTrigger, IPhysicsObject *pObject )
{
CBaseEntity *pTriggerEntity = static_cast<CBaseEntity *>(pTrigger->GetGameData());
CBaseEntity *pEntity = static_cast<CBaseEntity *>(pObject->GetGameData());
if ( pTriggerEntity && pEntity )
{
// UNDONE: Don't buffer these until we can solve generating touches at object creation time
if ( 0 && m_bBufferTouchEvents )
{
int index = m_triggerEvents.AddToTail();
m_triggerEvents[index].Init( pTriggerEntity, pTrigger, pEntity, pObject, false );
}
else
{
CallbackContext check(this);
m_currentTriggerEvent.Init( pTriggerEntity, pTrigger, pEntity, pObject, false );
pTriggerEntity->EndTouch( pEntity );
m_currentTriggerEvent.Clear();
}
}
}
bool CCollisionEvent::GetTriggerEvent( triggerevent_t *pEvent, CBaseEntity *pTriggerEntity )
{
if ( pEvent && pTriggerEntity == m_currentTriggerEvent.pTriggerEntity )
{
*pEvent = m_currentTriggerEvent;
return true;
}
return false;
}
void PhysGetListOfPenetratingEntities( CBaseEntity *pSearch, CUtlVector<CBaseEntity *> &list )
{
g_Collisions.GetListOfPenetratingEntities( pSearch, list );
}
bool PhysGetTriggerEvent( triggerevent_t *pEvent, CBaseEntity *pTriggerEntity )
{
return g_Collisions.GetTriggerEvent( pEvent, pTriggerEntity );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// External interface to collision sounds
//-----------------------------------------------------------------------------
void PhysicsImpactSound( CBaseEntity *pEntity, IPhysicsObject *pPhysObject, int channel, int surfaceProps, int surfacePropsHit, float volume, float impactSpeed )
{
physicssound::AddImpactSound( g_PhysicsHook.m_impactSounds, pEntity, pEntity->entindex(), channel, pPhysObject, surfaceProps, surfacePropsHit, volume, impactSpeed );
}
void PhysCollisionSound( CBaseEntity *pEntity, IPhysicsObject *pPhysObject, int channel, int surfaceProps, int surfacePropsHit, float deltaTime, float speed )
{
if ( deltaTime < 0.05f || speed < 70.0f )
return;
float volume = speed * speed * (1.0f/(320.0f*320.0f)); // max volume at 320 in/s
if ( volume > 1.0f )
volume = 1.0f;
PhysicsImpactSound( pEntity, pPhysObject, channel, surfaceProps, surfacePropsHit, volume, speed );
}
void PhysBreakSound( CBaseEntity *pEntity, IPhysicsObject *pPhysObject, Vector vecOrigin )
{
if ( !pPhysObject)
return;
physicssound::AddBreakSound( g_PhysicsHook.m_breakSounds, vecOrigin, pPhysObject->GetMaterialIndex() );
}
ConVar collision_shake_amp("collision_shake_amp", "0.2");
ConVar collision_shake_freq("collision_shake_freq", "0.5");
ConVar collision_shake_time("collision_shake_time", "0.5");
void PhysCollisionScreenShake( gamevcollisionevent_t *pEvent, int index )
{
int otherIndex = !index;
float mass = pEvent->pObjects[index]->GetMass();
if ( mass >= VPHYSICS_LARGE_OBJECT_MASS && pEvent->pObjects[otherIndex]->IsStatic() &&
!(pEvent->pObjects[index]->GetGameFlags() & FVPHYSICS_PENETRATING) )
{
mass = clamp(mass, VPHYSICS_LARGE_OBJECT_MASS, 2000.f);
if ( pEvent->collisionSpeed > 30 && pEvent->deltaCollisionTime > 0.25f )
{
Vector vecPos;
pEvent->pInternalData->GetContactPoint( vecPos );
float impulse = pEvent->collisionSpeed * mass;
float amplitude = impulse * (collision_shake_amp.GetFloat() / (30.0f * VPHYSICS_LARGE_OBJECT_MASS));
UTIL_ScreenShake( vecPos, amplitude, collision_shake_freq.GetFloat(), collision_shake_time.GetFloat(), amplitude * 60, SHAKE_START );
}
}
}
#if HL2_EPISODIC
// Uses DispatchParticleEffect because, so far as I know, that is the new means of kicking
// off flinders for this kind of collision. Should this be in g_pEffects instead?
void PhysCollisionWarpEffect( gamevcollisionevent_t *pEvent, surfacedata_t *phit )
{
Vector vecPos;
QAngle vecAngles;
pEvent->pInternalData->GetContactPoint( vecPos );
{
Vector vecNormal;
pEvent->pInternalData->GetSurfaceNormal(vecNormal);
VectorAngles( vecNormal, vecAngles );
}
DispatchParticleEffect( "warp_shield_impact", vecPos, vecAngles );
}
#endif
void PhysCollisionDust( gamevcollisionevent_t *pEvent, surfacedata_t *phit )
{
switch ( phit->game.material )
{
case CHAR_TEX_SAND:
case CHAR_TEX_DIRT:
if ( pEvent->collisionSpeed < 200.0f )
return;
break;
case CHAR_TEX_CONCRETE:
if ( pEvent->collisionSpeed < 340.0f )
return;
break;
#if HL2_EPISODIC
// this is probably redundant because BaseEntity::VHandleCollision should have already dispatched us elsewhere
case CHAR_TEX_WARPSHIELD:
PhysCollisionWarpEffect(pEvent,phit);
return;
break;
#endif
default:
return;
}
//Kick up dust
Vector vecPos, vecVel;
pEvent->pInternalData->GetContactPoint( vecPos );
vecVel.Random( -1.0f, 1.0f );
vecVel.z = random->RandomFloat( 0.3f, 1.0f );
VectorNormalize( vecVel );
g_pEffects->Dust( vecPos, vecVel, 8.0f, pEvent->collisionSpeed );
}
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 );
pFriction->patch = CSoundEnvelopeController::GetController().SoundCreate(
filter, pEntity->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 );
}
}
//-----------------------------------------------------------------------------
// Applies force impulses at a later time
//-----------------------------------------------------------------------------
void PhysCallbackImpulse( IPhysicsObject *pPhysicsObject, const Vector &vecCenterForce, const AngularImpulse &vecCenterTorque )
{
Assert( physenv->IsInSimulation() );
g_PostSimulationQueue.QueueCall( PostSimulation_ImpulseEvent, pPhysicsObject, RefToVal(vecCenterForce), RefToVal(vecCenterTorque) );
}
void PhysCallbackSetVelocity( IPhysicsObject *pPhysicsObject, const Vector &vecVelocity )
{
Assert( physenv->IsInSimulation() );
g_PostSimulationQueue.QueueCall( PostSimulation_SetVelocityEvent, pPhysicsObject, RefToVal(vecVelocity) );
}
void PhysCallbackDamage( CBaseEntity *pEntity, const CTakeDamageInfo &info, gamevcollisionevent_t &event, int hurtIndex )
{
Assert( physenv->IsInSimulation() );
int otherIndex = !hurtIndex;
g_Collisions.AddDamageEvent( pEntity, info, event.pObjects[otherIndex], true, event.preVelocity[otherIndex], event.preAngularVelocity[otherIndex] );
}
void PhysCallbackDamage( CBaseEntity *pEntity, const CTakeDamageInfo &info )
{
if ( PhysIsInCallback() )
{
CBaseEntity *pInflictor = info.GetInflictor();
IPhysicsObject *pInflictorPhysics = (pInflictor) ? pInflictor->VPhysicsGetObject() : NULL;
g_Collisions.AddDamageEvent( pEntity, info, pInflictorPhysics, false, vec3_origin, vec3_origin );
if ( pEntity && info.GetInflictor() )
{
DevMsg( 2, "Warning: Physics damage event with no recovery info!\nObjects: %s, %s\n", pEntity->GetClassname(), info.GetInflictor()->GetClassname() );
}
}
else
{
pEntity->TakeDamage( info );
}
}
void PhysCallbackRemove(IServerNetworkable *pRemove)
{
if ( PhysIsInCallback() )
{
g_Collisions.AddRemoveObject(pRemove);
}
else
{
UTIL_Remove(pRemove);
}
}
void PhysSetEntityGameFlags( CBaseEntity *pEntity, unsigned short flags )
{
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int count = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
for ( int i = 0; i < count; i++ )
{
PhysSetGameFlags( pList[i], flags );
}
}
bool PhysFindOrAddVehicleScript( const char *pScriptName, vehicleparams_t *pParams, vehiclesounds_t *pSounds )
{
return g_PhysicsHook.FindOrAddVehicleScript(pScriptName, pParams, pSounds);
}
void PhysFlushVehicleScripts()
{
g_PhysicsHook.FlushVehicleScripts();
}
IPhysicsObject *FindPhysicsObjectByName( const char *pName, CBaseEntity *pErrorEntity )
{
if ( !pName || !strlen(pName) )
return NULL;
CBaseEntity *pEntity = NULL;
IPhysicsObject *pBestObject = NULL;
while (1)
{
pEntity = gEntList.FindEntityByName( pEntity, pName );
if ( !pEntity )
break;
if ( pEntity->VPhysicsGetObject() )
{
if ( pBestObject )
{
const char *pErrorName = pErrorEntity ? pErrorEntity->GetClassname() : "Unknown";
Vector origin = pErrorEntity ? pErrorEntity->GetAbsOrigin() : vec3_origin;
DevWarning("entity %s at %s has physics attachment to more than one entity with the name %s!!!\n", pErrorName, VecToString(origin), pName );
while ( ( pEntity = gEntList.FindEntityByName( pEntity, pName ) ) != NULL )
{
DevWarning("Found %s\n", pEntity->GetClassname() );
}
break;
}
pBestObject = pEntity->VPhysicsGetObject();
}
}
return pBestObject;
}
void CC_AirDensity( const CCommand &args )
{
if ( !physenv )
return;
if ( args.ArgC() < 2 )
{
Msg( "air_density <value>\nCurrent air density is %.2f\n", physenv->GetAirDensity() );
}
else
{
float density = atof( args[1] );
physenv->SetAirDensity( density );
}
}
static ConCommand air_density("air_density", CC_AirDensity, "Changes the density of air for drag computations.", FCVAR_CHEAT);
void DebugDrawContactPoints(IPhysicsObject *pPhysics)
{
IPhysicsFrictionSnapshot *pSnapshot = pPhysics->CreateFrictionSnapshot();
while ( pSnapshot->IsValid() )
{
Vector pt, normal;
pSnapshot->GetContactPoint( pt );
pSnapshot->GetSurfaceNormal( normal );
NDebugOverlay::Box( pt, -Vector(1,1,1), Vector(1,1,1), 0, 255, 0, 32, 0 );
NDebugOverlay::Line( pt, pt - normal * 20, 0, 255, 0, false, 0 );
IPhysicsObject *pOther = pSnapshot->GetObject(1);
CBaseEntity *pEntity0 = static_cast<CBaseEntity *>(pOther->GetGameData());
CFmtStr str("%s (%s): %s [%0.2f]", pEntity0->GetClassname(), STRING(pEntity0->GetModelName()), pEntity0->GetDebugName(), pSnapshot->GetFrictionCoefficient() );
NDebugOverlay::Text( pt, str.Access(), false, 0 );
pSnapshot->NextFrictionData();
}
pSnapshot->DeleteAllMarkedContacts( true );
pPhysics->DestroyFrictionSnapshot( pSnapshot );
}
#if 0
#include "filesystem.h"
//-----------------------------------------------------------------------------
// Purpose: This will append a collide to a glview file. Then you can view the
// collisionmodels with glview.
// Input : *pCollide - collision model
// &origin - position of the instance of this model
// &angles - orientation of instance
// *pFilename - output text file
//-----------------------------------------------------------------------------
// examples:
// world:
// DumpCollideToGlView( pWorldCollide->solids[0], vec3_origin, vec3_origin, "jaycollide.txt" );
// static_prop:
// DumpCollideToGlView( info.m_pCollide->solids[0], info.m_Origin, info.m_Angles, "jaycollide.txt" );
//
//-----------------------------------------------------------------------------
void DumpCollideToGlView( CPhysCollide *pCollide, const Vector &origin, const QAngle &angles, const char *pFilename )
{
if ( !pCollide )
return;
printf("Writing %s...\n", pFilename );
Vector *outVerts;
int vertCount = physcollision->CreateDebugMesh( pCollide, &outVerts );
FileHandle_t fp = filesystem->Open( pFilename, "ab" );
int triCount = vertCount / 3;
int vert = 0;
VMatrix tmp = SetupMatrixOrgAngles( origin, angles );
int i;
for ( i = 0; i < vertCount; i++ )
{
outVerts[i] = tmp.VMul4x3( outVerts[i] );
}
for ( i = 0; i < triCount; i++ )
{
filesystem->FPrintf( fp, "3\n" );
filesystem->FPrintf( fp, "%6.3f %6.3f %6.3f 1 0 0\n", outVerts[vert].x, outVerts[vert].y, outVerts[vert].z );
vert++;
filesystem->FPrintf( fp, "%6.3f %6.3f %6.3f 0 1 0\n", outVerts[vert].x, outVerts[vert].y, outVerts[vert].z );
vert++;
filesystem->FPrintf( fp, "%6.3f %6.3f %6.3f 0 0 1\n", outVerts[vert].x, outVerts[vert].y, outVerts[vert].z );
vert++;
}
filesystem->Close( fp );
physcollision->DestroyDebugMesh( vertCount, outVerts );
}
#endif