1423 lines
46 KiB
C++
1423 lines
46 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "collisionproperty.h"
|
|
#include "igamesystem.h"
|
|
#include "utlvector.h"
|
|
#include "tier0/threadtools.h"
|
|
#include "tier0/tslist.h"
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
#include "c_baseentity.h"
|
|
#include "c_baseanimating.h"
|
|
#include "recvproxy.h"
|
|
|
|
#else
|
|
|
|
#include "baseentity.h"
|
|
#include "baseanimating.h"
|
|
#include "sendproxy.h"
|
|
#include "hierarchy.h"
|
|
#endif
|
|
|
|
#include "predictable_entity.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// KD tree query callbacks
|
|
//-----------------------------------------------------------------------------
|
|
class CDirtySpatialPartitionEntityList : public CAutoGameSystem, public IPartitionQueryCallback
|
|
{
|
|
public:
|
|
CDirtySpatialPartitionEntityList( char const *name );
|
|
|
|
// Members of IGameSystem
|
|
virtual bool Init();
|
|
virtual void Shutdown();
|
|
virtual void LevelShutdownPostEntity();
|
|
|
|
// Members of IPartitionQueryCallback
|
|
virtual void OnPreQuery_V1() { Assert( 0 ); }
|
|
virtual void OnPreQuery( SpatialPartitionListMask_t listMask );
|
|
virtual void OnPostQuery( SpatialPartitionListMask_t listMask );
|
|
|
|
void AddEntity( CBaseEntity *pEntity );
|
|
|
|
~CDirtySpatialPartitionEntityList();
|
|
void LockPartitionForRead()
|
|
{
|
|
if ( m_readLockCount == 0 )
|
|
{
|
|
m_partitionMutex.LockForRead();
|
|
}
|
|
m_readLockCount++;
|
|
}
|
|
void UnlockPartitionForRead()
|
|
{
|
|
m_readLockCount--;
|
|
if ( m_readLockCount == 0 )
|
|
{
|
|
m_partitionMutex.UnlockRead();
|
|
}
|
|
}
|
|
|
|
|
|
private:
|
|
CTSListWithFreeList<CBaseHandle> m_DirtyEntities;
|
|
CThreadSpinRWLock m_partitionMutex;
|
|
uint32 m_partitionWriteId;
|
|
CThreadLocalInt<> m_readLockCount;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Singleton instance
|
|
//-----------------------------------------------------------------------------
|
|
static CDirtySpatialPartitionEntityList s_DirtyKDTree( "CDirtySpatialPartitionEntityList" );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Force spatial partition updates (to avoid threading problems caused by lazy update)
|
|
//-----------------------------------------------------------------------------
|
|
void UpdateDirtySpatialPartitionEntities()
|
|
{
|
|
SpatialPartitionListMask_t listMask;
|
|
#ifdef CLIENT_DLL
|
|
listMask = PARTITION_CLIENT_GAME_EDICTS;
|
|
#else
|
|
listMask = PARTITION_SERVER_GAME_EDICTS;
|
|
#endif
|
|
s_DirtyKDTree.OnPreQuery( listMask );
|
|
s_DirtyKDTree.OnPostQuery( listMask );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CDirtySpatialPartitionEntityList::CDirtySpatialPartitionEntityList( char const *name ) : CAutoGameSystem( name )
|
|
{
|
|
m_DirtyEntities.Purge();
|
|
m_readLockCount = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Deconstructor.
|
|
//-----------------------------------------------------------------------------
|
|
CDirtySpatialPartitionEntityList::~CDirtySpatialPartitionEntityList()
|
|
{
|
|
m_DirtyEntities.Purge();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Initialization, shutdown
|
|
//-----------------------------------------------------------------------------
|
|
bool CDirtySpatialPartitionEntityList::Init()
|
|
{
|
|
::partition->InstallQueryCallback( this );
|
|
return true;
|
|
}
|
|
|
|
void CDirtySpatialPartitionEntityList::Shutdown()
|
|
{
|
|
::partition->RemoveQueryCallback( this );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Makes sure all entries in the KD tree are in the correct position
|
|
//-----------------------------------------------------------------------------
|
|
void CDirtySpatialPartitionEntityList::AddEntity( CBaseEntity *pEntity )
|
|
{
|
|
m_DirtyEntities.PushItem( pEntity->GetRefEHandle() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Members of IGameSystem
|
|
//-----------------------------------------------------------------------------
|
|
void CDirtySpatialPartitionEntityList::LevelShutdownPostEntity()
|
|
{
|
|
m_DirtyEntities.RemoveAll();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Makes sure all entries in the KD tree are in the correct position
|
|
//-----------------------------------------------------------------------------
|
|
void CDirtySpatialPartitionEntityList::OnPreQuery( SpatialPartitionListMask_t listMask )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
const int validMask = PARTITION_CLIENT_GAME_EDICTS;
|
|
#else
|
|
const int validMask = PARTITION_SERVER_GAME_EDICTS;
|
|
#endif
|
|
|
|
if ( !( listMask & validMask ) )
|
|
return;
|
|
|
|
if ( m_partitionWriteId != 0 && m_partitionWriteId == ThreadGetCurrentId() )
|
|
return;
|
|
|
|
#ifdef CLIENT_DLL
|
|
// FIXME: This should really be an assertion... feh!
|
|
if ( !C_BaseEntity::IsAbsRecomputationsEnabled() )
|
|
{
|
|
LockPartitionForRead();
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
// if you're holding a read lock, then these are entities that were still dirty after your trace started
|
|
// or became dirty due to some other thread or callback. Updating them may cause corruption further up the
|
|
// stack (e.g. partition iterator). Ignoring the state change should be safe since it happened after the
|
|
// trace was requested or was unable to be resolved in a previous attempt (still dirty).
|
|
if ( m_DirtyEntities.Count() && !m_readLockCount )
|
|
{
|
|
CUtlVector< CBaseHandle > vecStillDirty;
|
|
m_partitionMutex.LockForWrite();
|
|
m_partitionWriteId = ThreadGetCurrentId();
|
|
CTSListWithFreeList<CBaseHandle>::Node_t *pCurrent, *pNext;
|
|
while ( ( pCurrent = m_DirtyEntities.Detach() ) != NULL )
|
|
{
|
|
while ( pCurrent )
|
|
{
|
|
CBaseHandle handle = pCurrent->elem;
|
|
pNext = (CTSListWithFreeList<CBaseHandle>::Node_t *)pCurrent->Next;
|
|
m_DirtyEntities.FreeNode( pCurrent );
|
|
pCurrent = pNext;
|
|
|
|
#ifndef CLIENT_DLL
|
|
CBaseEntity *pEntity = gEntList.GetBaseEntity( handle );
|
|
#else
|
|
CBaseEntity *pEntity = cl_entitylist->GetBaseEntityFromHandle( handle );
|
|
#endif
|
|
|
|
if ( pEntity )
|
|
{
|
|
// If an entity is in the middle of bone setup, don't call UpdatePartition
|
|
// which can cause it to redo bone setup on the same frame causing a recursive
|
|
// call to bone setup.
|
|
if ( !pEntity->IsEFlagSet( EFL_SETTING_UP_BONES ) )
|
|
{
|
|
pEntity->CollisionProp()->UpdatePartition();
|
|
}
|
|
else
|
|
{
|
|
vecStillDirty.AddToTail( handle );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( vecStillDirty.Count() > 0 )
|
|
{
|
|
for ( int i = 0; i < vecStillDirty.Count(); i++ )
|
|
{
|
|
m_DirtyEntities.PushItem( vecStillDirty[i] );
|
|
}
|
|
}
|
|
m_partitionWriteId = 0;
|
|
m_partitionMutex.UnlockWrite();
|
|
}
|
|
LockPartitionForRead();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Makes sure all entries in the KD tree are in the correct position
|
|
//-----------------------------------------------------------------------------
|
|
void CDirtySpatialPartitionEntityList::OnPostQuery( SpatialPartitionListMask_t listMask )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
if ( !( listMask & PARTITION_CLIENT_GAME_EDICTS ) )
|
|
return;
|
|
#else
|
|
if ( !( listMask & PARTITION_SERVER_GAME_EDICTS ) )
|
|
return;
|
|
#endif
|
|
|
|
if ( m_partitionWriteId != 0 )
|
|
return;
|
|
|
|
UnlockPartitionForRead();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Save/load
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef CLIENT_DLL
|
|
|
|
BEGIN_DATADESC_NO_BASE( CCollisionProperty )
|
|
|
|
// DEFINE_FIELD( m_pOuter, FIELD_CLASSPTR ),
|
|
DEFINE_GLOBAL_FIELD( m_vecMinsPreScaled, FIELD_VECTOR ),
|
|
DEFINE_GLOBAL_FIELD( m_vecMaxsPreScaled, FIELD_VECTOR ),
|
|
DEFINE_GLOBAL_FIELD( m_vecMins, FIELD_VECTOR ),
|
|
DEFINE_GLOBAL_FIELD( m_vecMaxs, FIELD_VECTOR ),
|
|
DEFINE_KEYFIELD( m_nSolidType, FIELD_CHARACTER, "solid" ),
|
|
DEFINE_FIELD( m_usSolidFlags, FIELD_SHORT ),
|
|
DEFINE_FIELD( m_nSurroundType, FIELD_CHARACTER ),
|
|
DEFINE_FIELD( m_flRadius, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_triggerBloat, FIELD_CHARACTER ),
|
|
DEFINE_FIELD( m_vecSpecifiedSurroundingMinsPreScaled, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_vecSpecifiedSurroundingMaxsPreScaled, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_vecSpecifiedSurroundingMins, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_vecSpecifiedSurroundingMaxs, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_vecSurroundingMins, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_vecSurroundingMaxs, FIELD_VECTOR ),
|
|
// DEFINE_FIELD( m_Partition, FIELD_SHORT ),
|
|
// DEFINE_PHYSPTR( m_pPhysicsObject ),
|
|
|
|
END_DATADESC()
|
|
|
|
#else
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Prediction
|
|
//-----------------------------------------------------------------------------
|
|
BEGIN_PREDICTION_DATA_NO_BASE( CCollisionProperty )
|
|
|
|
DEFINE_PRED_FIELD( m_vecMinsPreScaled, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_vecMaxsPreScaled, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_vecMins, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_vecMaxs, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_nSolidType, FIELD_CHARACTER, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_usSolidFlags, FIELD_SHORT, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_triggerBloat, FIELD_CHARACTER, FTYPEDESC_INSENDTABLE ),
|
|
|
|
END_PREDICTION_DATA()
|
|
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Networking
|
|
//-----------------------------------------------------------------------------
|
|
#ifdef CLIENT_DLL
|
|
|
|
static void RecvProxy_Solid( const CRecvProxyData *pData, void *pStruct, void *pOut )
|
|
{
|
|
((CCollisionProperty*)pStruct)->SetSolid( (SolidType_t)pData->m_Value.m_Int );
|
|
}
|
|
|
|
static void RecvProxy_SolidFlags( const CRecvProxyData *pData, void *pStruct, void *pOut )
|
|
{
|
|
((CCollisionProperty*)pStruct)->SetSolidFlags( pData->m_Value.m_Int );
|
|
}
|
|
|
|
static void RecvProxy_OBBMinsPreScaled( const CRecvProxyData *pData, void *pStruct, void *pOut )
|
|
{
|
|
CCollisionProperty *pProp = ((CCollisionProperty*)pStruct);
|
|
Vector &vecMins = *((Vector*)pData->m_Value.m_Vector);
|
|
pProp->SetCollisionBounds( vecMins, pProp->OBBMaxsPreScaled() );
|
|
}
|
|
|
|
static void RecvProxy_OBBMaxsPreScaled( const CRecvProxyData *pData, void *pStruct, void *pOut )
|
|
{
|
|
CCollisionProperty *pProp = ((CCollisionProperty*)pStruct);
|
|
Vector &vecMaxs = *((Vector*)pData->m_Value.m_Vector);
|
|
pProp->SetCollisionBounds( pProp->OBBMinsPreScaled(), vecMaxs );
|
|
}
|
|
|
|
static void RecvProxy_VectorDirtySurround( const CRecvProxyData *pData, void *pStruct, void *pOut )
|
|
{
|
|
Vector &vecold = *((Vector*)pOut);
|
|
Vector vecnew( pData->m_Value.m_Vector[0], pData->m_Value.m_Vector[1], pData->m_Value.m_Vector[2] );
|
|
|
|
if ( vecold != vecnew )
|
|
{
|
|
vecold = vecnew;
|
|
((CCollisionProperty*)pStruct)->MarkSurroundingBoundsDirty();
|
|
}
|
|
}
|
|
|
|
static void RecvProxy_IntDirtySurround( const CRecvProxyData *pData, void *pStruct, void *pOut )
|
|
{
|
|
if ( *((unsigned char*)pOut) != pData->m_Value.m_Int )
|
|
{
|
|
*((unsigned char*)pOut) = pData->m_Value.m_Int;
|
|
((CCollisionProperty*)pStruct)->MarkSurroundingBoundsDirty();
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
static void SendProxy_Solid( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID )
|
|
{
|
|
pOut->m_Int = ((CCollisionProperty*)pStruct)->GetSolid();
|
|
}
|
|
|
|
static void SendProxy_SolidFlags( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID )
|
|
{
|
|
pOut->m_Int = ((CCollisionProperty*)pStruct)->GetSolidFlags();
|
|
}
|
|
|
|
#endif
|
|
|
|
BEGIN_NETWORK_TABLE_NOBASE( CCollisionProperty, DT_CollisionProperty )
|
|
|
|
#ifdef CLIENT_DLL
|
|
RecvPropVector( RECVINFO(m_vecMinsPreScaled), 0, RecvProxy_OBBMinsPreScaled ),
|
|
RecvPropVector( RECVINFO(m_vecMaxsPreScaled), 0, RecvProxy_OBBMaxsPreScaled ),
|
|
RecvPropVector( RECVINFO(m_vecMins), 0 ),
|
|
RecvPropVector( RECVINFO(m_vecMaxs), 0 ),
|
|
RecvPropInt( RECVINFO( m_nSolidType ), 0, RecvProxy_Solid ),
|
|
RecvPropInt( RECVINFO( m_usSolidFlags ), 0, RecvProxy_SolidFlags ),
|
|
RecvPropInt( RECVINFO(m_nSurroundType), 0, RecvProxy_IntDirtySurround ),
|
|
RecvPropInt( RECVINFO(m_triggerBloat), 0, RecvProxy_IntDirtySurround ),
|
|
RecvPropVector( RECVINFO(m_vecSpecifiedSurroundingMinsPreScaled), 0, RecvProxy_VectorDirtySurround ),
|
|
RecvPropVector( RECVINFO(m_vecSpecifiedSurroundingMaxsPreScaled), 0, RecvProxy_VectorDirtySurround ),
|
|
RecvPropVector( RECVINFO(m_vecSpecifiedSurroundingMins), 0, RecvProxy_VectorDirtySurround ),
|
|
RecvPropVector( RECVINFO(m_vecSpecifiedSurroundingMaxs), 0, RecvProxy_VectorDirtySurround ),
|
|
#else
|
|
SendPropVector( SENDINFO(m_vecMinsPreScaled), 0, SPROP_NOSCALE),
|
|
SendPropVector( SENDINFO(m_vecMaxsPreScaled), 0, SPROP_NOSCALE),
|
|
SendPropVector( SENDINFO(m_vecMins), 0, SPROP_NOSCALE),
|
|
SendPropVector( SENDINFO(m_vecMaxs), 0, SPROP_NOSCALE),
|
|
SendPropInt( SENDINFO( m_nSolidType ), 3, SPROP_UNSIGNED, SendProxy_Solid ),
|
|
SendPropInt( SENDINFO( m_usSolidFlags ), FSOLID_MAX_BITS, SPROP_UNSIGNED, SendProxy_SolidFlags ),
|
|
SendPropInt( SENDINFO( m_nSurroundType ), SURROUNDING_TYPE_BIT_COUNT, SPROP_UNSIGNED ),
|
|
SendPropInt( SENDINFO(m_triggerBloat), 0, SPROP_UNSIGNED),
|
|
SendPropVector( SENDINFO(m_vecSpecifiedSurroundingMinsPreScaled), 0, SPROP_NOSCALE),
|
|
SendPropVector( SENDINFO(m_vecSpecifiedSurroundingMaxsPreScaled), 0, SPROP_NOSCALE),
|
|
SendPropVector( SENDINFO(m_vecSpecifiedSurroundingMins), 0, SPROP_NOSCALE),
|
|
SendPropVector( SENDINFO(m_vecSpecifiedSurroundingMaxs), 0, SPROP_NOSCALE),
|
|
#endif
|
|
|
|
END_NETWORK_TABLE()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
CCollisionProperty::CCollisionProperty()
|
|
{
|
|
m_Partition = PARTITION_INVALID_HANDLE;
|
|
Init( NULL );
|
|
}
|
|
|
|
CCollisionProperty::~CCollisionProperty()
|
|
{
|
|
DestroyPartitionHandle();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Initialization
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::Init( CBaseEntity *pEntity )
|
|
{
|
|
m_pOuter = pEntity;
|
|
m_vecMinsPreScaled.GetForModify().Init();
|
|
m_vecMaxsPreScaled.GetForModify().Init();
|
|
m_vecMins.GetForModify().Init();
|
|
m_vecMaxs.GetForModify().Init();
|
|
m_flRadius = 0.0f;
|
|
m_triggerBloat = 0;
|
|
m_usSolidFlags = 0;
|
|
m_nSolidType = SOLID_NONE;
|
|
|
|
// NOTE: This replicates previous behavior; we may always want to use BEST_COLLISION_BOUNDS
|
|
m_nSurroundType = USE_OBB_COLLISION_BOUNDS;
|
|
m_vecSurroundingMins = vec3_origin;
|
|
m_vecSurroundingMaxs = vec3_origin;
|
|
m_vecSpecifiedSurroundingMinsPreScaled.GetForModify().Init();
|
|
m_vecSpecifiedSurroundingMaxsPreScaled.GetForModify().Init();
|
|
m_vecSpecifiedSurroundingMins.GetForModify().Init();
|
|
m_vecSpecifiedSurroundingMaxs.GetForModify().Init();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// EntityHandle
|
|
//-----------------------------------------------------------------------------
|
|
IHandleEntity *CCollisionProperty::GetEntityHandle()
|
|
{
|
|
return m_pOuter;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Collision group
|
|
//-----------------------------------------------------------------------------
|
|
int CCollisionProperty::GetCollisionGroup() const
|
|
{
|
|
return m_pOuter->GetCollisionGroup();
|
|
}
|
|
|
|
|
|
bool CCollisionProperty::ShouldTouchTrigger( int triggerSolidFlags ) const
|
|
{
|
|
// debris only touches certain triggers
|
|
if ( GetCollisionGroup() == COLLISION_GROUP_DEBRIS )
|
|
{
|
|
if ( triggerSolidFlags & FSOLID_TRIGGER_TOUCH_DEBRIS )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
// triggers don't touch other triggers (might be solid to other ents as well as trigger)
|
|
if ( IsSolidFlagSet( FSOLID_TRIGGER ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
const matrix3x4_t *CCollisionProperty::GetRootParentToWorldTransform() const
|
|
{
|
|
if ( IsSolidFlagSet( FSOLID_ROOT_PARENT_ALIGNED ) )
|
|
{
|
|
CBaseEntity *pEntity = m_pOuter->GetRootMoveParent();
|
|
Assert(pEntity);
|
|
if ( pEntity )
|
|
{
|
|
return &pEntity->CollisionProp()->CollisionToWorldTransform();
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// IClientUnknown
|
|
//-----------------------------------------------------------------------------
|
|
IClientUnknown* CCollisionProperty::GetIClientUnknown()
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
return m_pOuter->GetIClientUnknown();
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Check for untouch
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::CheckForUntouch()
|
|
{
|
|
#ifndef CLIENT_DLL
|
|
if ( !IsSolid() && !IsSolidFlagSet(FSOLID_TRIGGER))
|
|
{
|
|
// If this ent's touch list isn't empty, it's transitioning to not solid
|
|
if ( m_pOuter->IsCurrentlyTouching() )
|
|
{
|
|
// mark ent so that at the end of frame it will check to
|
|
// see if it's no longer touching ents
|
|
m_pOuter->SetCheckUntouch( true );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the solid type
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::SetSolid( SolidType_t val )
|
|
{
|
|
if ( m_nSolidType == val )
|
|
return;
|
|
|
|
#ifndef CLIENT_DLL
|
|
bool bWasNotSolid = IsSolid();
|
|
#endif
|
|
|
|
MarkSurroundingBoundsDirty();
|
|
|
|
// OBB is not yet implemented
|
|
if ( val == SOLID_BSP )
|
|
{
|
|
if ( GetOuter()->GetMoveParent() )
|
|
{
|
|
if ( GetOuter()->GetRootMoveParent()->GetSolid() != SOLID_BSP )
|
|
{
|
|
// must be SOLID_VPHYSICS because parent might rotate
|
|
val = SOLID_VPHYSICS;
|
|
}
|
|
}
|
|
#ifndef CLIENT_DLL
|
|
// UNDONE: This should be fine in the client DLL too. Move GetAllChildren() into shared code.
|
|
// If the root of the hierarchy is SOLID_BSP, then assume that the designer
|
|
// wants the collisions to rotate with this hierarchy so that the player can
|
|
// move while riding the hierarchy.
|
|
if ( !GetOuter()->GetMoveParent() )
|
|
{
|
|
// NOTE: This assumes things don't change back from SOLID_BSP
|
|
// NOTE: This is 100% true for HL2 - need to support removing the flag to support changing from SOLID_BSP
|
|
CUtlVector<CBaseEntity *> list;
|
|
GetAllChildren( GetOuter(), list );
|
|
for ( int i = list.Count()-1; i>=0; --i )
|
|
{
|
|
list[i]->AddSolidFlags( FSOLID_ROOT_PARENT_ALIGNED );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
m_nSolidType = val;
|
|
|
|
#ifndef CLIENT_DLL
|
|
m_pOuter->CollisionRulesChanged();
|
|
|
|
UpdateServerPartitionMask( );
|
|
|
|
if ( bWasNotSolid != IsSolid() )
|
|
{
|
|
CheckForUntouch();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
SolidType_t CCollisionProperty::GetSolid() const
|
|
{
|
|
return (SolidType_t)m_nSolidType.Get();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the solid flags
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::SetSolidFlags( int flags )
|
|
{
|
|
int oldFlags = m_usSolidFlags;
|
|
m_usSolidFlags = (unsigned short)(flags & 0xFFFF);
|
|
if ( oldFlags == m_usSolidFlags )
|
|
return;
|
|
|
|
// These two flags, if changed, can produce different surrounding bounds
|
|
if ( (oldFlags & (FSOLID_FORCE_WORLD_ALIGNED | FSOLID_USE_TRIGGER_BOUNDS)) !=
|
|
(m_usSolidFlags & (FSOLID_FORCE_WORLD_ALIGNED | FSOLID_USE_TRIGGER_BOUNDS)) )
|
|
{
|
|
MarkSurroundingBoundsDirty();
|
|
}
|
|
|
|
if ( (oldFlags & (FSOLID_NOT_SOLID|FSOLID_TRIGGER)) != (m_usSolidFlags & (FSOLID_NOT_SOLID|FSOLID_TRIGGER)) )
|
|
{
|
|
m_pOuter->CollisionRulesChanged();
|
|
}
|
|
|
|
#ifndef CLIENT_DLL
|
|
if ( (oldFlags & (FSOLID_NOT_SOLID | FSOLID_TRIGGER)) != (m_usSolidFlags & (FSOLID_NOT_SOLID | FSOLID_TRIGGER)) )
|
|
{
|
|
UpdateServerPartitionMask( );
|
|
CheckForUntouch();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Coordinate system of the collision model
|
|
//-----------------------------------------------------------------------------
|
|
const Vector& CCollisionProperty::GetCollisionOrigin() const
|
|
{
|
|
return m_pOuter->GetAbsOrigin();
|
|
}
|
|
|
|
const QAngle& CCollisionProperty::GetCollisionAngles() const
|
|
{
|
|
if ( IsBoundsDefinedInEntitySpace() )
|
|
{
|
|
return m_pOuter->GetAbsAngles();
|
|
}
|
|
|
|
return vec3_angle;
|
|
}
|
|
|
|
const matrix3x4_t& CCollisionProperty::CollisionToWorldTransform() const
|
|
{
|
|
static matrix3x4_t s_matTemp[4];
|
|
static int s_nIndex = 0;
|
|
|
|
matrix3x4_t &matResult = s_matTemp[s_nIndex];
|
|
s_nIndex = (s_nIndex+1) & 0x3;
|
|
|
|
if ( IsBoundsDefinedInEntitySpace() )
|
|
{
|
|
return m_pOuter->EntityToWorldTransform();
|
|
}
|
|
|
|
SetIdentityMatrix( matResult );
|
|
MatrixSetColumn( GetCollisionOrigin(), 3, matResult );
|
|
return matResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the collision bounds + the size
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::SetCollisionBounds( const Vector &mins, const Vector &maxs )
|
|
{
|
|
if ( ( m_vecMinsPreScaled != mins ) || ( m_vecMaxsPreScaled != maxs ) )
|
|
{
|
|
m_vecMinsPreScaled = mins;
|
|
m_vecMaxsPreScaled = maxs;
|
|
}
|
|
|
|
bool bDirty = false;
|
|
|
|
// Check if it's a scaled model
|
|
CBaseAnimating *pAnim = GetOuter()->GetBaseAnimating();
|
|
if ( pAnim && pAnim->GetModelScale() != 1.0f )
|
|
{
|
|
// Do the scaling
|
|
Vector vecNewMins = mins * pAnim->GetModelScale();
|
|
Vector vecNewMaxs = maxs * pAnim->GetModelScale();
|
|
|
|
if ( ( m_vecMins != vecNewMins ) || ( m_vecMaxs != vecNewMaxs ) )
|
|
{
|
|
m_vecMins = vecNewMins;
|
|
m_vecMaxs = vecNewMaxs;
|
|
bDirty = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No scaling needed!
|
|
if ( ( m_vecMins != mins ) || ( m_vecMaxs != maxs ) )
|
|
{
|
|
m_vecMins = mins;
|
|
m_vecMaxs = maxs;
|
|
bDirty = true;
|
|
}
|
|
}
|
|
|
|
if ( bDirty )
|
|
{
|
|
//ASSERT_COORD( m_vecMins.Get() );
|
|
//ASSERT_COORD( m_vecMaxs.Get() );
|
|
|
|
Vector vecSize;
|
|
VectorSubtract( m_vecMaxs, m_vecMins, vecSize );
|
|
m_flRadius = vecSize.Length() * 0.5f;
|
|
|
|
MarkSurroundingBoundsDirty();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Rebuilds the scaled bounds from the prescaled bounds after a model's scale has changed
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::RefreshScaledCollisionBounds( void )
|
|
{
|
|
SetCollisionBounds( m_vecMinsPreScaled, m_vecMaxsPreScaled );
|
|
|
|
SurroundingBoundsType_t nSurroundType = static_cast< SurroundingBoundsType_t >( m_nSurroundType.Get() );
|
|
if ( nSurroundType == USE_SPECIFIED_BOUNDS )
|
|
{
|
|
SetSurroundingBoundsType( nSurroundType,
|
|
&(m_vecSpecifiedSurroundingMinsPreScaled.Get()),
|
|
&(m_vecSpecifiedSurroundingMaxsPreScaled.Get()) );
|
|
}
|
|
else
|
|
{
|
|
SetSurroundingBoundsType( nSurroundType );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Lazily calculates the 2D bounding radius. If we do this enough, we should
|
|
// calculate this in SetCollisionBounds above and cache the results in a data member!
|
|
//-----------------------------------------------------------------------------
|
|
float CCollisionProperty::BoundingRadius2D() const
|
|
{
|
|
Vector vecSize;
|
|
VectorSubtract( m_vecMaxs, m_vecMins, vecSize );
|
|
|
|
vecSize.z = 0;
|
|
return vecSize.Length() * 0.5f;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Special trigger representation (OBB)
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::WorldSpaceTriggerBounds( Vector *pVecWorldMins, Vector *pVecWorldMaxs ) const
|
|
{
|
|
WorldSpaceAABB( pVecWorldMins, pVecWorldMaxs );
|
|
if ( ( GetSolidFlags() & FSOLID_USE_TRIGGER_BOUNDS ) == 0 )
|
|
return;
|
|
|
|
// Don't bloat below, we don't want to trigger it with our heads
|
|
pVecWorldMins->x -= m_triggerBloat;
|
|
pVecWorldMins->y -= m_triggerBloat;
|
|
|
|
pVecWorldMaxs->x += m_triggerBloat;
|
|
pVecWorldMaxs->y += m_triggerBloat;
|
|
pVecWorldMaxs->z += (float)m_triggerBloat * 0.5f;
|
|
}
|
|
|
|
void CCollisionProperty::UseTriggerBounds( bool bEnable, float flBloat )
|
|
{
|
|
Assert( flBloat <= 127.0f );
|
|
m_triggerBloat = (char )flBloat;
|
|
if ( bEnable )
|
|
{
|
|
AddSolidFlags( FSOLID_USE_TRIGGER_BOUNDS );
|
|
Assert( flBloat > 0.0f );
|
|
}
|
|
else
|
|
{
|
|
RemoveSolidFlags( FSOLID_USE_TRIGGER_BOUNDS );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Collision model (BSP)
|
|
//-----------------------------------------------------------------------------
|
|
int CCollisionProperty::GetCollisionModelIndex()
|
|
{
|
|
return m_pOuter->GetModelIndex();
|
|
}
|
|
|
|
const model_t* CCollisionProperty::GetCollisionModel()
|
|
{
|
|
return m_pOuter->GetModel();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Collision methods implemented in the entity
|
|
// FIXME: This shouldn't happen there!!
|
|
//-----------------------------------------------------------------------------
|
|
bool CCollisionProperty::TestCollision( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr )
|
|
{
|
|
return m_pOuter->TestCollision( ray, fContentsMask, tr );
|
|
}
|
|
|
|
bool CCollisionProperty::TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr )
|
|
{
|
|
return m_pOuter->TestHitboxes( ray, fContentsMask, tr );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes a "normalized" point (range 0,0,0 - 1,1,1) in collision space
|
|
//-----------------------------------------------------------------------------
|
|
const Vector & CCollisionProperty::NormalizedToCollisionSpace( const Vector &in, Vector *pResult ) const
|
|
{
|
|
pResult->x = Lerp( in.x, m_vecMins.Get().x, m_vecMaxs.Get().x );
|
|
pResult->y = Lerp( in.y, m_vecMins.Get().y, m_vecMaxs.Get().y );
|
|
pResult->z = Lerp( in.z, m_vecMins.Get().z, m_vecMaxs.Get().z );
|
|
return *pResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Transforms a point in collision space to normalized space
|
|
//-----------------------------------------------------------------------------
|
|
const Vector & CCollisionProperty::CollisionToNormalizedSpace( const Vector &in, Vector *pResult ) const
|
|
{
|
|
Vector vecSize = OBBSize( );
|
|
pResult->x = ( vecSize.x != 0.0f ) ? ( in.x - m_vecMins.Get().x ) / vecSize.x : 0.5f;
|
|
pResult->y = ( vecSize.y != 0.0f ) ? ( in.y - m_vecMins.Get().y ) / vecSize.y : 0.5f;
|
|
pResult->z = ( vecSize.z != 0.0f ) ? ( in.z - m_vecMins.Get().z ) / vecSize.z : 0.5f;
|
|
return *pResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes a "normalized" point (range 0,0,0 - 1,1,1) in world space
|
|
//-----------------------------------------------------------------------------
|
|
const Vector & CCollisionProperty::NormalizedToWorldSpace( const Vector &in, Vector *pResult ) const
|
|
{
|
|
Vector vecCollisionSpace;
|
|
NormalizedToCollisionSpace( in, &vecCollisionSpace );
|
|
CollisionToWorldSpace( vecCollisionSpace, pResult );
|
|
return *pResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Transforms a point in world space to normalized space
|
|
//-----------------------------------------------------------------------------
|
|
const Vector & CCollisionProperty::WorldToNormalizedSpace( const Vector &in, Vector *pResult ) const
|
|
{
|
|
Vector vecCollisionSpace;
|
|
WorldToCollisionSpace( in, &vecCollisionSpace );
|
|
CollisionToNormalizedSpace( vecCollisionSpace, pResult );
|
|
return *pResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Selects a random point in the bounds given the normalized 0-1 bounds
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::RandomPointInBounds( const Vector &vecNormalizedMins, const Vector &vecNormalizedMaxs, Vector *pPoint) const
|
|
{
|
|
Vector vecNormalizedSpace;
|
|
vecNormalizedSpace.x = random->RandomFloat( vecNormalizedMins.x, vecNormalizedMaxs.x );
|
|
vecNormalizedSpace.y = random->RandomFloat( vecNormalizedMins.y, vecNormalizedMaxs.y );
|
|
vecNormalizedSpace.z = random->RandomFloat( vecNormalizedMins.z, vecNormalizedMaxs.z );
|
|
NormalizedToWorldSpace( vecNormalizedSpace, pPoint );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Transforms an AABB measured in entity space to a box that surrounds it in world space
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::CollisionAABBToWorldAABB( const Vector &entityMins,
|
|
const Vector &entityMaxs, Vector *pWorldMins, Vector *pWorldMaxs ) const
|
|
{
|
|
if ( !IsBoundsDefinedInEntitySpace() || (GetCollisionAngles() == vec3_angle) )
|
|
{
|
|
VectorAdd( entityMins, GetCollisionOrigin(), *pWorldMins );
|
|
VectorAdd( entityMaxs, GetCollisionOrigin(), *pWorldMaxs );
|
|
}
|
|
else
|
|
{
|
|
TransformAABB( CollisionToWorldTransform(), entityMins, entityMaxs, *pWorldMins, *pWorldMaxs );
|
|
}
|
|
}
|
|
|
|
/*
|
|
void CCollisionProperty::WorldAABBToCollisionAABB( const Vector &worldMins, const Vector &worldMaxs, Vector *pEntityMins, Vector *pEntityMaxs ) const
|
|
{
|
|
if ( !IsBoundsDefinedInEntitySpace() || (GetCollisionAngles() == vec3_angle) )
|
|
{
|
|
VectorSubtract( worldMins, GetAbsOrigin(), *pEntityMins );
|
|
VectorSubtract( worldMaxs, GetAbsOrigin(), *pEntityMaxs );
|
|
}
|
|
else
|
|
{
|
|
ITransformAABB( CollisionToWorldTransform(), worldMins, worldMaxs, *pEntityMins, *pEntityMaxs );
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is a worldspace point within the bounds of the OBB?
|
|
//-----------------------------------------------------------------------------
|
|
bool CCollisionProperty::IsPointInBounds( const Vector &vecWorldPt ) const
|
|
{
|
|
Vector vecLocalSpace;
|
|
WorldToCollisionSpace( vecWorldPt, &vecLocalSpace );
|
|
return ( ( vecLocalSpace.x >= m_vecMins.Get().x && vecLocalSpace.x <= m_vecMaxs.Get().x ) &&
|
|
( vecLocalSpace.y >= m_vecMins.Get().y && vecLocalSpace.y <= m_vecMaxs.Get().y ) &&
|
|
( vecLocalSpace.z >= m_vecMins.Get().z && vecLocalSpace.z <= m_vecMaxs.Get().z ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the nearest point in the OBB to a point specified in world space
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::CalcNearestPoint( const Vector &vecWorldPt, Vector *pVecNearestWorldPt ) const
|
|
{
|
|
// Calculate physics force
|
|
Vector localPt, localClosestPt;
|
|
WorldToCollisionSpace( vecWorldPt, &localPt );
|
|
CalcClosestPointOnAABB( m_vecMins.Get(), m_vecMaxs.Get(), localPt, localClosestPt );
|
|
CollisionToWorldSpace( localClosestPt, pVecNearestWorldPt );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the nearest point in the OBB to a point specified in world space
|
|
//-----------------------------------------------------------------------------
|
|
float CCollisionProperty::CalcDistanceFromPoint( const Vector &vecWorldPt ) const
|
|
{
|
|
// Calculate physics force
|
|
Vector localPt, localClosestPt;
|
|
WorldToCollisionSpace( vecWorldPt, &localPt );
|
|
CalcClosestPointOnAABB( m_vecMins.Get(), m_vecMaxs.Get(), localPt, localClosestPt );
|
|
return localPt.DistTo( localClosestPt );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute the largest dot product of the OBB and the specified direction vector
|
|
//-----------------------------------------------------------------------------
|
|
float CCollisionProperty::ComputeSupportMap( const Vector &vecDirection ) const
|
|
{
|
|
Vector vecCollisionDir;
|
|
WorldDirectionToCollisionSpace( vecDirection, &vecCollisionDir );
|
|
|
|
float flResult = DotProduct( GetCollisionOrigin(), vecDirection );
|
|
flResult += (( vecCollisionDir.x >= 0.0f ) ? m_vecMaxs.Get().x : m_vecMins.Get().x) * vecCollisionDir.x;
|
|
flResult += (( vecCollisionDir.y >= 0.0f ) ? m_vecMaxs.Get().y : m_vecMins.Get().y) * vecCollisionDir.y;
|
|
flResult += (( vecCollisionDir.z >= 0.0f ) ? m_vecMaxs.Get().z : m_vecMins.Get().z) * vecCollisionDir.z;
|
|
|
|
return flResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Expand trigger bounds..
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::ComputeVPhysicsSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
|
|
{
|
|
bool bSetBounds = false;
|
|
IPhysicsObject *pPhysicsObject = GetOuter()->VPhysicsGetObject();
|
|
if ( pPhysicsObject )
|
|
{
|
|
if ( pPhysicsObject->GetCollide() )
|
|
{
|
|
physcollision->CollideGetAABB( pVecWorldMins, pVecWorldMaxs,
|
|
pPhysicsObject->GetCollide(), GetCollisionOrigin(), GetCollisionAngles() );
|
|
bSetBounds = true;
|
|
}
|
|
else if ( pPhysicsObject->GetSphereRadius( ) )
|
|
{
|
|
float flRadius = pPhysicsObject->GetSphereRadius( );
|
|
Vector vecExtents( flRadius, flRadius, flRadius );
|
|
VectorSubtract( GetCollisionOrigin(), vecExtents, *pVecWorldMins );
|
|
VectorAdd( GetCollisionOrigin(), vecExtents, *pVecWorldMaxs );
|
|
bSetBounds = true;
|
|
}
|
|
}
|
|
|
|
if ( !bSetBounds )
|
|
{
|
|
*pVecWorldMins = GetCollisionOrigin();
|
|
*pVecWorldMaxs = *pVecWorldMins;
|
|
}
|
|
|
|
// Also, lets expand for the trigger bounds also
|
|
if ( IsSolidFlagSet( FSOLID_USE_TRIGGER_BOUNDS ) )
|
|
{
|
|
Vector vecWorldTriggerMins, vecWorldTriggerMaxs;
|
|
WorldSpaceTriggerBounds( &vecWorldTriggerMins, &vecWorldTriggerMaxs );
|
|
VectorMin( vecWorldTriggerMins, *pVecWorldMins, *pVecWorldMins );
|
|
VectorMax( vecWorldTriggerMaxs, *pVecWorldMaxs, *pVecWorldMaxs );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Expand trigger bounds..
|
|
//-----------------------------------------------------------------------------
|
|
bool CCollisionProperty::ComputeHitboxSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
|
|
{
|
|
CBaseAnimating *pAnim = GetOuter()->GetBaseAnimating();
|
|
if (pAnim)
|
|
{
|
|
return pAnim->ComputeHitboxSurroundingBox( pVecWorldMins, pVecWorldMaxs );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Expand trigger bounds..
|
|
//-----------------------------------------------------------------------------
|
|
bool CCollisionProperty::ComputeEntitySpaceHitboxSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
|
|
{
|
|
CBaseAnimating *pAnim = GetOuter()->GetBaseAnimating();
|
|
if (pAnim)
|
|
{
|
|
return pAnim->ComputeEntitySpaceHitboxSurroundingBox( pVecWorldMins, pVecWorldMaxs );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the surrounding collision bounds from the the OBB (not vphysics)
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::ComputeRotationExpandedBounds( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
|
|
{
|
|
if ( !IsBoundsDefinedInEntitySpace() )
|
|
{
|
|
*pVecWorldMins = m_vecMins;
|
|
*pVecWorldMaxs = m_vecMaxs;
|
|
}
|
|
else
|
|
{
|
|
float flMaxVal;
|
|
flMaxVal = MAX( FloatMakePositive(m_vecMins.Get().x), FloatMakePositive(m_vecMaxs.Get().x) );
|
|
pVecWorldMins->x = -flMaxVal;
|
|
pVecWorldMaxs->x = flMaxVal;
|
|
|
|
flMaxVal = MAX( FloatMakePositive(m_vecMins.Get().y), FloatMakePositive(m_vecMaxs.Get().y) );
|
|
pVecWorldMins->y = -flMaxVal;
|
|
pVecWorldMaxs->y = flMaxVal;
|
|
|
|
flMaxVal = MAX( FloatMakePositive(m_vecMins.Get().z), FloatMakePositive(m_vecMaxs.Get().z) );
|
|
pVecWorldMins->z = -flMaxVal;
|
|
pVecWorldMaxs->z = flMaxVal;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the surrounding collision bounds based on whatever algorithm we want...
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::ComputeCollisionSurroundingBox( bool bUseVPhysics, Vector *pVecWorldMins, Vector *pVecWorldMaxs )
|
|
{
|
|
Assert( GetSolid() != SOLID_CUSTOM );
|
|
|
|
// NOTE: For solid none, we are still going to use the bounds; necessary because
|
|
// the surrounding box is used for the PVS...
|
|
// FIXME: Should we make some other call for the PVS stuff?? If so, we should return
|
|
// a point bounds for SOLID_NONE...
|
|
// if ( GetSolid() == SOLID_NONE )
|
|
// {
|
|
// *pVecWorldMins = GetCollisionOrigin();
|
|
// *pVecWorldMaxs = *pVecWorldMins;
|
|
// return;
|
|
// }
|
|
|
|
if ( bUseVPhysics )
|
|
{
|
|
ComputeVPhysicsSurroundingBox( pVecWorldMins, pVecWorldMaxs );
|
|
}
|
|
else
|
|
{
|
|
// Will expand the bounds for the trigger, if it is a trigger
|
|
WorldSpaceTriggerBounds( pVecWorldMins, pVecWorldMaxs );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the surrounding collision bounds based on whatever algorithm we want...
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::ComputeSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
|
|
{
|
|
if (( GetSolid() == SOLID_CUSTOM ) && (m_nSurroundType != USE_GAME_CODE ))
|
|
{
|
|
// NOTE: This can only happen in transition periods, say during network
|
|
// reception on the client. We expect USE_GAME_CODE to be used with SOLID_CUSTOM
|
|
*pVecWorldMins = GetCollisionOrigin();
|
|
*pVecWorldMaxs = *pVecWorldMins;
|
|
return;
|
|
}
|
|
|
|
switch( m_nSurroundType )
|
|
{
|
|
case USE_OBB_COLLISION_BOUNDS:
|
|
{
|
|
Assert( GetSolid() != SOLID_CUSTOM );
|
|
bool bUseVPhysics = false;
|
|
if ( ( GetSolid() == SOLID_VPHYSICS ) && ( GetOuter()->GetMoveType() == MOVETYPE_VPHYSICS ) )
|
|
{
|
|
// UNDONE: This may not be necessary any more.
|
|
IPhysicsObject *pPhysics = GetOuter()->VPhysicsGetObject();
|
|
bUseVPhysics = pPhysics && pPhysics->IsAsleep();
|
|
}
|
|
ComputeCollisionSurroundingBox( bUseVPhysics, pVecWorldMins, pVecWorldMaxs );
|
|
}
|
|
break;
|
|
|
|
case USE_BEST_COLLISION_BOUNDS:
|
|
Assert( GetSolid() != SOLID_CUSTOM );
|
|
ComputeCollisionSurroundingBox( (GetSolid() == SOLID_VPHYSICS), pVecWorldMins, pVecWorldMaxs );
|
|
break;
|
|
|
|
case USE_COLLISION_BOUNDS_NEVER_VPHYSICS:
|
|
Assert( GetSolid() != SOLID_CUSTOM );
|
|
ComputeCollisionSurroundingBox( false, pVecWorldMins, pVecWorldMaxs );
|
|
break;
|
|
|
|
case USE_HITBOXES:
|
|
ComputeHitboxSurroundingBox( pVecWorldMins, pVecWorldMaxs );
|
|
break;
|
|
|
|
case USE_ROTATION_EXPANDED_BOUNDS:
|
|
ComputeRotationExpandedBounds( pVecWorldMins, pVecWorldMaxs );
|
|
break;
|
|
|
|
case USE_SPECIFIED_BOUNDS:
|
|
VectorAdd( GetCollisionOrigin(), m_vecSpecifiedSurroundingMins, *pVecWorldMins );
|
|
VectorAdd( GetCollisionOrigin(), m_vecSpecifiedSurroundingMaxs, *pVecWorldMaxs );
|
|
break;
|
|
|
|
case USE_GAME_CODE:
|
|
GetOuter()->ComputeWorldSpaceSurroundingBox( pVecWorldMins, pVecWorldMaxs );
|
|
Assert( pVecWorldMins->x <= pVecWorldMaxs->x );
|
|
Assert( pVecWorldMins->y <= pVecWorldMaxs->y );
|
|
Assert( pVecWorldMins->z <= pVecWorldMaxs->z );
|
|
return;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
/*
|
|
// For debugging purposes, make sure the bounds actually does surround the thing.
|
|
// Otherwise the optimization we were using isn't really all that great, is it?
|
|
Vector vecTestMins, vecTestMaxs;
|
|
ComputeCollisionSurroundingBox( (GetSolid() == SOLID_VPHYSICS), &vecTestMins, &vecTestMaxs );
|
|
|
|
// Now that we have the basics, let's expand for hitboxes if appropriate
|
|
Vector vecWorldHitboxMins, vecWorldHitboxMaxs;
|
|
if ( ComputeHitboxSurroundingBox( &vecWorldHitboxMins, &vecWorldHitboxMaxs ) )
|
|
{
|
|
VectorMin( vecWorldHitboxMaxs, vecTestMins, vecTestMins );
|
|
VectorMax( vecWorldHitboxMaxs, vecTestMaxs, vecTestMaxs );
|
|
}
|
|
|
|
Assert( vecTestMins.x >= pVecWorldMins->x && vecTestMins.y >= pVecWorldMins->y && vecTestMins.z >= pVecWorldMins->z );
|
|
Assert( vecTestMaxs.x <= pVecWorldMaxs->x && vecTestMaxs.y <= pVecWorldMaxs->y && vecTestMaxs.z <= pVecWorldMaxs->z );
|
|
*/
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the method by which the surrounding collision bounds is set
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::SetSurroundingBoundsType( SurroundingBoundsType_t type, const Vector *pMins, const Vector *pMaxs )
|
|
{
|
|
m_nSurroundType = type;
|
|
if (type != USE_SPECIFIED_BOUNDS)
|
|
{
|
|
Assert( !pMins && !pMaxs );
|
|
MarkSurroundingBoundsDirty();
|
|
}
|
|
else
|
|
{
|
|
Assert( pMins && pMaxs );
|
|
m_vecSpecifiedSurroundingMinsPreScaled = *pMins;
|
|
m_vecSpecifiedSurroundingMaxsPreScaled = *pMaxs;
|
|
|
|
// Check if it's a scaled model
|
|
CBaseAnimating *pAnim = GetOuter()->GetBaseAnimating();
|
|
if ( pAnim && pAnim->GetModelScale() != 1.0f )
|
|
{
|
|
// Do the scaling
|
|
Vector vecNewMins = *pMins * pAnim->GetModelScale();
|
|
Vector vecNewMaxs = *pMaxs * pAnim->GetModelScale();
|
|
|
|
m_vecSpecifiedSurroundingMins = vecNewMins;
|
|
m_vecSpecifiedSurroundingMaxs = vecNewMaxs;
|
|
m_vecSurroundingMins = vecNewMins;
|
|
m_vecSurroundingMaxs = vecNewMaxs;
|
|
|
|
}
|
|
else
|
|
{
|
|
// No scaling needed!
|
|
m_vecSpecifiedSurroundingMins = *pMins;
|
|
m_vecSpecifiedSurroundingMaxs = *pMaxs;
|
|
m_vecSurroundingMins = *pMins;
|
|
m_vecSurroundingMaxs = *pMaxs;
|
|
|
|
}
|
|
|
|
ASSERT_COORD( m_vecSurroundingMins );
|
|
ASSERT_COORD( m_vecSurroundingMaxs );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Marks the entity has having a dirty surrounding box
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::MarkSurroundingBoundsDirty()
|
|
{
|
|
GetOuter()->AddEFlags( EFL_DIRTY_SURROUNDING_COLLISION_BOUNDS );
|
|
MarkPartitionHandleDirty();
|
|
|
|
#ifdef CLIENT_DLL
|
|
g_pClientShadowMgr->MarkRenderToTextureShadowDirty( GetOuter()->GetShadowHandle() );
|
|
#else
|
|
GetOuter()->NetworkProp()->MarkPVSInformationDirty();
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Does VPhysicsUpdate make us need to recompute the surrounding box?
|
|
//-----------------------------------------------------------------------------
|
|
bool CCollisionProperty::DoesVPhysicsInvalidateSurroundingBox( ) const
|
|
{
|
|
switch ( m_nSurroundType )
|
|
{
|
|
case USE_BEST_COLLISION_BOUNDS:
|
|
return true;
|
|
|
|
case USE_OBB_COLLISION_BOUNDS:
|
|
return (GetSolid() == SOLID_VPHYSICS) && (GetOuter()->GetMoveType() == MOVETYPE_VPHYSICS) && GetOuter()->VPhysicsGetObject();
|
|
|
|
// In the case of game code, we don't really know, so we have to assume it does
|
|
case USE_GAME_CODE:
|
|
return true;
|
|
|
|
case USE_COLLISION_BOUNDS_NEVER_VPHYSICS:
|
|
case USE_HITBOXES:
|
|
case USE_ROTATION_EXPANDED_BOUNDS:
|
|
case USE_SPECIFIED_BOUNDS:
|
|
return false;
|
|
|
|
default:
|
|
Assert(0);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the surrounding collision bounds based on whatever algorithm we want...
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::WorldSpaceSurroundingBounds( Vector *pVecMins, Vector *pVecMaxs )
|
|
{
|
|
const Vector &vecAbsOrigin = GetCollisionOrigin();
|
|
if ( GetOuter()->IsEFlagSet( EFL_DIRTY_SURROUNDING_COLLISION_BOUNDS ))
|
|
{
|
|
GetOuter()->RemoveEFlags( EFL_DIRTY_SURROUNDING_COLLISION_BOUNDS );
|
|
ComputeSurroundingBox( pVecMins, pVecMaxs );
|
|
VectorSubtract( *pVecMins, vecAbsOrigin, m_vecSurroundingMins );
|
|
VectorSubtract( *pVecMaxs, vecAbsOrigin, m_vecSurroundingMaxs );
|
|
|
|
ASSERT_COORD( m_vecSurroundingMins );
|
|
ASSERT_COORD( m_vecSurroundingMaxs );
|
|
}
|
|
else
|
|
{
|
|
VectorAdd( m_vecSurroundingMins, vecAbsOrigin, *pVecMins );
|
|
VectorAdd( m_vecSurroundingMaxs, vecAbsOrigin, *pVecMaxs );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Spatial partition
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::CreatePartitionHandle()
|
|
{
|
|
// Put the entity into the spatial partition.
|
|
Assert( m_Partition == PARTITION_INVALID_HANDLE );
|
|
m_Partition = ::partition->CreateHandle( GetEntityHandle() );
|
|
}
|
|
|
|
void CCollisionProperty::DestroyPartitionHandle()
|
|
{
|
|
if ( m_Partition != PARTITION_INVALID_HANDLE )
|
|
{
|
|
::partition->DestroyHandle( m_Partition );
|
|
m_Partition = PARTITION_INVALID_HANDLE;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Updates the spatial partition
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::UpdateServerPartitionMask( )
|
|
{
|
|
#ifndef CLIENT_DLL
|
|
SpatialPartitionHandle_t handle = GetPartitionHandle();
|
|
if ( handle == PARTITION_INVALID_HANDLE )
|
|
return;
|
|
|
|
// Remove it from whatever lists it may be in at the moment
|
|
// We'll re-add it below if we need to.
|
|
::partition->Remove( handle );
|
|
|
|
// Don't bother with deleted things
|
|
if ( !m_pOuter->edict() )
|
|
return;
|
|
|
|
// don't add the world
|
|
if ( m_pOuter->entindex() == 0 )
|
|
return;
|
|
|
|
// Make sure it's in the list of all entities
|
|
bool bIsSolid = IsSolid() || IsSolidFlagSet(FSOLID_TRIGGER);
|
|
if ( bIsSolid || m_pOuter->IsEFlagSet(EFL_USE_PARTITION_WHEN_NOT_SOLID) )
|
|
{
|
|
::partition->Insert( PARTITION_ENGINE_NON_STATIC_EDICTS, handle );
|
|
}
|
|
|
|
if ( !bIsSolid )
|
|
return;
|
|
|
|
// Insert it into the appropriate lists.
|
|
// We have to continually reinsert it because its solid type may have changed
|
|
SpatialPartitionListMask_t mask = 0;
|
|
if ( !IsSolidFlagSet(FSOLID_NOT_SOLID) )
|
|
{
|
|
mask |= PARTITION_ENGINE_SOLID_EDICTS;
|
|
}
|
|
if ( IsSolidFlagSet(FSOLID_TRIGGER) )
|
|
{
|
|
mask |= PARTITION_ENGINE_TRIGGER_EDICTS;
|
|
}
|
|
Assert( mask != 0 );
|
|
::partition->Insert( mask, handle );
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Marks the spatial partition dirty
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::MarkPartitionHandleDirty()
|
|
{
|
|
// don't bother with the world
|
|
if ( m_pOuter->entindex() == 0 )
|
|
return;
|
|
|
|
if ( !m_pOuter->IsEFlagSet( EFL_DIRTY_SPATIAL_PARTITION ) )
|
|
{
|
|
m_pOuter->AddEFlags( EFL_DIRTY_SPATIAL_PARTITION );
|
|
s_DirtyKDTree.AddEntity( m_pOuter );
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
GetOuter()->MarkRenderHandleDirty();
|
|
g_pClientShadowMgr->AddToDirtyShadowList( GetOuter() );
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Updates the spatial partition
|
|
//-----------------------------------------------------------------------------
|
|
void CCollisionProperty::UpdatePartition( )
|
|
{
|
|
if ( m_pOuter->IsEFlagSet( EFL_DIRTY_SPATIAL_PARTITION ) )
|
|
{
|
|
m_pOuter->RemoveEFlags( EFL_DIRTY_SPATIAL_PARTITION );
|
|
|
|
#ifndef CLIENT_DLL
|
|
Assert( m_pOuter->entindex() != 0 );
|
|
|
|
// Don't bother with deleted things
|
|
if ( !m_pOuter->edict() )
|
|
return;
|
|
|
|
if ( GetPartitionHandle() == PARTITION_INVALID_HANDLE )
|
|
{
|
|
CreatePartitionHandle();
|
|
UpdateServerPartitionMask();
|
|
}
|
|
#else
|
|
if ( GetPartitionHandle() == PARTITION_INVALID_HANDLE )
|
|
return;
|
|
#endif
|
|
|
|
// We don't need to bother if it's not a trigger or solid
|
|
if ( IsSolid() || IsSolidFlagSet( FSOLID_TRIGGER ) || m_pOuter->IsEFlagSet( EFL_USE_PARTITION_WHEN_NOT_SOLID ) )
|
|
{
|
|
// Bloat a little bit...
|
|
if ( BoundingRadius() != 0.0f )
|
|
{
|
|
Vector vecSurroundMins, vecSurroundMaxs;
|
|
WorldSpaceSurroundingBounds( &vecSurroundMins, &vecSurroundMaxs );
|
|
vecSurroundMins -= Vector( 1, 1, 1 );
|
|
vecSurroundMaxs += Vector( 1, 1, 1 );
|
|
::partition->ElementMoved( GetPartitionHandle(), vecSurroundMins, vecSurroundMaxs );
|
|
}
|
|
else
|
|
{
|
|
::partition->ElementMoved( GetPartitionHandle(), GetCollisionOrigin(), GetCollisionOrigin() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|