mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-23 14:46:53 +00:00
2934 lines
84 KiB
C++
2934 lines
84 KiB
C++
//========= 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( ¶ms );
|
|
|
|
#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( gpGlobals->interval_per_tick ); // 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( gpGlobals->interval_per_tick );
|
|
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( gpGlobals->interval_per_tick );
|
|
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 ¢erForce, const AngularImpulse ¢erTorque )
|
|
{
|
|
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
|
|
|