H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 06:06:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
source-engine/vphysics/physics_environment.cpp

2229 lines
66 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tier0/threadtools.h"
#include "physics_constraint.h"
#include "physics_spring.h"
#include "physics_fluid.h"
#include "physics_shadow.h"
#include "physics_motioncontroller.h"
#include "physics_vehicle.h"
#include "physics_virtualmesh.h"
#include "utlmultilist.h"
#include "vphysics/constraints.h"
#include "vphysics/vehicles.h"
#include "vphysics/object_hash.h"
#include "vphysics/performance.h"
#include "vphysics/stats.h"
#include "vphysics/player_controller.h"
#include "vphysics_saverestore.h"
#include "vphysics_internal.h"
#include "ivu_linear_macros.hxx"
#include "ivp_collision_filter.hxx"
#include "ivp_listener_collision.hxx"
#include "ivp_listener_object.hxx"
#include "ivp_mindist.hxx"
#include "ivp_mindist_intern.hxx"
#include "ivp_friction.hxx"
#include "ivp_anomaly_manager.hxx"
#include "ivp_time.hxx"
#include "ivp_listener_psi.hxx"
#include "ivp_phantom.hxx"
#include "ivp_range_manager.hxx"
#include "ivp_clustering_visualizer.hxx"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
IPhysicsObjectPairHash *CreateObjectPairHash();
IVP_Synapse_Friction *GetOppositeSynapse( IVP_Synapse_Friction *pfriction )
{
IVP_Contact_Point *contact = pfriction->get_contact_point();
IVP_Synapse_Friction *ptest = contact->get_synapse(0);
if ( ptest == pfriction )
{
ptest = contact->get_synapse(1);
}
return ptest;
}
IVP_Real_Object *GetOppositeSynapseObject( IVP_Synapse_Friction *pfriction )
{
IVP_Synapse_Friction *opposite = GetOppositeSynapse( pfriction );
return opposite->get_object();
}
// simple delete queue
class IDeleteQueueItem
{
public:
// Add a virtual destructor to silence the clang warning.
// Note that this destructor doesn't actually do anything -- you
// still have to use the Delete() then delete pattern.
virtual ~IDeleteQueueItem() {}
virtual void Delete() = 0;
};
template <typename T>
class CDeleteProxy : public IDeleteQueueItem
{
public:
CDeleteProxy(T *pItem) : m_pItem(pItem) {}
virtual void Delete() { delete m_pItem; }
private:
T *m_pItem;
};
class CDeleteQueue
{
public:
void Add( IDeleteQueueItem *pItem )
{
m_list.AddToTail( pItem );
}
template <typename T>
void QueueForDelete( T *pItem )
{
Add( new CDeleteProxy<T>(pItem) );
}
void DeleteAll()
{
for ( int i = m_list.Count()-1; i >= 0; --i)
{
m_list[i]->Delete();
delete m_list[i];
}
m_list.RemoveAll();
}
private:
CUtlVector< IDeleteQueueItem * > m_list;
};
class CPhysicsCollisionData : public IPhysicsCollisionData
{
public:
CPhysicsCollisionData( IVP_Contact_Situation *contact ) : m_pContact(contact) {}
virtual void GetSurfaceNormal( Vector &out ) { ConvertDirectionToHL( m_pContact->surf_normal, out ); }
virtual void GetContactPoint( Vector &out ) { ConvertPositionToHL( m_pContact->contact_point_ws, out ); }
virtual void GetContactSpeed( Vector &out ) { ConvertPositionToHL( m_pContact->speed, out ); }
const IVP_Contact_Situation *m_pContact;
};
class CPhysicsFrictionData : public IPhysicsCollisionData
{
public:
CPhysicsFrictionData( IVP_Synapse_Friction *synapse, float sign ) : m_sign(sign)
{
m_pPoint = synapse->get_contact_point();
m_pContact = NULL;
}
CPhysicsFrictionData( IVP_Event_Friction *pEvent ) : m_sign(1.0f)
{
m_pPoint = pEvent->friction_handle;
m_pContact = pEvent->contact_situation;
}
virtual void GetSurfaceNormal( Vector &out )
{
if ( m_pContact )
{
ConvertDirectionToHL( m_pContact->surf_normal, out );
}
else
{
IVP_U_Float_Point normal;
IVP_Contact_Point_API::get_surface_normal_ws(const_cast<IVP_Contact_Point *>(m_pPoint), &normal);
ConvertDirectionToHL( normal, out );
out *= m_sign;
}
}
virtual void GetContactPoint( Vector &out )
{
if ( m_pContact )
{
ConvertPositionToHL( m_pContact->contact_point_ws, out );
}
else
{
ConvertPositionToHL( *m_pPoint->get_contact_point_ws(), out );
}
}
virtual void GetContactSpeed( Vector &out )
{
if ( m_pContact )
{
ConvertPositionToHL( m_pContact->speed, out );
}
else
{
out.Init();
}
}
private:
const IVP_Contact_Point *m_pPoint;
float m_sign;
const IVP_Contact_Situation *m_pContact;
};
//-----------------------------------------------------------------------------
// Purpose: Routes object event callbacks to game code
//-----------------------------------------------------------------------------
class CSleepObjects : public IVP_Listener_Object
{
public:
CSleepObjects( void ) : IVP_Listener_Object()
{
m_pCallback = NULL;
m_lastScrapeTime = 0.0f;
}
void SetHandler( IPhysicsObjectEvent *pListener )
{
m_pCallback = pListener;
}
void Remove( int index )
{
// fast remove preserves indices except for the last element (moved into the empty spot)
m_activeObjects.FastRemove(index);
// If this isn't the last element, shift its index over
if ( index < m_activeObjects.Count() )
{
m_activeObjects[index]->SetActiveIndex( index );
}
}
void DeleteObject( CPhysicsObject *pObject )
{
int index = pObject->GetActiveIndex();
if ( index < m_activeObjects.Count() )
{
Assert( m_activeObjects[index] == pObject );
Remove( index );
pObject->SetActiveIndex( 0xFFFF );
}
else
{
Assert(index==0xFFFF);
}
}
void event_object_deleted( IVP_Event_Object *pEvent )
{
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pEvent->real_object->client_data);
if ( !pObject )
return;
DeleteObject(pObject);
}
void event_object_created( IVP_Event_Object *pEvent )
{
}
void event_object_revived( IVP_Event_Object *pEvent )
{
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pEvent->real_object->client_data);
if ( !pObject )
return;
int sleepState = pObject->GetSleepState();
pObject->NotifyWake();
// asleep, but already in active list
if ( sleepState == OBJ_STARTSLEEP )
return;
// don't track static objects (like the world). That way we only track objects that will move
if ( pObject->GetObject()->get_movement_state() != IVP_MT_STATIC )
{
Assert(pObject->GetActiveIndex()==0xFFFF);
if ( pObject->GetActiveIndex()!=0xFFFF)
return;
int index = m_activeObjects.AddToTail( pObject );
pObject->SetActiveIndex( index );
}
if ( m_pCallback )
{
m_pCallback->ObjectWake( pObject );
}
}
void event_object_frozen( IVP_Event_Object *pEvent )
{
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pEvent->real_object->client_data);
if ( !pObject )
return;
pObject->NotifySleep();
if ( m_pCallback )
{
m_pCallback->ObjectSleep( pObject );
}
}
//-----------------------------------------------------------------------------
// Purpose: This walks the objects in the environment and generates friction events
// for any scraping that is occurring.
//-----------------------------------------------------------------------------
void ProcessActiveObjects( IVP_Environment *pEnvironment, IPhysicsCollisionEvent *pEvent )
{
// FIXME: Is this correct? Shouldn't it do next PSI - lastScrape?
float nextTime = pEnvironment->get_old_time_of_last_PSI().get_time();
float delta = nextTime - m_lastScrapeTime;
// only process if we have done a PSI
if ( delta < pEnvironment->get_delta_PSI_time() )
return;
float t = 0.0f;
if ( delta != 0.0f )
{
t = 1.0f / delta;
}
m_lastScrapeTime = nextTime;
// UNDONE: This only calls friciton for one object in each pair.
// UNDONE: Split energy in half and call for both objects?
// UNDONE: Don't split/call if one object is static (like the world)?
for ( int i = 0; i < m_activeObjects.Count(); i++ )
{
CPhysicsObject *pObject = m_activeObjects[i];
IVP_Real_Object *ivpObject = pObject->GetObject();
// no friction callbacks for this object
if ( ! (pObject->CallbackFlags() & CALLBACK_GLOBAL_FRICTION) )
continue;
// UNDONE: IVP_Synapse_Friction is supposed to be opaque. Is there a better way
// to implement this? Using the friction listener is much more work for the CPU
// and considers sleeping objects.
IVP_Synapse_Friction *pfriction = ivpObject->get_first_friction_synapse();
while ( pfriction )
{
IVP_Contact_Point *contact = pfriction->get_contact_point();
IVP_Synapse_Friction *pOpposite = GetOppositeSynapse( pfriction );
IVP_Real_Object *pobj = pOpposite->get_object();
CPhysicsObject *pScrape = (CPhysicsObject *)pobj->client_data;
// friction callbacks for this object?
if ( pScrape->CallbackFlags() & CALLBACK_GLOBAL_FRICTION )
{
float energy = IVP_Contact_Point_API::get_eliminated_energy( contact );
if ( energy )
{
// scrape with an estimate for the energy per unit mass
// This assumes that the game is interested in some measure of vibration
// for sound effects. This also assumes that more massive objects require
// more energy to vibrate.
energy = energy * t * ivpObject->get_core()->get_inv_mass();
if ( energy > 0.05f )
{
int hitSurface = pScrape->GetMaterialIndexInternal();
int materialIndex = pOpposite->get_material_index();
if ( materialIndex )
{
// use the per-triangle material if it has one
hitSurface = physprops->RemapIVPMaterialIndex( materialIndex );
}
float sign = (pfriction == contact->get_synapse(0)) ? 1 : -1;
CPhysicsFrictionData data(pfriction, sign);
pEvent->Friction( pObject, ConvertEnergyToHL(energy), pObject->GetMaterialIndexInternal(), hitSurface, &data );
}
IVP_Contact_Point_API::reset_eliminated_energy( contact );
}
}
pfriction = pfriction->get_next();
}
}
}
void DebugCheckContacts( IVP_Environment *pEnvironment )
{
IVP_Mindist_Manager *pManager = pEnvironment->get_mindist_manager();
for( IVP_Mindist *mdist = pManager->exact_mindists; mdist != NULL; mdist = mdist->next )
{
IVP_Real_Object *obj[2];
mdist->get_objects( obj );
IVP_BOOL check = pEnvironment->get_collision_filter()->check_objects_for_collision_detection( obj[0], obj[1] );
Assert(check);
if ( !check )
{
Msg("Changed collision rules for %s vs. %s without calling recheck!\n", obj[0]->get_name(), obj[1]->get_name() );
}
}
}
int GetActiveObjectCount( void ) const
{
return m_activeObjects.Count();
}
void GetActiveObjects( IPhysicsObject **pOutputObjectList ) const
{
for ( int i = 0; i < m_activeObjects.Count(); i++ )
{
pOutputObjectList[i] = m_activeObjects[i];
}
}
void UpdateSleepObjects( void )
{
int i;
CUtlVector<CPhysicsObject *> sleepObjects;
for ( i = 0; i < m_activeObjects.Count(); i++ )
{
CPhysicsObject *pObject = m_activeObjects[i];
if ( pObject->GetSleepState() != OBJ_AWAKE )
{
sleepObjects.AddToTail( pObject );
}
}
for ( i = sleepObjects.Count()-1; i >= 0; --i )
{
// put fully to sleep
sleepObjects[i]->NotifySleep();
// remove from the active list
DeleteObject( sleepObjects[i] );
}
}
private:
CUtlVector<CPhysicsObject *> m_activeObjects;
float m_lastScrapeTime;
IPhysicsObjectEvent *m_pCallback;
};
class CEmptyCollisionListener : public IPhysicsCollisionEvent
{
public:
virtual void PreCollision( vcollisionevent_t *pEvent ) {}
virtual void PostCollision( vcollisionevent_t *pEvent ) {}
// This is a scrape event. The object has scraped across another object consuming the indicated energy
virtual void Friction( IPhysicsObject *pObject, float energy, int surfaceProps, int surfacePropsHit, IPhysicsCollisionData *pData ) {}
virtual void StartTouch( IPhysicsObject *pObject1, IPhysicsObject *pObject2, IPhysicsCollisionData *pTouchData ) {}
virtual void EndTouch( IPhysicsObject *pObject1, IPhysicsObject *pObject2, IPhysicsCollisionData *pTouchData ) {}
virtual void FluidStartTouch( IPhysicsObject *pObject, IPhysicsFluidController *pFluid ) {}
virtual void FluidEndTouch( IPhysicsObject *pObject, IPhysicsFluidController *pFluid ) {}
virtual void ObjectEnterTrigger( IPhysicsObject *pTrigger, IPhysicsObject *pObject ) {}
virtual void ObjectLeaveTrigger( IPhysicsObject *pTrigger, IPhysicsObject *pObject ) {}
virtual void PostSimulationFrame() {}
};
CEmptyCollisionListener g_EmptyCollisionListener;
#define ALL_COLLISION_FLAGS (IVP_LISTENER_COLLISION_CALLBACK_PRE_COLLISION|IVP_LISTENER_COLLISION_CALLBACK_POST_COLLISION|IVP_LISTENER_COLLISION_CALLBACK_FRICTION)
//-----------------------------------------------------------------------------
// Purpose: Routes collision event callbacks to game code
//-----------------------------------------------------------------------------
class CPhysicsListenerCollision : public IVP_Listener_Collision, public IVP_Listener_Phantom
{
public:
CPhysicsListenerCollision();
void SetHandler( IPhysicsCollisionEvent *pCallback )
{
m_pCallback = pCallback;
}
IPhysicsCollisionEvent *GetHandler() { return m_pCallback; }
virtual void event_pre_collision( IVP_Event_Collision *pEvent )
{
m_event.isCollision = false;
m_event.isShadowCollision = false;
IVP_Contact_Situation *contact = pEvent->contact_situation;
CPhysicsObject *pObject1 = static_cast<CPhysicsObject *>(contact->objects[0]->client_data);
CPhysicsObject *pObject2 = static_cast<CPhysicsObject *>(contact->objects[1]->client_data);
if ( !pObject1 || !pObject2 )
return;
unsigned int flags1 = pObject1->CallbackFlags();
unsigned int flags2 = pObject2->CallbackFlags();
m_event.isCollision = (flags1 & flags2 & CALLBACK_GLOBAL_COLLISION) ? true : false;
// only call shadow collisions if one is shadow and the other isn't (hence the xor)
// (if both are shadow, the collisions happen in AI - if neither, then no callback)
m_event.isShadowCollision = ((flags1^flags2) & CALLBACK_SHADOW_COLLISION) ? true : false;
m_event.pObjects[0] = pObject1;
m_event.pObjects[1] = pObject2;
m_event.deltaCollisionTime = pEvent->d_time_since_last_collision;
// This timer must have been reset or something (constructor initializes time to -1000)
// Fake the time to 50ms (resets happen often in rolling collisions for some reason)
if ( m_event.deltaCollisionTime > 999 )
{
m_event.deltaCollisionTime = 1.0;
}
CPhysicsCollisionData data(contact);
m_event.pInternalData = &data;
// clear out any static object collisions unless flagged to keep them
if ( contact->objects[0]->get_movement_state() == IVP_MT_STATIC )
{
// don't call global if disabled
if ( !(flags2 & CALLBACK_GLOBAL_COLLIDE_STATIC) )
{
m_event.isCollision = false;
}
}
if ( contact->objects[1]->get_movement_state() == IVP_MT_STATIC )
{
// don't call global if disabled
if ( !(flags1 & CALLBACK_GLOBAL_COLLIDE_STATIC) )
{
m_event.isCollision = false;
}
}
if ( !m_event.isCollision && !m_event.isShadowCollision )
return;
// look up surface props
for ( int i = 0; i < 2; i++ )
{
m_event.surfaceProps[i] = physprops->GetIVPMaterialIndex( contact->materials[i] );
if ( m_event.surfaceProps[i] < 0 )
{
m_event.surfaceProps[i] = m_event.pObjects[i]->GetMaterialIndex();
}
}
m_pCallback->PreCollision( &m_event );
}
virtual void event_post_collision( IVP_Event_Collision *pEvent )
{
// didn't call preCollision, so don't call postCollision
if ( !m_event.isCollision && !m_event.isShadowCollision )
return;
IVP_Contact_Situation *contact = pEvent->contact_situation;
float collisionSpeed = contact->speed.dot_product(&contact->surf_normal);
m_event.collisionSpeed = ConvertDistanceToHL( fabs(collisionSpeed) );
CPhysicsCollisionData data(contact);
m_event.pInternalData = &data;
m_pCallback->PostCollision( &m_event );
}
virtual void event_collision_object_deleted( class IVP_Real_Object *)
{
// enable this in constructor
}
virtual void event_friction_created( IVP_Event_Friction *pEvent )
{
IVP_Contact_Situation *contact = pEvent->contact_situation;
CPhysicsObject *pObject1 = static_cast<CPhysicsObject *>(contact->objects[0]->client_data);
CPhysicsObject *pObject2 = static_cast<CPhysicsObject *>(contact->objects[1]->client_data);
if ( !pObject1 || !pObject2 )
return;
unsigned int flags1 = pObject1->CallbackFlags();
unsigned int flags2 = pObject2->CallbackFlags();
unsigned int allflags = flags1|flags2;
if ( !pObject1->IsStatic() || !pObject2->IsStatic() )
{
if ( !pObject1->HasTouchedDynamic() && pObject2->IsMoveable() )
{
pObject1->SetTouchedDynamic();
}
if ( !pObject2->HasTouchedDynamic() && pObject1->IsMoveable() )
{
pObject2->SetTouchedDynamic();
}
}
bool calltouch = ( allflags & CALLBACK_GLOBAL_TOUCH ) ? true : false;
if ( !calltouch )
return;
if ( pObject1->IsStatic() || pObject2->IsStatic() )
{
if ( !( allflags & CALLBACK_GLOBAL_TOUCH_STATIC ) )
return;
}
CPhysicsFrictionData data(pEvent);
m_pCallback->StartTouch( pObject1, pObject2, &data );
}
virtual void event_friction_deleted( IVP_Event_Friction *pEvent )
{
IVP_Contact_Situation *contact = pEvent->contact_situation;
CPhysicsObject *pObject1 = static_cast<CPhysicsObject *>(contact->objects[0]->client_data);
CPhysicsObject *pObject2 = static_cast<CPhysicsObject *>(contact->objects[1]->client_data);
if ( !pObject1 || !pObject2 )
return;
unsigned int flags1 = pObject1->CallbackFlags();
unsigned int flags2 = pObject2->CallbackFlags();
unsigned int allflags = flags1|flags2;
bool calltouch = ( allflags & CALLBACK_GLOBAL_TOUCH ) ? true : false;
if ( !calltouch )
return;
if ( pObject1->IsStatic() || pObject2->IsStatic() )
{
if ( !( allflags & CALLBACK_GLOBAL_TOUCH_STATIC ) )
return;
}
CPhysicsFrictionData data(pEvent);
m_pCallback->EndTouch( pObject1, pObject2, &data );
}
virtual void event_friction_pair_created( class IVP_Friction_Core_Pair *pair );
virtual void event_friction_pair_deleted( class IVP_Friction_Core_Pair *pair );
virtual void mindist_entered_volume( class IVP_Controller_Phantom *controller,class IVP_Mindist_Base *mindist ) {}
virtual void mindist_left_volume(class IVP_Controller_Phantom *controller, class IVP_Mindist_Base *mindist) {}
virtual void core_entered_volume( IVP_Controller_Phantom *controller, IVP_Core *pCore )
{
CPhysicsFluidController *pFluid = static_cast<CPhysicsFluidController *>( controller->client_data );
IVP_Real_Object *pivp = pCore->objects.element_at(0);
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pivp->client_data);
if ( !pObject )
return;
if ( pFluid )
{
if ( pObject && (pObject->CallbackFlags() & CALLBACK_FLUID_TOUCH) )
{
m_pCallback->FluidStartTouch( pObject, pFluid );
}
}
else
{
// must be a trigger
IVP_Real_Object *pTriggerIVP = controller->get_object();
CPhysicsObject *pTrigger = static_cast<CPhysicsObject *>(pTriggerIVP->client_data);
if ( pTrigger )
{
m_pCallback->ObjectEnterTrigger( pTrigger, pObject );
}
}
}
virtual void core_left_volume( IVP_Controller_Phantom *controller, IVP_Core *pCore )
{
CPhysicsFluidController *pFluid = static_cast<CPhysicsFluidController *>( controller->client_data );
IVP_Real_Object *pivp = pCore->objects.element_at(0);
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pivp->client_data);
if ( !pObject )
return;
if ( pFluid )
{
if ( pObject && (pObject->CallbackFlags() & CALLBACK_FLUID_TOUCH) )
{
m_pCallback->FluidEndTouch( pObject, pFluid );
}
}
else
{
// must be a trigger
IVP_Real_Object *pTriggerIVP = controller->get_object();
CPhysicsObject *pTrigger = static_cast<CPhysicsObject *>(pTriggerIVP->client_data);
if ( pTrigger )
{
m_pCallback->ObjectLeaveTrigger( pTrigger, pObject );
}
}
}
void phantom_is_going_to_be_deleted_event(class IVP_Controller_Phantom *controller) {}
void EventPSI( CPhysicsEnvironment *pEnvironment )
{
m_pCallback->PostSimulationFrame();
UpdatePairListPSI( pEnvironment );
}
private:
struct corepair_t
{
corepair_t() = default;
corepair_t( IVP_Friction_Core_Pair *pair )
{
int index = ( pair->objs[0] < pair->objs[1] ) ? 0 : 1;
core0 = pair->objs[index];
core1 = pair->objs[!index];
lastImpactTime= pair->last_impact_time_pair;
}
IVP_Core *core0;
IVP_Core *core1;
IVP_Time lastImpactTime;
};
static bool CorePairLessFunc( const corepair_t &lhs, const corepair_t &rhs )
{
if ( lhs.core0 != rhs.core0 )
return ( lhs.core0 < rhs.core0 );
else
return ( lhs.core1 < rhs.core1 );
}
void UpdatePairListPSI( CPhysicsEnvironment *pEnvironment )
{
unsigned short index = m_pairList.FirstInorder();
IVP_Time currentTime = pEnvironment->GetIVPEnvironment()->get_current_time();
while ( m_pairList.IsValidIndex(index) )
{
unsigned short next = m_pairList.NextInorder( index );
corepair_t &test = m_pairList.Element(index);
// only keep 1 seconds worth of data
if ( (currentTime - test.lastImpactTime) > 1.0 )
{
m_pairList.RemoveAt( index );
}
index = next;
}
}
CUtlRBTree<corepair_t> m_pairList;
float m_pairListOldestTime;
IPhysicsCollisionEvent *m_pCallback;
vcollisionevent_t m_event;
};
CPhysicsListenerCollision::CPhysicsListenerCollision() : IVP_Listener_Collision( ALL_COLLISION_FLAGS ), m_pCallback(&g_EmptyCollisionListener)
{
m_pairList.SetLessFunc( CorePairLessFunc );
}
void CPhysicsListenerCollision::event_friction_pair_created( IVP_Friction_Core_Pair *pair )
{
corepair_t test(pair);
unsigned short index = m_pairList.Find( test );
if ( m_pairList.IsValidIndex( index ) )
{
corepair_t &save = m_pairList.Element(index);
// found this one already, update the time
if ( save.lastImpactTime.get_seconds() > pair->last_impact_time_pair.get_seconds() )
{
pair->last_impact_time_pair = save.lastImpactTime;
}
else
{
save.lastImpactTime = pair->last_impact_time_pair;
}
}
else
{
if ( m_pairList.Count() < 16 )
{
m_pairList.Insert( test );
}
}
}
void CPhysicsListenerCollision::event_friction_pair_deleted( IVP_Friction_Core_Pair *pair )
{
corepair_t test(pair);
unsigned short index = m_pairList.Find( test );
if ( m_pairList.IsValidIndex( index ) )
{
corepair_t &save = m_pairList.Element(index);
// found this one already, update the time
if ( save.lastImpactTime.get_seconds() < pair->last_impact_time_pair.get_seconds() )
{
save.lastImpactTime = pair->last_impact_time_pair;
}
}
else
{
if ( m_pairList.Count() < 16 )
{
m_pairList.Insert( test );
}
}
}
#if IVP_ENABLE_VISUALIZER
class CCollisionVisualizer : public IVP_Clustering_Visualizer_Shortrange_Callback, public IVP_Clustering_Visualizer_Longrange_Callback
{
IVPhysicsDebugOverlay *m_pDebug;
public:
CCollisionVisualizer(IVPhysicsDebugOverlay *pDebug) { m_pDebug = pDebug;}
void visualize_request()
{
Vector origin, extents;
ConvertPositionToHL( center, origin );
float hlradius = ConvertDistanceToHL( radius);
extents.Init( hlradius, hlradius, hlradius );
m_pDebug->AddBoxOverlay( origin, -extents, extents, vec3_angle, 0, 255, 0, 32, 0.5f);
}
virtual void devisualize_request() {}
virtual void enable() {}
virtual void disable() {}
void visualize_request_for_node()
{
Vector origin, extents;
ConvertPositionToHL( position, origin );
ConvertPositionToHL( box_extents, extents );
Vector boxOrigin, boxExtents;
CPhysicsObject *pObject0 = static_cast<CPhysicsObject *>(node_object->client_data);
pObject0->LocalToWorld( boxOrigin, origin );
QAngle angles;
pObject0->GetPosition( NULL, &angles );
m_pDebug->AddBoxOverlay( boxOrigin, -extents, extents, angles, 255, 255, 0, 0, 0.5f);
}
void visualize_request_for_intruder_radius()
{
Vector origin, extents;
ConvertPositionToHL( position, origin );
float hlradius = ConvertDistanceToHL( sphere_radius );
extents.Init( hlradius, hlradius, hlradius );
m_pDebug->AddBoxOverlay( origin, -extents, extents, vec3_angle, 0, 0, 255, 32, 0.25f);
}
};
#endif
class CCollisionSolver : public IVP_Collision_Filter, public IVP_Anomaly_Manager
{
public:
CCollisionSolver( void ) : IVP_Anomaly_Manager(IVP_FALSE) { m_pSolver = NULL; }
void SetHandler( IPhysicsCollisionSolver *pSolver ) { m_pSolver = pSolver; }
// IVP_Collision_Filter
IVP_BOOL check_objects_for_collision_detection(IVP_Real_Object *ivp0, IVP_Real_Object *ivp1)
{
if ( m_pSolver )
{
CPhysicsObject *pObject0 = static_cast<CPhysicsObject *>(ivp0->client_data);
CPhysicsObject *pObject1 = static_cast<CPhysicsObject *>(ivp1->client_data);
if ( pObject0 && pObject1 )
{
if ( (pObject0->CallbackFlags() & CALLBACK_ENABLING_COLLISION) && (pObject1->CallbackFlags() & CALLBACK_MARKED_FOR_DELETE) )
return IVP_FALSE;
if ( (pObject1->CallbackFlags() & CALLBACK_ENABLING_COLLISION) && (pObject0->CallbackFlags() & CALLBACK_MARKED_FOR_DELETE) )
return IVP_FALSE;
if ( !m_pSolver->ShouldCollide( pObject0, pObject1, pObject0->GetGameData(), pObject1->GetGameData() ) )
return IVP_FALSE;
}
}
return IVP_TRUE;
}
void environment_will_be_deleted(IVP_Environment *) {}
// IVP_Anomaly_Manager
virtual void inter_penetration( IVP_Mindist *mindist,IVP_Real_Object *ivp0, IVP_Real_Object *ivp1, IVP_DOUBLE speedChange)
{
if ( m_pSolver )
{
// UNDONE: project current velocity onto rescue velocity instead
// This will cause escapes to be slow - which is probably a good
// thing. That's probably a better heuristic than only rescuing once
// per PSI!
CPhysicsObject *pObject0 = static_cast<CPhysicsObject *>(ivp0->client_data);
CPhysicsObject *pObject1 = static_cast<CPhysicsObject *>(ivp1->client_data);
if ( pObject0 && pObject1 )
{
if ( (pObject0->CallbackFlags() & CALLBACK_MARKED_FOR_DELETE) ||
(pObject1->CallbackFlags() & CALLBACK_MARKED_FOR_DELETE) )
return;
// moveable object pair?
if ( pObject0->IsMoveable() && pObject1->IsMoveable() )
{
// only push each pair apart once per PSI
if ( CheckObjPair( ivp0, ivp1 ) )
return;
}
IVP_Environment *env = ivp0->get_environment();
float deltaTime = env->get_delta_PSI_time();
if ( !m_pSolver->ShouldSolvePenetration( pObject0, pObject1, pObject0->GetGameData(), pObject1->GetGameData(), deltaTime ) )
return;
}
else
{
return;
}
}
IVP_Anomaly_Manager::inter_penetration( mindist, ivp0, ivp1, speedChange );
}
// return true if object should be temp. freezed
virtual IVP_BOOL max_collisions_exceeded_check_freezing(IVP_Anomaly_Limits *, IVP_Core *pCore)
{
if ( m_pSolver )
{
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pCore->objects.element_at(0)->client_data);
return m_pSolver->ShouldFreezeObject( pObject ) ? IVP_TRUE : IVP_FALSE;
}
return IVP_TRUE;
}
// return number of additional checks to do this psi
virtual int max_collision_checks_exceeded( int totalChecks )
{
if ( m_pSolver )
{
return m_pSolver->AdditionalCollisionChecksThisTick( totalChecks );
}
return 0;
}
void max_velocity_exceeded(IVP_Anomaly_Limits *al, IVP_Core *pCore, IVP_U_Float_Point *velocity_in_out)
{
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pCore->objects.element_at(0)->client_data);
if ( pObject->GetShadowController() != NULL )
return;
IVP_Anomaly_Manager::max_velocity_exceeded(al, pCore, velocity_in_out);
}
IVP_BOOL max_contacts_exceeded_check_freezing( IVP_Core **pCoreList, int coreCount )
{
CUtlVector<IPhysicsObject *> list;
list.EnsureCapacity(coreCount);
for ( int i = 0; i < coreCount; i++ )
{
IVP_Core *pCore = pCoreList[i];
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(pCore->objects.element_at(0)->client_data);
list.AddToTail(pObject);
}
return m_pSolver->ShouldFreezeContacts( list.Base(), list.Count() ) ? IVP_TRUE : IVP_FALSE;
}
public:
void EventPSI( CPhysicsEnvironment * )
{
m_rescue.RemoveAll();
}
private:
struct realobjectpair_t
{
IVP_Real_Object *pObj0;
IVP_Real_Object *pObj1;
inline bool operator==( const realobjectpair_t &src ) const
{
return (pObj0 == src.pObj0) && (pObj1 == src.pObj1);
}
};
// basically each moveable object pair gets 1 rescue per PSI
// UNDONE: Add a counter to do more?
bool CheckObjPair( IVP_Real_Object *pObj0, IVP_Real_Object *pObj1 )
{
realobjectpair_t tmp;
tmp.pObj0 = pObj0 < pObj1 ? pObj0 : pObj1;
tmp.pObj1 = pObj0 > pObj1 ? pObj0 : pObj1;
if ( m_rescue.Find( tmp ) != m_rescue.InvalidIndex() )
return true;
m_rescue.AddToTail( tmp );
return false;
}
private:
IPhysicsCollisionSolver *m_pSolver;
// UNDONE: Linear search? should be small, but switch to rb tree if this ever gets large
CUtlVector<realobjectpair_t> m_rescue;
#if IVP_ENABLE_VISUALIZER
public:
CCollisionVisualizer *pVisualizer;
#endif
};
class CPhysicsListenerConstraint : public IVP_Listener_Constraint
{
public:
CPhysicsListenerConstraint()
{
m_pCallback = NULL;
}
void SetHandler( IPhysicsConstraintEvent *pHandler )
{
m_pCallback = pHandler;
}
void event_constraint_broken( IVP_Constraint *pConstraint )
{
// IVP_Constraint is not allowed, something is broken
Assert(0);
}
void event_constraint_broken( hk_Breakable_Constraint *pConstraint )
{
if ( m_pCallback )
{
IPhysicsConstraint *pObj = GetClientDataForHkConstraint( pConstraint );
m_pCallback->ConstraintBroken( pObj );
}
}
void event_constraint_broken( IPhysicsConstraint *pConstraint )
{
if ( m_pCallback )
{
m_pCallback->ConstraintBroken(pConstraint);
}
}
private:
IPhysicsConstraintEvent *m_pCallback;
};
#define AIR_DENSITY 2
class CDragController : public IVP_Controller_Independent
{
public:
CDragController( void )
{
m_airDensity = AIR_DENSITY;
}
virtual ~CDragController( void ) {}
virtual void do_simulation_controller(IVP_Event_Sim *event,IVP_U_Vector<IVP_Core> *core_list)
{
int i;
for( i = core_list->len()-1; i >=0; i--)
{
IVP_Core *pCore = core_list->element_at(i);
IVP_Real_Object *pivp = pCore->objects.element_at(0);
CPhysicsObject *pPhys = static_cast<CPhysicsObject *>(pivp->client_data);
float dragForce = -0.5 * pPhys->GetDragInDirection( pCore->speed ) * m_airDensity * event->delta_time;
if ( dragForce < -1.0f )
dragForce = -1.0f;
if ( dragForce < 0 )
{
IVP_U_Float_Point dragVelocity;
dragVelocity.set_multiple( &pCore->speed, dragForce );
pCore->speed.add( &dragVelocity );
}
float angDragForce = -pPhys->GetAngularDragInDirection( pCore->rot_speed ) * m_airDensity * event->delta_time;
if ( angDragForce < -1.0f )
angDragForce = -1.0f;
if ( angDragForce < 0 )
{
IVP_U_Float_Point angDragVelocity;
angDragVelocity.set_multiple( &pCore->rot_speed, angDragForce );
pCore->rot_speed.add( &angDragVelocity );
}
}
}
virtual const char *get_controller_name() { return "vphysics:drag"; }
virtual IVP_CONTROLLER_PRIORITY get_controller_priority()
{
return IVP_CP_MOTION;
}
float GetAirDensity() const { return m_airDensity; }
void SetAirDensity( float density ) { m_airDensity = density; }
private:
float m_airDensity;
};
//
// Default implementation of the debug overlay interface so that we never return NULL from GetDebugOverlay.
//
class CVPhysicsDebugOverlay : public IVPhysicsDebugOverlay
{
public:
virtual void AddEntityTextOverlay(int ent_index, int line_offset, float duration, int r, int g, int b, int a, const char *format, ...) {}
virtual void AddBoxOverlay(const Vector& origin, const Vector& mins, const Vector& max, QAngle const& orientation, int r, int g, int b, int a, float duration) {}
virtual void AddTriangleOverlay(const Vector& p1, const Vector& p2, const Vector& p3, int r, int g, int b, int a, bool noDepthTest, float duration) {}
virtual void AddLineOverlay(const Vector& origin, const Vector& dest, int r, int g, int b,bool noDepthTest, float duration) {}
virtual void AddTextOverlay(const Vector& origin, float duration, const char *format, ...) {}
virtual void AddTextOverlay(const Vector& origin, int line_offset, float duration, const char *format, ...) {}
virtual void AddScreenTextOverlay(float flXPos, float flYPos,float flDuration, int r, int g, int b, int a, const char *text) {}
virtual void AddSweptBoxOverlay(const Vector& start, const Vector& end, const Vector& mins, const Vector& max, const QAngle & angles, int r, int g, int b, int a, float flDuration) {}
virtual void AddTextOverlayRGB(const Vector& origin, int line_offset, float duration, float r, float g, float b, float alpha, const char *format, ...) {}
};
static CVPhysicsDebugOverlay s_DefaultDebugOverlay;
CPhysicsEnvironment::CPhysicsEnvironment( void )
// assume that these lists will have at least one object
{
// set this to true to force the
m_deleteQuick = false;
m_queueDeleteObject = false;
m_inSimulation = false;
m_fixedTimestep = true; // try to simulate using fixed timesteps
m_enableConstraintNotify = false;
// build a default environment
IVP_Environment_Manager *env_manager;
env_manager = IVP_Environment_Manager::get_environment_manager();
IVP_Application_Environment appl_env;
m_pCollisionSolver = new CCollisionSolver;
appl_env.collision_filter = m_pCollisionSolver;
appl_env.material_manager = physprops->GetIVPManager();
appl_env.anomaly_manager = m_pCollisionSolver;
// UNDONE: This would save another 45K of RAM on xbox, test perf
// if ( IsXbox() )
// {
// appl_env.n_cache_object = 128;
// }
BEGIN_IVP_ALLOCATION();
m_pPhysEnv = env_manager->create_environment( &appl_env, "JAY", 0xBEEF );
END_IVP_ALLOCATION();
// UNDONE: Revisit brush/terrain/object shrinking and tune this number to something larger
// UNDONE: Expose this to callers, also via physcollision
m_pPhysEnv->set_global_collision_tolerance( ConvertDistanceToIVP( g_PhysicsUnits.globalCollisionTolerance - 1e-4f ) ); // just under 1/4 inch tolerance
m_pSleepEvents = new CSleepObjects;
m_pDeleteQueue = new CDeleteQueue;
BEGIN_IVP_ALLOCATION();
m_pPhysEnv->add_listener_object_global( m_pSleepEvents );
END_IVP_ALLOCATION();
m_pCollisionListener = new CPhysicsListenerCollision;
BEGIN_IVP_ALLOCATION();
m_pPhysEnv->add_listener_collision_global( m_pCollisionListener );
END_IVP_ALLOCATION();
m_pConstraintListener = new CPhysicsListenerConstraint;
BEGIN_IVP_ALLOCATION();
m_pPhysEnv->add_listener_constraint_global( m_pConstraintListener );
END_IVP_ALLOCATION();
m_pDragController = new CDragController;
physics_performanceparams_t perf;
perf.Defaults();
SetPerformanceSettings( &perf );
m_pPhysEnv->client_data = (void *)this;
m_lastObjectThisTick = 0;
}
CPhysicsEnvironment::~CPhysicsEnvironment( void )
{
// no callbacks during shutdown
SetCollisionSolver( NULL );
m_pPhysEnv->remove_listener_object_global( m_pSleepEvents );
// don't bother waking up other objects as we clear them out
SetQuickDelete( true );
// delete/remove the listeners
m_pPhysEnv->remove_listener_collision_global( m_pCollisionListener );
delete m_pCollisionListener;
m_pPhysEnv->remove_listener_constraint_global( m_pConstraintListener );
delete m_pConstraintListener;
// Clean out the list of physics objects
for ( int i = m_objects.Count()-1; i >= 0; --i )
{
CPhysicsObject *pObject = static_cast<CPhysicsObject *>(m_objects[i]);
PhantomRemove( pObject );
delete pObject;
}
m_objects.RemoveAll();
ClearDeadObjects();
// Clean out the list of fluids
m_fluids.PurgeAndDeleteElements();
delete m_pSleepEvents;
delete m_pDragController;
delete m_pPhysEnv;
delete m_pDeleteQueue;
// must be deleted after the environment (calls back in destructor)
delete m_pCollisionSolver;
}
IPhysicsCollisionEvent *CPhysicsEnvironment::GetCollisionEventHandler()
{
return m_pCollisionListener->GetHandler();
}
void CPhysicsEnvironment::NotifyConstraintDisabled( IPhysicsConstraint *pConstraint )
{
if ( m_enableConstraintNotify )
{
m_pConstraintListener->event_constraint_broken( pConstraint );
}
}
void CPhysicsEnvironment::DebugCheckContacts(void)
{
if ( m_pSleepEvents )
{
m_pSleepEvents->DebugCheckContacts( m_pPhysEnv );
}
}
void CPhysicsEnvironment::SetDebugOverlay( CreateInterfaceFn debugOverlayFactory )
{
m_pDebugOverlay = NULL;
if (debugOverlayFactory)
{
m_pDebugOverlay = ( IVPhysicsDebugOverlay * )debugOverlayFactory( VPHYSICS_DEBUG_OVERLAY_INTERFACE_VERSION, NULL );
}
if (!m_pDebugOverlay)
{
m_pDebugOverlay = &s_DefaultDebugOverlay;
}
#if IVP_ENABLE_VISUALIZER
m_pCollisionSolver->pVisualizer = new CCollisionVisualizer( m_pDebugOverlay );
INSTALL_SHORTRANGE_CALLBACK(m_pCollisionSolver->pVisualizer);
INSTALL_LONGRANGE_CALLBACK(m_pCollisionSolver->pVisualizer);
#endif
}
IVPhysicsDebugOverlay *CPhysicsEnvironment::GetDebugOverlay( void )
{
return m_pDebugOverlay;
}
void CPhysicsEnvironment::SetGravity( const Vector& gravityVector )
{
IVP_U_Point gravity;
ConvertPositionToIVP( gravityVector, gravity );
m_pPhysEnv->set_gravity( &gravity );
// BUGBUG: global collision tolerance has a constant that depends on gravity.
m_pPhysEnv->set_global_collision_tolerance( m_pPhysEnv->get_global_collision_tolerance(), gravity.real_length() );
DevMsg(1,"Set Gravity %.1f (%.3f tolerance)\n", gravityVector.Length(), IVP2HL(m_pPhysEnv->get_global_collision_tolerance()) );
}
void CPhysicsEnvironment::GetGravity( Vector *pGravityVector ) const
{
const IVP_U_Point *gravity = m_pPhysEnv->get_gravity();
ConvertPositionToHL( *gravity, *pGravityVector );
}
IPhysicsObject *CPhysicsEnvironment::CreatePolyObject( const CPhysCollide *pCollisionModel, int materialIndex, const Vector& position, const QAngle& angles, objectparams_t *pParams )
{
IPhysicsObject *pObject = ::CreatePhysicsObject( this, pCollisionModel, materialIndex, position, angles, pParams, false );
if ( pObject )
{
m_objects.AddToTail( pObject );
}
return pObject;
}
IPhysicsObject *CPhysicsEnvironment::CreatePolyObjectStatic( const CPhysCollide *pCollisionModel, int materialIndex, const Vector& position, const QAngle& angles, objectparams_t *pParams )
{
IPhysicsObject *pObject = ::CreatePhysicsObject( this, pCollisionModel, materialIndex, position, angles, pParams, true );
if ( pObject )
{
m_objects.AddToTail( pObject );
}
return pObject;
}
unsigned int CPhysicsEnvironment::GetObjectSerializeSize( IPhysicsObject *pObject ) const
{
return sizeof(vphysics_save_cphysicsobject_t);
}
void CPhysicsEnvironment::SerializeObjectToBuffer( IPhysicsObject *pObject, unsigned char *pBuffer, unsigned int bufferSize )
{
CPhysicsObject *pPhysics = static_cast<CPhysicsObject *>(pObject);
if ( bufferSize >= sizeof(vphysics_save_cphysicsobject_t))
{
vphysics_save_cphysicsobject_t *pTemplate = reinterpret_cast<vphysics_save_cphysicsobject_t *>(pBuffer);
pPhysics->WriteToTemplate( *pTemplate );
}
}
IPhysicsObject *CPhysicsEnvironment::UnserializeObjectFromBuffer( void *pGameData, unsigned char *pBuffer, unsigned int bufferSize, bool enableCollisions )
{
IPhysicsObject *pObject = ::CreateObjectFromBuffer( this, pGameData, pBuffer, bufferSize, enableCollisions );
if ( pObject )
{
m_objects.AddToTail( pObject );
}
return pObject;
}
const IPhysicsObject **CPhysicsEnvironment::GetObjectList( int *pOutputObjectCount ) const
{
int iCount = m_objects.Count();
if( pOutputObjectCount )
*pOutputObjectCount = iCount;
if( iCount )
return (const IPhysicsObject **)m_objects.Base();
else
return NULL;
}
extern void ControlPhysicsShadowControllerAttachment_Silent( IPhysicsShadowController *pController, IVP_Real_Object *pivp, bool bAttach );
extern void ControlPhysicsPlayerControllerAttachment_Silent( IPhysicsPlayerController *pController, IVP_Real_Object *pivp, bool bAttach );
bool CPhysicsEnvironment::TransferObject( IPhysicsObject *pObject, IPhysicsEnvironment *pDestinationEnvironment )
{
int iIndex = m_objects.Find( pObject );
if( iIndex == -1 || (pObject->GetCallbackFlags() & CALLBACK_MARKED_FOR_DELETE ) )
return false;
CPhysicsObject *pPhysics = static_cast<CPhysicsObject *>(pObject);
//pPhysics->Wake();
//pPhysics->NotifyWake();
void *pGameData = pObject->GetGameData();
//Find any controllers attached to this object
IPhysicsShadowController *pController = pObject->GetShadowController();
IPhysicsPlayerController *pPlayerController = NULL;
if( (pObject->GetCallbackFlags() & CALLBACK_IS_PLAYER_CONTROLLER) != 0 )
{
pPlayerController = FindPlayerController( pObject );
}
//temporarily (and silently) detach any physics controllers we found because destroying the object would destroy them
if( pController )
{
//detach the controller from the object
((CPhysicsObject *)pObject)->m_pShadow = NULL;
IVP_Real_Object *pivp = ((CPhysicsObject *)pObject)->GetObject();
ControlPhysicsShadowControllerAttachment_Silent( pController, pivp, false );
}
else if( pPlayerController )
{
RemovePlayerController( pPlayerController );
pObject->SetCallbackFlags( pObject->GetCallbackFlags() & ~CALLBACK_IS_PLAYER_CONTROLLER );
IVP_Real_Object *pivp = ((CPhysicsObject *)pObject)->GetObject();
ControlPhysicsPlayerControllerAttachment_Silent( pPlayerController, pivp, false );
}
//templatize the object
vphysics_save_cphysicsobject_t objectTemplate;
memset( &objectTemplate, 0, sizeof( vphysics_save_cphysicsobject_t ) );
pPhysics->WriteToTemplate( objectTemplate );
//these should be detached already
Assert( objectTemplate.pShadow == NULL );
Assert( objectTemplate.hasShadowController == false );
//destroy the existing version of the object
m_objects.FastRemove( iIndex );
pPhysics->ForceSilentDelete();
m_pSleepEvents->DeleteObject( pPhysics );
pPhysics->CPhysicsObject::~CPhysicsObject();
//now recreate in place in the destination environment
CPhysicsEnvironment *pDest = static_cast<CPhysicsEnvironment *>(pDestinationEnvironment);
CreateObjectFromBuffer_UseExistingMemory( pDest, pGameData, (unsigned char *)&objectTemplate, sizeof(objectTemplate), pPhysics );
pDest->m_objects.AddToTail( pObject );
//even if this is going to sleep in a second, put it active right away to fix some object hitching problems
pPhysics->Wake();
pPhysics->NotifyWake();
/*int iActiveIndex = pDest->m_pSleepEvents->m_activeObjects.AddToTail( pPhysics );
pPhysics->SetActiveIndex( iActiveIndex );*/
pDest->m_pPhysEnv->force_psi_on_next_simulation(); //avoids an object pause
if( pController )
{
//re-attach the controller to the new object
((CPhysicsObject *)pObject)->m_pShadow = pController;
IVP_Real_Object *pivp = ((CPhysicsObject *)pObject)->GetObject();
ControlPhysicsShadowControllerAttachment_Silent( pController, pivp, true );
}
else if( pPlayerController )
{
IVP_Real_Object *pivp = ((CPhysicsObject *)pObject)->GetObject();
pObject->SetCallbackFlags( pObject->GetCallbackFlags() | CALLBACK_IS_PLAYER_CONTROLLER );
ControlPhysicsPlayerControllerAttachment_Silent( pPlayerController, pivp, true );
pDest->AddPlayerController( pPlayerController );
}
return true;
}
IPhysicsSpring *CPhysicsEnvironment::CreateSpring( IPhysicsObject *pObjectStart, IPhysicsObject *pObjectEnd, springparams_t *pParams )
{
return ::CreateSpring( m_pPhysEnv, static_cast<CPhysicsObject *>(pObjectStart), static_cast<CPhysicsObject *>(pObjectEnd), pParams );
}
IPhysicsFluidController *CPhysicsEnvironment::CreateFluidController( IPhysicsObject *pFluidObject, fluidparams_t *pParams )
{
CPhysicsFluidController *pFluid = ::CreateFluidController( m_pPhysEnv, static_cast<CPhysicsObject *>(pFluidObject), pParams );
m_fluids.AddToTail( pFluid );
return pFluid;
}
IPhysicsConstraint *CPhysicsEnvironment::CreateRagdollConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_ragdollparams_t &ragdoll )
{
return ::CreateRagdollConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, ragdoll );
}
IPhysicsConstraint *CPhysicsEnvironment::CreateHingeConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_hingeparams_t &hinge )
{
constraint_limitedhingeparams_t limitedhinge(hinge);
return ::CreateHingeConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, limitedhinge );
}
IPhysicsConstraint *CPhysicsEnvironment::CreateLimitedHingeConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_limitedhingeparams_t &hinge )
{
return ::CreateHingeConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, hinge );
}
IPhysicsConstraint *CPhysicsEnvironment::CreateFixedConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_fixedparams_t &fixed )
{
return ::CreateFixedConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, fixed );
}
IPhysicsConstraint *CPhysicsEnvironment::CreateSlidingConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_slidingparams_t &sliding )
{
return ::CreateSlidingConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, sliding );
}
IPhysicsConstraint *CPhysicsEnvironment::CreateBallsocketConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_ballsocketparams_t &ballsocket )
{
return ::CreateBallsocketConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, ballsocket );
}
IPhysicsConstraint *CPhysicsEnvironment::CreatePulleyConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_pulleyparams_t &pulley )
{
return ::CreatePulleyConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, pulley );
}
IPhysicsConstraint *CPhysicsEnvironment::CreateLengthConstraint( IPhysicsObject *pReferenceObject, IPhysicsObject *pAttachedObject, IPhysicsConstraintGroup *pGroup, const constraint_lengthparams_t &length )
{
return ::CreateLengthConstraint( m_pPhysEnv, (CPhysicsObject *)pReferenceObject, (CPhysicsObject *)pAttachedObject, pGroup, length );
}
IPhysicsConstraintGroup *CPhysicsEnvironment::CreateConstraintGroup( const constraint_groupparams_t &group )
{
return CreatePhysicsConstraintGroup( m_pPhysEnv, group );
}
void CPhysicsEnvironment::Simulate( float deltaTime )
{
LOCAL_THREAD_LOCK();
if ( !m_pPhysEnv )
return;
ClearDeadObjects();
#if DEBUG_CHECK_CONTATCTS_AUTO
m_pSleepEvents->DebugCheckContacts( m_pPhysEnv );
#endif
// save this to catch objects deleted without being simulated
m_lastObjectThisTick = m_objects.Count()-1;
// stop updating objects that went to sleep during the previous frame.
m_pSleepEvents->UpdateSleepObjects();
// Trap interrupts and clock changes
// don't simulate less than .1 ms
if ( deltaTime <= 1.0 && deltaTime > 0.0001 )
{
if ( deltaTime > 0.1 )
{
deltaTime = 0.1f;
}
m_pCollisionSolver->EventPSI( this );
m_pCollisionListener->EventPSI( this );
m_inSimulation = true;
BEGIN_IVP_ALLOCATION();
if ( !m_fixedTimestep || deltaTime != m_pPhysEnv->get_delta_PSI_time() )
{
m_fixedTimestep = false;
m_pPhysEnv->simulate_dtime( deltaTime );
}
else
{
m_pPhysEnv->simulate_time_step();
}
END_IVP_ALLOCATION();
m_inSimulation = false;
}
// If the queue is disabled, it's only used during simulation.
// Flush it as soon as possible (which is now)
if ( !m_queueDeleteObject )
{
ClearDeadObjects();
}
if ( m_pCollisionListener->GetHandler() )
{
m_pSleepEvents->ProcessActiveObjects( m_pPhysEnv, m_pCollisionListener->GetHandler() );
}
//visualize_collisions();
VirtualMeshPSI();
GetNextFrameTime();
}
void CPhysicsEnvironment::ResetSimulationClock()
{
// UNDONE: You'd think that all of this would make the system deterministic, but
// it doesn't.
extern void SeedRandomGenerators();
m_pPhysEnv->reset_time();
m_pPhysEnv->get_time_manager()->env_set_current_time( m_pPhysEnv, IVP_Time(0) );
m_pPhysEnv->reset_time();
m_fixedTimestep = true;
SeedRandomGenerators();
}
float CPhysicsEnvironment::GetSimulationTimestep( void ) const
{
return m_pPhysEnv->get_delta_PSI_time();
}
void CPhysicsEnvironment::SetSimulationTimestep( float timestep )
{
m_pPhysEnv->set_delta_PSI_time( timestep );
}
float CPhysicsEnvironment::GetSimulationTime( void ) const
{
return (float)m_pPhysEnv->get_current_time().get_time();
}
float CPhysicsEnvironment::GetNextFrameTime( void ) const
{
return (float)m_pPhysEnv->get_next_PSI_time().get_time();
}
// true if currently running the simulator (i.e. in a callback during physenv->Simulate())
bool CPhysicsEnvironment::IsInSimulation( void ) const
{
return m_inSimulation;
}
void CPhysicsEnvironment::DestroyObject( IPhysicsObject *pObject )
{
if ( !pObject )
{
DevMsg("Deleted NULL vphysics object\n");
return;
}
// search from the end because we usually delete the most recent objects during run time
int index = -1;
for ( int i = m_objects.Count(); --i >= 0; )
{
if ( m_objects[i] == pObject )
{
index = i;
break;
}
}
if ( index != -1 )
{
m_objects.FastRemove( index );
}
else
{
DevMsg(1,"error deleting physics object\n");
CPhysicsObject *pPhysics = static_cast<CPhysicsObject *>(pObject);
if ( pPhysics->GetCallbackFlags() & CALLBACK_MARKED_FOR_DELETE )
{
// deleted twice
Assert(0);
return;
}
// bad ptr?
Assert(0);
return;
}
CPhysicsObject *pPhysics = static_cast<CPhysicsObject *>(pObject);
// add this flag so we can optimize some cases
pPhysics->AddCallbackFlags( CALLBACK_MARKED_FOR_DELETE );
// was created/destroyed without simulating. No need to wake the neighbors!
if ( index > m_lastObjectThisTick )
{
pPhysics->ForceSilentDelete();
}
if ( m_inSimulation || m_queueDeleteObject )
{
// don't delete while simulating
m_deadObjects.AddToTail( pObject );
}
else
{
m_pSleepEvents->DeleteObject( pPhysics );
delete pObject;
}
}
void CPhysicsEnvironment::DestroySpring( IPhysicsSpring *pSpring )
{
delete pSpring;
}
void CPhysicsEnvironment::DestroyFluidController( IPhysicsFluidController *pFluid )
{
m_fluids.FindAndRemove( (CPhysicsFluidController *)pFluid );
delete pFluid;
}
void CPhysicsEnvironment::DestroyConstraint( IPhysicsConstraint *pConstraint )
{
if ( !m_deleteQuick && pConstraint )
{
IPhysicsObject *pObj0 = pConstraint->GetReferenceObject();
if ( pObj0 )
{
pObj0->Wake();
}
IPhysicsObject *pObj1 = pConstraint->GetAttachedObject();
if ( pObj1 )
{
pObj1->Wake();
}
}
if ( m_inSimulation )
{
pConstraint->Deactivate();
m_pDeleteQueue->QueueForDelete( pConstraint );
}
else
{
delete pConstraint;
}
}
void CPhysicsEnvironment::DestroyConstraintGroup( IPhysicsConstraintGroup *pGroup )
{
delete pGroup;
}
void CPhysicsEnvironment::TraceBox( trace_t *ptr, const Vector &mins, const Vector &maxs, const Vector &start, const Vector &end )
{
// UNDONE: Need this?
}
void CPhysicsEnvironment::SetCollisionSolver( IPhysicsCollisionSolver *pSolver )
{
m_pCollisionSolver->SetHandler( pSolver );
}
void CPhysicsEnvironment::ClearDeadObjects( void )
{
for ( int i = 0; i < m_deadObjects.Count(); i++ )
{
CPhysicsObject *pObject = (CPhysicsObject *)m_deadObjects.Element(i);
m_pSleepEvents->DeleteObject( pObject );
delete pObject;
}
m_deadObjects.Purge();
m_pDeleteQueue->DeleteAll();
}
void CPhysicsEnvironment::AddPlayerController( IPhysicsPlayerController *pController )
{
if ( m_playerControllers.Find(pController) != -1 )
{
Assert(0);
return;
}
m_playerControllers.AddToTail( pController );
}
void CPhysicsEnvironment::RemovePlayerController( IPhysicsPlayerController *pController )
{
m_playerControllers.FindAndRemove( pController );
}
IPhysicsPlayerController *CPhysicsEnvironment::FindPlayerController( IPhysicsObject *pPhysicsObject )
{
for ( int i = m_playerControllers.Count()-1; i >= 0; --i )
{
if ( m_playerControllers[i]->GetObject() == pPhysicsObject )
return m_playerControllers[i];
}
return NULL;
}
void CPhysicsEnvironment::SetCollisionEventHandler( IPhysicsCollisionEvent *pCollisionEvents )
{
m_pCollisionListener->SetHandler( pCollisionEvents );
}
void CPhysicsEnvironment::SetObjectEventHandler( IPhysicsObjectEvent *pObjectEvents )
{
m_pSleepEvents->SetHandler( pObjectEvents );
}
void CPhysicsEnvironment::SetConstraintEventHandler( IPhysicsConstraintEvent *pConstraintEvents )
{
m_pConstraintListener->SetHandler( pConstraintEvents );
}
IPhysicsShadowController *CPhysicsEnvironment::CreateShadowController( IPhysicsObject *pObject, bool allowTranslation, bool allowRotation )
{
return ::CreateShadowController( static_cast<CPhysicsObject*>(pObject), allowTranslation, allowRotation );
}
void CPhysicsEnvironment::DestroyShadowController( IPhysicsShadowController *pController )
{
delete pController;
}
IPhysicsPlayerController *CPhysicsEnvironment::CreatePlayerController( IPhysicsObject *pObject )
{
IPhysicsPlayerController *pController = ::CreatePlayerController( static_cast<CPhysicsObject*>(pObject) );
AddPlayerController( pController );
return pController;
}
void CPhysicsEnvironment::DestroyPlayerController( IPhysicsPlayerController *pController )
{
RemovePlayerController( pController );
::DestroyPlayerController( pController );
}
IPhysicsMotionController *CPhysicsEnvironment::CreateMotionController( IMotionEvent *pHandler )
{
return ::CreateMotionController( this, pHandler );
}
void CPhysicsEnvironment::DestroyMotionController( IPhysicsMotionController *pController )
{
delete pController;
}
IPhysicsVehicleController *CPhysicsEnvironment::CreateVehicleController( IPhysicsObject *pVehicleBodyObject, const vehicleparams_t &params, unsigned int nVehicleType, IPhysicsGameTrace *pGameTrace )
{
return ::CreateVehicleController( this, static_cast<CPhysicsObject*>(pVehicleBodyObject), params, nVehicleType, pGameTrace );
}
void CPhysicsEnvironment::DestroyVehicleController( IPhysicsVehicleController *pController )
{
delete pController;
}
int CPhysicsEnvironment::GetActiveObjectCount( void ) const
{
return m_pSleepEvents->GetActiveObjectCount();
}
void CPhysicsEnvironment::GetActiveObjects( IPhysicsObject **pOutputObjectList ) const
{
m_pSleepEvents->GetActiveObjects( pOutputObjectList );
}
void CPhysicsEnvironment::SetAirDensity( float density )
{
CDragController *pDrag = ((CDragController *)m_pDragController);
if ( pDrag )
{
pDrag->SetAirDensity( density );
}
}
float CPhysicsEnvironment::GetAirDensity( void ) const
{
const CDragController *pDrag = ((CDragController *)m_pDragController);
if ( pDrag )
{
return pDrag->GetAirDensity();
}
return 0;
}
void CPhysicsEnvironment::CleanupDeleteList()
{
ClearDeadObjects();
}
bool CPhysicsEnvironment::IsCollisionModelUsed( CPhysCollide *pCollide ) const
{
int i;
for ( i = m_deadObjects.Count()-1; i >= 0; --i )
{
if ( m_deadObjects[i]->GetCollide() == pCollide )
return true;
}
for ( i = m_objects.Count()-1; i >= 0; --i )
{
if ( m_objects[i]->GetCollide() == pCollide )
return true;
}
return false;
}
// manage phantoms
void CPhysicsEnvironment::PhantomAdd( CPhysicsObject *pObject )
{
IVP_Controller_Phantom *pPhantom = pObject->GetObject()->get_controller_phantom();
if ( pPhantom )
{
pPhantom->add_listener_phantom( m_pCollisionListener );
}
}
void CPhysicsEnvironment::PhantomRemove( CPhysicsObject *pObject )
{
IVP_Controller_Phantom *pPhantom = pObject->GetObject()->get_controller_phantom();
if ( pPhantom )
{
pPhantom->remove_listener_phantom( m_pCollisionListener );
}
}
//-------------------------------------
IPhysicsObject *CPhysicsEnvironment::CreateSphereObject( float radius, int materialIndex, const Vector& position, const QAngle& angles, objectparams_t *pParams, bool isStatic )
{
IPhysicsObject *pObject = ::CreatePhysicsSphere( this, radius, materialIndex, position, angles, pParams, isStatic );
m_objects.AddToTail( pObject );
return pObject;
}
void CPhysicsEnvironment::TraceRay( const Ray_t &ray, unsigned int fMask, IPhysicsTraceFilter *pTraceFilter, trace_t *pTrace )
{
}
void CPhysicsEnvironment::SweepCollideable( const CPhysCollide *pCollide, const Vector &vecAbsStart, const Vector &vecAbsEnd,
const QAngle &vecAngles, unsigned int fMask, IPhysicsTraceFilter *pTraceFilter, trace_t *pTrace )
{
}
void CPhysicsEnvironment::GetPerformanceSettings( physics_performanceparams_t *pOutput ) const
{
if ( !pOutput )
return;
IVP_Anomaly_Limits *limits = m_pPhysEnv->get_anomaly_limits();
if ( limits )
{
// UNDONE: Expose these values for tuning
pOutput->maxVelocity = ConvertDistanceToHL( limits->max_velocity );
pOutput->maxAngularVelocity = ConvertAngleToHL(limits->max_angular_velocity_per_psi) * m_pPhysEnv->get_inv_delta_PSI_time();
pOutput->maxCollisionsPerObjectPerTimestep = limits->max_collisions_per_psi;
pOutput->maxCollisionChecksPerTimestep = limits->max_collision_checks_per_psi;
pOutput->minFrictionMass = limits->min_friction_mass;
pOutput->maxFrictionMass = limits->max_friction_mass;
}
IVP_Range_Manager *range = m_pPhysEnv->get_range_manager();
if ( range )
{
pOutput->lookAheadTimeObjectsVsWorld = range->look_ahead_time_world;
pOutput->lookAheadTimeObjectsVsObject = range->look_ahead_time_intra;
}
}
void CPhysicsEnvironment::SetPerformanceSettings( const physics_performanceparams_t *pSettings )
{
if ( !pSettings )
return;
IVP_Anomaly_Limits *limits = m_pPhysEnv->get_anomaly_limits();
if ( limits )
{
// UNDONE: Expose these values for tuning
limits->max_velocity = ConvertDistanceToIVP( pSettings->maxVelocity );
limits->max_collisions_per_psi = pSettings->maxCollisionsPerObjectPerTimestep;
limits->max_collision_checks_per_psi = pSettings->maxCollisionChecksPerTimestep;
limits->max_angular_velocity_per_psi = ConvertAngleToIVP(pSettings->maxAngularVelocity) * m_pPhysEnv->get_delta_PSI_time();
limits->min_friction_mass = clamp(pSettings->minFrictionMass, 1.0f, VPHYSICS_MAX_MASS );
limits->max_friction_mass = clamp(pSettings->maxFrictionMass, 1.0f, VPHYSICS_MAX_MASS );
}
IVP_Range_Manager *range = m_pPhysEnv->get_range_manager();
if ( range )
{
range->look_ahead_time_world = pSettings->lookAheadTimeObjectsVsWorld;
range->look_ahead_time_intra = pSettings->lookAheadTimeObjectsVsObject;
}
}
// perf/cost statistics
void CPhysicsEnvironment::ReadStats( physics_stats_t *pOutput )
{
if ( !pOutput )
return;
IVP_Statistic_Manager *stats = m_pPhysEnv->get_statistic_manager();
if ( stats )
{
pOutput->maxRescueSpeed = ConvertDistanceToHL( stats->max_rescue_speed );
pOutput->maxSpeedGain = ConvertDistanceToHL( stats->max_speed_gain );
pOutput->impactSysNum = stats->impact_sys_num;
pOutput->impactCounter = stats->impact_counter;
pOutput->impactSumSys = stats->impact_sum_sys;
pOutput->impactHardRescueCount = stats->impact_hard_rescue_counter;
pOutput->impactRescueAfterCount = stats->impact_rescue_after_counter;
pOutput->impactDelayedCount = stats->impact_delayed_counter;
pOutput->impactCollisionChecks = stats->impact_coll_checks;
pOutput->impactStaticCount = stats->impact_unmov;
pOutput->totalEnergyDestroyed = stats->sum_energy_destr;
pOutput->collisionPairsTotal = stats->sum_of_mindists;
pOutput->collisionPairsCreated = stats->mindists_generated;
pOutput->collisionPairsDestroyed = stats->mindists_deleted;
pOutput->potentialCollisionsObjectVsObject = stats->range_intra_exceeded;
pOutput->potentialCollisionsObjectVsWorld = stats->range_world_exceeded;
pOutput->frictionEventsProcessed = stats->processed_fmindists;
}
}
void CPhysicsEnvironment::ClearStats()
{
IVP_Statistic_Manager *stats = m_pPhysEnv->get_statistic_manager();
if ( stats )
{
stats->clear_statistic();
}
}
void CPhysicsEnvironment::EnableConstraintNotify( bool bEnable )
{
m_enableConstraintNotify = bEnable;
}
IPhysicsEnvironment *CreatePhysicsEnvironment( void )
{
return new CPhysicsEnvironment;
}
// This wraps IVP_Collision_Filter_Exclusive_Pair since we're reusing it
// as a general void * pair hash and it's API implies that has something
// to do with collision detection
class CVoidPairHash : private IVP_Collision_Filter_Exclusive_Pair
{
public:
void AddPair( void *pObject0, void *pObject1 )
{
// disabled pairs are stored int the collision filter's hash
disable_collision_between_objects( (IVP_Real_Object *)pObject0, (IVP_Real_Object *)pObject1 );
}
void RemovePair( void *pObject0, void *pObject1 )
{
// enabling removes the stored hash pair
enable_collision_between_objects( (IVP_Real_Object *)pObject0, (IVP_Real_Object *)pObject1 );
}
bool HasPair( void *pObject0, void *pObject1 )
{
// If collision is enabled, the pair is NOT present, so invert the test here.
return check_objects_for_collision_detection( (IVP_Real_Object *)pObject0, (IVP_Real_Object *)pObject1 ) ? false : true;
}
};
class CObjectPairHash : public IPhysicsObjectPairHash
{
public:
CObjectPairHash()
{
m_pObjectHash = new IVP_VHash_Store(1024);
}
~CObjectPairHash()
{
delete m_pObjectHash;
}
// converts the void * stored in the hash to a list in the multilist
unsigned short HashToListIndex( void *pHash )
{
if ( !pHash )
return m_objectList.InvalidIndex();
uintp hash = (uintp)pHash;
// mask off the extra bit we added to avoid zeros
hash &= 0xFFFF;
return (unsigned short)hash;
}
// converts the list in the multilist to a void * we can put in the hash
void *ListIndexToHash( unsigned short listIndex )
{
unsigned int hash = (unsigned int)listIndex;
// set the high bit, so zero means "not there"
hash |= 0x80000000;
return (void *)(intp)hash;
}
// Lookup this object and get a multilist entry
unsigned short GetListForObject( void *pObject )
{
return HashToListIndex( m_pObjectHash->find_elem( pObject ) );
}
// new object, set up his list
void SetListForObject( void *pObject, unsigned short listIndex )
{
Assert( !m_pObjectHash->find_elem( pObject ) );
m_pObjectHash->add_elem( pObject, ListIndexToHash(listIndex) );
}
// last entry is gone, remove the object
void DestroyListForObject( void *pObject, unsigned short listIndex )
{
if ( m_objectList.IsValidList( listIndex ) )
{
m_objectList.DestroyList( listIndex );
m_pObjectHash->remove_elem( pObject );
}
}
// Add this object to the list of disabled objects
void AddToObjectList( void *pObject, void *pAdd )
{
unsigned short listIndex = GetListForObject( pObject );
if ( !m_objectList.IsValidList( listIndex ) )
{
listIndex = m_objectList.CreateList();
SetListForObject( pObject, listIndex );
}
m_objectList.AddToTail( listIndex, pAdd );
}
// Remove one object from a particular object's list (linear time)
void RemoveFromObjectList( void *pObject, void *pRemove )
{
unsigned short listIndex = GetListForObject( pObject );
if ( !m_objectList.IsValidList( listIndex ) )
return;
for ( unsigned short item = m_objectList.Head(listIndex); item != m_objectList.InvalidIndex(); item = m_objectList.Next(item) )
{
if ( m_objectList[item] == pRemove )
{
// found it, remove
m_objectList.Remove( listIndex, item );
if ( m_objectList.Head(listIndex) == m_objectList.InvalidIndex() )
{
DestroyListForObject( pObject, listIndex );
}
return;
}
}
}
// add a pair (constant time)
virtual void AddObjectPair( void *pObject0, void *pObject1 )
{
if ( IsObjectPairInHash(pObject0,pObject1) )
return;
// add the pair to the hash
m_pairHash.AddPair( pObject0, pObject1 );
AddToObjectList( pObject0, pObject1 );
AddToObjectList( pObject1, pObject0 );
}
// remove a pair (linear time x 2)
virtual void RemoveObjectPair( void *pObject0, void *pObject1 )
{
if ( !IsObjectPairInHash(pObject0,pObject1) )
return;
// remove the pair from the hash
m_pairHash.RemovePair( pObject0, pObject1 );
RemoveFromObjectList( pObject0, pObject1 );
RemoveFromObjectList( pObject1, pObject0 );
}
// check for pair presence (fast constant time)
virtual bool IsObjectPairInHash( void *pObject0, void *pObject1 )
{
return m_pairHash.HasPair( pObject0, pObject1 );
}
virtual void RemoveAllPairsForObject( void *pObject )
{
unsigned short listIndex = GetListForObject( pObject );
if ( !m_objectList.IsValidList( listIndex ) )
return;
unsigned short item = m_objectList.Head(listIndex);
while ( item != m_objectList.InvalidIndex() )
{
unsigned short next = m_objectList.Next(item);
void *pOther = m_objectList[item];
m_objectList.Remove( listIndex, item );
// remove the matching entry
RemoveFromObjectList( pOther, pObject );
m_pairHash.RemovePair( pOther, pObject );
item = next;
}
DestroyListForObject( pObject, listIndex );
}
// Gets the # of dependencies for a particular entity
virtual int GetPairCountForObject( void *pObject0 )
{
unsigned short listIndex = GetListForObject( pObject0 );
if ( !m_objectList.IsValidList( listIndex ) )
return 0;
int nCount = 0;
unsigned short item;
for ( item = m_objectList.Head(listIndex); item != m_objectList.InvalidIndex();
item = m_objectList.Next(item) )
{
++nCount;
}
return nCount;
}
// Gets all dependencies for a particular entity
virtual int GetPairListForObject( void *pObject0, int nMaxCount, void **ppObjectList )
{
unsigned short listIndex = GetListForObject( pObject0 );
if ( !m_objectList.IsValidList( listIndex ) )
return 0;
int nCount = 0;
unsigned short item;
for ( item = m_objectList.Head(listIndex); item != m_objectList.InvalidIndex();
item = m_objectList.Next(item) )
{
ppObjectList[nCount] = m_objectList[item];
if ( ++nCount >= nMaxCount )
break;
}
return nCount;
}
virtual bool IsObjectInHash( void *pObject0 )
{
return m_pObjectHash->find_elem(pObject0) != NULL ? true : false;
}
#if 0
virtual int CountObjectsInHash()
{
return m_pObjectHash->n_elems();
}
#endif
private:
// this is a hash of object pairs
CVoidPairHash m_pairHash;
// this is a hash of pObjects with each element storing an index to the head of its list of disabled collisions
IVP_VHash_Store *m_pObjectHash;
// this is the list of disabled collisions for each object. Uses multilist
CUtlMultiList<void *, unsigned short> m_objectList;
};
IPhysicsObjectPairHash *CreateObjectPairHash()
{
return new CObjectPairHash;
}
Reference in New Issue View Git Blame Copy Permalink