2229 lines
66 KiB
C++
2229 lines
66 KiB
C++
//========= 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_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"
|
|
#include "ivp_mindist_intern.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() {}
|
|
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 ¶ms, 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();
|
|
|
|
unsigned int hash = (unsigned int)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 *)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;
|
|
}
|