Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1092 lines
30 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Clones a physics object (usually with a matrix transform applied)
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "physicsshadowclone.h"
#include "portal_util_shared.h"
#include "vphysics/object_hash.h"
#include "trains.h"
#include "props.h"
#include "model_types.h"
#include "portal/weapon_physcannon.h" //grab controllers
#include "PortalSimulation.h"
#define MAX_SHADOW_CLONE_COUNT 200
static int g_iShadowCloneCount = 0;
ConVar sv_debug_physicsshadowclones("sv_debug_physicsshadowclones", "0", FCVAR_REPLICATED );
ConVar sv_use_shadow_clones( "sv_use_shadow_clones", "1", FCVAR_REPLICATED | FCVAR_CHEAT ); //should we create shadow clones?
static void DrawDebugOverlayForShadowClone( CPhysicsShadowClone *pClone );
LINK_ENTITY_TO_CLASS( physicsshadowclone, CPhysicsShadowClone );
static CUtlVector<CPhysicsShadowClone *> s_ActiveShadowClones;
CUtlVector<CPhysicsShadowClone *> const &CPhysicsShadowClone::g_ShadowCloneList = s_ActiveShadowClones;
static bool s_IsShadowClone[MAX_EDICTS] = { false };
static CPhysicsShadowCloneLL *s_EntityClones[MAX_EDICTS] = { NULL };
struct ShadowCloneLLEntryManager
{
CPhysicsShadowCloneLL m_ShadowCloneLLEntries[MAX_SHADOW_CLONE_COUNT];
CPhysicsShadowCloneLL *m_pFreeShadowCloneLLEntries[MAX_SHADOW_CLONE_COUNT];
int m_iUsedEntryIndex;
ShadowCloneLLEntryManager( void )
{
m_iUsedEntryIndex = 0;
for( int i = 0; i != MAX_SHADOW_CLONE_COUNT; ++i )
{
m_pFreeShadowCloneLLEntries[i] = &m_ShadowCloneLLEntries[i];
}
}
inline CPhysicsShadowCloneLL *Alloc( void )
{
return m_pFreeShadowCloneLLEntries[m_iUsedEntryIndex++];
}
inline void Free( CPhysicsShadowCloneLL *pFree )
{
m_pFreeShadowCloneLLEntries[--m_iUsedEntryIndex] = pFree;
}
};
static ShadowCloneLLEntryManager s_SCLLManager;
CPhysicsShadowClone::CPhysicsShadowClone( void )
{
m_matrixShadowTransform.Identity();
m_matrixShadowTransform_Inverse.Identity();
m_bShadowTransformIsIdentity = true;
s_ActiveShadowClones.AddToTail( this );
}
CPhysicsShadowClone::~CPhysicsShadowClone( void )
{
VPhysicsDestroyObject();
VPhysicsSetObject( NULL );
m_hClonedEntity = NULL;
s_ActiveShadowClones.FindAndRemove( this ); //also removed in UpdateOnRemove()
Assert( s_IsShadowClone[entindex()] == true );
s_IsShadowClone[entindex()] = false;
}
void CPhysicsShadowClone::UpdateOnRemove( void )
{
CBaseEntity *pSource = m_hClonedEntity;
if( pSource )
{
CPhysicsShadowCloneLL *pCloneListHead = s_EntityClones[pSource->entindex()];
Assert( pCloneListHead != NULL );
CPhysicsShadowCloneLL *pFind = pCloneListHead;
CPhysicsShadowCloneLL *pLast = pFind;
while( pFind->pClone != this )
{
pLast = pFind;
Assert( pFind->pNext != NULL );
pFind = pFind->pNext;
}
if( pFind == pCloneListHead )
{
s_EntityClones[pSource->entindex()] = pFind->pNext;
}
else
{
pLast->pNext = pFind->pNext;
}
s_SCLLManager.Free( pFind );
}
#ifdef _DEBUG
else
{
//verify that it didn't weasel into a list somewhere and get left behind
for( int i = 0; i != MAX_SHADOW_CLONE_COUNT; ++i )
{
CPhysicsShadowCloneLL *pCloneSearch = s_EntityClones[i];
while( pCloneSearch )
{
Assert( pCloneSearch->pClone != this );
pCloneSearch = pCloneSearch->pNext;
}
}
}
#endif
VPhysicsDestroyObject();
VPhysicsSetObject( NULL );
m_hClonedEntity = NULL;
s_ActiveShadowClones.FindAndRemove( this ); //also removed in Destructor
BaseClass::UpdateOnRemove();
}
void CPhysicsShadowClone::Spawn( void )
{
AddFlag( FL_DONTTOUCH );
AddEffects( EF_NODRAW | EF_NOSHADOW | EF_NORECEIVESHADOW );
FullSync( false );
m_bInAssumedSyncState = false;
BaseClass::Spawn();
s_IsShadowClone[entindex()] = true;
}
void CPhysicsShadowClone::FullSync( bool bAllowAssumedSync )
{
Assert( IsMarkedForDeletion() == false );
CBaseEntity *pClonedEntity = m_hClonedEntity.Get();
if( pClonedEntity == NULL )
{
AssertMsg( VPhysicsGetObject() != NULL, "Been linkless for more than this update, something should have killed this clone." );
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_NONE );
SetSolidFlags( 0 );
SetCollisionGroup( COLLISION_GROUP_NONE );
VPhysicsDestroyObject();
return;
}
SetGroundEntity( NULL );
bool bIsSynced = bAllowAssumedSync;
bool bBigChanges = true; //assume there are, and be proven wrong
if( bAllowAssumedSync )
{
IPhysicsObject *pSourceObjects[1024];
int iObjectCount = pClonedEntity->VPhysicsGetObjectList( pSourceObjects, 1024 );
//scan for really big differences that would definitely require a full sync
bBigChanges = ( iObjectCount != m_CloneLinks.Count() );
if( !bBigChanges )
{
for( int i = 0; i != iObjectCount; ++i )
{
IPhysicsObject *pSourcePhysics = pSourceObjects[i];
IPhysicsObject *pClonedPhysics = m_CloneLinks[i].pClone;
if( (pSourcePhysics != m_CloneLinks[i].pSource) ||
(pSourcePhysics->IsCollisionEnabled() != pClonedPhysics->IsCollisionEnabled()) )
{
bBigChanges = true;
bIsSynced = false;
break;
}
Vector ptSourcePosition, ptClonePosition;
pSourcePhysics->GetPosition( &ptSourcePosition, NULL );
if( !m_bShadowTransformIsIdentity )
ptSourcePosition = m_matrixShadowTransform * ptSourcePosition;
pClonedPhysics->GetPosition( &ptClonePosition, NULL );
if( (ptClonePosition - ptSourcePosition).LengthSqr() > 2500.0f )
{
bBigChanges = true;
bIsSynced = false;
break;
}
//Vector vSourceVelocity, vCloneVelocity;
if( !pSourcePhysics->IsAsleep() ) //only allow full syncrosity if the source entity is entirely asleep
bIsSynced = false;
if( m_bInAssumedSyncState && !pClonedPhysics->IsAsleep() )
bIsSynced = false;
}
}
else
{
bIsSynced = false;
}
bIsSynced = false;
if( bIsSynced )
{
//good enough to skip a full update
if( !m_bInAssumedSyncState )
{
//do one last sync
PartialSync( true );
//if we don't do this, objects just fall out of the world (it happens, I swear)
for( int i = m_CloneLinks.Count(); --i >= 0; )
{
if( (m_CloneLinks[i].pSource->GetShadowController() == NULL) && m_CloneLinks[i].pClone->IsMotionEnabled() )
{
//m_CloneLinks[i].pClone->SetVelocityInstantaneous( &vec3_origin, &vec3_origin );
//m_CloneLinks[i].pClone->SetVelocity( &vec3_origin, &vec3_origin );
m_CloneLinks[i].pClone->EnableGravity( false );
m_CloneLinks[i].pClone->EnableMotion( false );
m_CloneLinks[i].pClone->Sleep();
}
}
m_bInAssumedSyncState = true;
}
if( sv_debug_physicsshadowclones.GetBool() )
DrawDebugOverlayForShadowClone( this );
return;
}
}
m_bInAssumedSyncState = false;
//past this point, we're committed to a broad update
if( bBigChanges )
{
MoveType_t sourceMoveType = pClonedEntity->GetMoveType();
IPhysicsObject *pPhysObject = pClonedEntity->VPhysicsGetObject();
if( (sourceMoveType == MOVETYPE_CUSTOM) ||
(sourceMoveType == MOVETYPE_STEP) ||
(sourceMoveType == MOVETYPE_WALK) ||
(pPhysObject &&
(
(pPhysObject->GetGameFlags() & FVPHYSICS_PLAYER_HELD) ||
(pPhysObject->GetShadowController() != NULL)
)
)
)
{
//#ifdef _DEBUG
SetMoveType( MOVETYPE_NONE ); //to kill an assert
//#endif
//PUSH should be used sparingly, you can't stand on a MOVETYPE_PUSH object :/
SetMoveType( MOVETYPE_VPHYSICS, pClonedEntity->GetMoveCollide() ); //either an unclonable movetype, or a shadow/held object
}
/*else if(sourceMoveType == MOVETYPE_STEP)
{
//SetMoveType( MOVETYPE_NONE ); //to kill an assert
SetMoveType( MOVETYPE_VPHYSICS, pClonedEntity->GetMoveCollide() );
}*/
else
{
//if( m_bShadowTransformIsIdentity )
SetMoveType( sourceMoveType, pClonedEntity->GetMoveCollide() );
//else
//{
// SetMoveType( MOVETYPE_NONE ); //to kill an assert
// SetMoveType( MOVETYPE_PUSH, pClonedEntity->GetMoveCollide() );
//}
}
SolidType_t sourceSolidType = pClonedEntity->GetSolid();
if( sourceSolidType == SOLID_BBOX )
SetSolid( SOLID_VPHYSICS );
else
SetSolid( sourceSolidType );
//SetSolid( SOLID_VPHYSICS );
SetElasticity( pClonedEntity->GetElasticity() );
SetFriction( pClonedEntity->GetFriction() );
int iSolidFlags = pClonedEntity->GetSolidFlags() | FSOLID_CUSTOMRAYTEST;
if( m_bShadowTransformIsIdentity )
iSolidFlags |= FSOLID_CUSTOMBOXTEST; //need this at least for the player or they get stuck in themselves
else
iSolidFlags &= ~FSOLID_FORCE_WORLD_ALIGNED;
/*if( pClonedEntity->IsPlayer() )
{
iSolidFlags |= FSOLID_CUSTOMRAYTEST | FSOLID_CUSTOMBOXTEST;
}*/
SetSolidFlags( iSolidFlags );
SetEffects( pClonedEntity->GetEffects() | (EF_NODRAW | EF_NOSHADOW | EF_NORECEIVESHADOW) );
SetCollisionGroup( pClonedEntity->GetCollisionGroup() );
SetModelIndex( pClonedEntity->GetModelIndex() );
SetModelName( pClonedEntity->GetModelName() );
if( modelinfo->GetModelType( pClonedEntity->GetModel() ) == mod_studio )
SetModel( STRING( pClonedEntity->GetModelName() ) );
CCollisionProperty *pClonedCollisionProp = pClonedEntity->CollisionProp();
SetSize( pClonedCollisionProp->OBBMins(), pClonedCollisionProp->OBBMaxs() );
}
FullSyncClonedPhysicsObjects( bBigChanges );
SyncEntity( true );
if( bBigChanges )
CollisionRulesChanged();
if( sv_debug_physicsshadowclones.GetBool() )
DrawDebugOverlayForShadowClone( this );
}
void CPhysicsShadowClone::SyncEntity( bool bPullChanges )
{
m_bShouldUpSync = false;
CBaseEntity *pSource, *pDest;
VMatrix *pTransform;
if( bPullChanges )
{
pSource = m_hClonedEntity.Get();
pDest = this;
pTransform = &m_matrixShadowTransform;
if( pSource == NULL )
return;
}
else
{
pSource = this;
pDest = m_hClonedEntity.Get();
pTransform = &m_matrixShadowTransform_Inverse;
if( pDest == NULL )
return;
}
Vector ptOrigin, vVelocity;
QAngle qAngles;
ptOrigin = pSource->GetAbsOrigin();
qAngles = pSource->GetAbsAngles();
vVelocity = pSource->GetAbsVelocity();
if( !m_bShadowTransformIsIdentity )
{
ptOrigin = (*pTransform) * ptOrigin;
qAngles = TransformAnglesToWorldSpace( qAngles, pTransform->As3x4() );
vVelocity = pTransform->ApplyRotation( vVelocity );
}
//else
//{
// pDest->SetGroundEntity( pSource->GetGroundEntity() );
//}
if( (ptOrigin != pDest->GetAbsOrigin()) || (qAngles != pDest->GetAbsAngles()) )
{
pDest->Teleport( &ptOrigin, &qAngles, NULL );
}
if( vVelocity != pDest->GetAbsVelocity() )
{
//pDest->IncrementInterpolationFrame();
pDest->SetAbsVelocity( vec3_origin ); //the two step process helps, I don't know why, but it does
pDest->ApplyAbsVelocityImpulse( vVelocity );
}
}
static void FullSyncPhysicsObject( IPhysicsObject *pSource, IPhysicsObject *pDest, const VMatrix *pTransform, bool bTeleport )
{
CGrabController *pGrabController = NULL;
if( !pSource->IsAsleep() )
pDest->Wake();
float fSavedMass = 0.0f, fSavedRotationalDamping; //setting mass to 0.0f purely to kill a warning that I can't seem to kill with pragmas
if( pSource->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
{
//CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );
//Assert( pPlayer );
CBaseEntity *pLookingForEntity = (CBaseEntity *)pSource->GetGameData();
CBasePlayer *pHoldingPlayer = GetPlayerHoldingEntity( pLookingForEntity );
if( pHoldingPlayer )
{
pGrabController = GetGrabControllerForPlayer( pHoldingPlayer );
if ( !pGrabController )
pGrabController = GetGrabControllerForPhysCannon( pHoldingPlayer->GetActiveWeapon() );
}
AssertMsg( pGrabController, "Physics object is held, but we can't find the holding controller." );
GetSavedParamsForCarriedPhysObject( pGrabController, pSource, &fSavedMass, &fSavedRotationalDamping );
}
//Boiler plate
{
pDest->SetGameIndex( pSource->GetGameIndex() ); //what's it do?
pDest->SetCallbackFlags( pSource->GetCallbackFlags() ); //wise?
pDest->SetGameFlags( pSource->GetGameFlags() | FVPHYSICS_NO_SELF_COLLISIONS | FVPHYSICS_IS_SHADOWCLONE );
pDest->SetMaterialIndex( pSource->GetMaterialIndex() );
pDest->SetContents( pSource->GetContents() );
pDest->EnableCollisions( pSource->IsCollisionEnabled() );
pDest->EnableGravity( pSource->IsGravityEnabled() );
pDest->EnableDrag( pSource->IsDragEnabled() );
pDest->EnableMotion( pSource->IsMotionEnabled() );
}
//Damping
{
float fSpeedDamp, fRotDamp;
if( pGrabController )
{
pSource->GetDamping( &fSpeedDamp, NULL );
pDest->SetDamping( &fSpeedDamp, &fSavedRotationalDamping );
}
else
{
pSource->GetDamping( &fSpeedDamp, &fRotDamp );
pDest->SetDamping( &fSpeedDamp, &fRotDamp );
}
}
//stuff that we really care about
{
if( pGrabController )
pDest->SetMass( fSavedMass );
else
pDest->SetMass( pSource->GetMass() );
Vector ptOrigin, vVelocity, vAngularVelocity, vInertia;
QAngle qAngles;
pSource->GetPosition( &ptOrigin, &qAngles );
pSource->GetVelocity( &vVelocity, &vAngularVelocity );
vInertia = pSource->GetInertia();
if( pTransform )
{
#if 0
pDest->SetPositionMatrix( pTransform->As3x4(), true ); //works like we think?
#else
ptOrigin = (*pTransform) * ptOrigin;
qAngles = TransformAnglesToWorldSpace( qAngles, pTransform->As3x4() );
vVelocity = pTransform->ApplyRotation( vVelocity );
vAngularVelocity = pTransform->ApplyRotation( vAngularVelocity );
#endif
}
//avoid oversetting variables (I think that even setting them to the same value they already are disrupts the delicate physics balance)
if( vInertia != pDest->GetInertia() )
pDest->SetInertia( vInertia );
Vector ptDestOrigin, vDestVelocity, vDestAngularVelocity;
QAngle qDestAngles;
pDest->GetPosition( &ptDestOrigin, &qDestAngles );
if( (ptOrigin != ptDestOrigin) || (qAngles != qDestAngles) )
pDest->SetPosition( ptOrigin, qAngles, bTeleport );
//pDest->SetVelocityInstantaneous( &vec3_origin, &vec3_origin );
//pDest->Sleep();
pDest->GetVelocity( &vDestVelocity, &vDestAngularVelocity );
if( (vVelocity != vDestVelocity) || (vAngularVelocity != vDestAngularVelocity) )
pDest->SetVelocityInstantaneous( &vVelocity, &vAngularVelocity );
IPhysicsShadowController *pSourceController = pSource->GetShadowController();
if( pSourceController == NULL )
{
if( pDest->GetShadowController() != NULL )
{
//we don't need a shadow controller anymore
pDest->RemoveShadowController();
}
}
else
{
IPhysicsShadowController *pDestController = pDest->GetShadowController();
if( pDestController == NULL )
{
//we need a shadow controller
float fMaxSpeed, fMaxAngularSpeed;
pSourceController->GetMaxSpeed( &fMaxSpeed, &fMaxAngularSpeed );
pDest->SetShadow( fMaxSpeed, fMaxAngularSpeed, pSourceController->AllowsTranslation(), pSourceController->AllowsRotation() );
pDestController = pDest->GetShadowController();
pDestController->SetTeleportDistance( pSourceController->GetTeleportDistance() );
pDestController->SetPhysicallyControlled( pSourceController->IsPhysicallyControlled() );
}
//sync shadow controllers
float fTimeOffset;
Vector ptTargetPosition;
QAngle qTargetAngles;
fTimeOffset = pSourceController->GetTargetPosition( &ptTargetPosition, &qTargetAngles );
if( pTransform )
{
ptTargetPosition = (*pTransform) * ptTargetPosition;
qTargetAngles = TransformAnglesToWorldSpace( qTargetAngles, pTransform->As3x4() );
}
pDestController->Update( ptTargetPosition, qTargetAngles, fTimeOffset );
}
}
//pDest->RecheckContactPoints();
}
static void PartialSyncPhysicsObject( IPhysicsObject *pSource, IPhysicsObject *pDest, const VMatrix *pTransform )
{
Vector ptOrigin, vVelocity, vAngularVelocity, vInertia;
QAngle qAngles;
pSource->GetPosition( &ptOrigin, &qAngles );
pSource->GetVelocity( &vVelocity, &vAngularVelocity );
vInertia = pSource->GetInertia();
if( pTransform )
{
#if 0
//pDest->SetPositionMatrix( matTransform.As3x4(), true ); //works like we think?
#else
ptOrigin = (*pTransform) * ptOrigin;
qAngles = TransformAnglesToWorldSpace( qAngles, pTransform->As3x4() );
vVelocity = pTransform->ApplyRotation( vVelocity );
vAngularVelocity = pTransform->ApplyRotation( vAngularVelocity );
#endif
}
//avoid oversetting variables (I think that even setting them to the same value they already are disrupts the delicate physics balance)
if( vInertia != pDest->GetInertia() )
pDest->SetInertia( vInertia );
Vector ptDestOrigin, vDestVelocity, vDestAngularVelocity;
QAngle qDestAngles;
pDest->GetPosition( &ptDestOrigin, &qDestAngles );
pDest->GetVelocity( &vDestVelocity, &vDestAngularVelocity );
if( (ptOrigin != ptDestOrigin) || (qAngles != qDestAngles) )
pDest->SetPosition( ptOrigin, qAngles, false );
if( (vVelocity != vDestVelocity) || (vAngularVelocity != vDestAngularVelocity) )
pDest->SetVelocity( &vVelocity, &vAngularVelocity );
pDest->EnableCollisions( pSource->IsCollisionEnabled() );
}
void CPhysicsShadowClone::FullSyncClonedPhysicsObjects( bool bTeleport )
{
CBaseEntity *pClonedEntity = m_hClonedEntity.Get();
if( pClonedEntity == NULL )
{
VPhysicsDestroyObject();
return;
}
VMatrix *pTransform;
if( m_bShadowTransformIsIdentity )
pTransform = NULL;
else
pTransform = &m_matrixShadowTransform;
IPhysicsObject *(pSourceObjects[1024]);
int iObjectCount = pClonedEntity->VPhysicsGetObjectList( pSourceObjects, 1024 );
//easy out if nothing has changed
if( iObjectCount == m_CloneLinks.Count() )
{
int i;
for( i = 0; i != iObjectCount; ++i )
{
if( pSourceObjects[i] == NULL )
break;
if( pSourceObjects[i] != m_CloneLinks[i].pSource )
break;
}
if( i == iObjectCount ) //no changes
{
for( i = 0; i != iObjectCount; ++i )
FullSyncPhysicsObject( m_CloneLinks[i].pSource, m_CloneLinks[i].pClone, pTransform, bTeleport );
return;
}
}
//copy the existing list of clone links to a temp array, we're going to be starting from scratch and copying links as we need them
PhysicsObjectCloneLink_t *pExistingLinks = NULL;
int iExistingLinkCount = m_CloneLinks.Count();
if( iExistingLinkCount != 0 )
{
pExistingLinks = (PhysicsObjectCloneLink_t *)stackalloc( sizeof(PhysicsObjectCloneLink_t) * m_CloneLinks.Count() );
memcpy( pExistingLinks, m_CloneLinks.Base(), sizeof(PhysicsObjectCloneLink_t) * m_CloneLinks.Count() );
}
m_CloneLinks.RemoveAll();
//now, go over the object list we just got from the source entity, and either copy or create links as necessary
int i;
for( i = 0; i != iObjectCount; ++i )
{
IPhysicsObject *pSource = pSourceObjects[i];
if( pSource == NULL ) //this really shouldn't happen, but it does >_<
continue;
PhysicsObjectCloneLink_t cloneLink;
int j;
for( j = 0; j != iExistingLinkCount; ++j )
{
if( pExistingLinks[j].pSource == pSource )
break;
}
if( j != iExistingLinkCount )
{
//copyable link found
cloneLink = pExistingLinks[j];
memset( &pExistingLinks[j], 0, sizeof( PhysicsObjectCloneLink_t ) ); //zero out this slot so we don't destroy it in cleanup
}
else
{
//no link found to copy, create a new one
cloneLink.pSource = pSource;
//apparently some collision code gets called on creation before we've set extra game flags, so we're going to cheat a bit and temporarily set our extra flags on the source
unsigned int iOldGameFlags = pSource->GetGameFlags();
pSource->SetGameFlags( iOldGameFlags | FVPHYSICS_IS_SHADOWCLONE );
unsigned int size = physenv->GetObjectSerializeSize(pSource);
byte *pBuffer = (byte *)stackalloc(size);
memset( pBuffer, 0, size );
physenv->SerializeObjectToBuffer( pSource, pBuffer, size ); //this should work across physics environments because the serializer doesn't write anything about itself to the template
pSource->SetGameFlags( iOldGameFlags );
cloneLink.pClone = m_pOwnerPhysEnvironment->UnserializeObjectFromBuffer( this, pBuffer, size, false ); //unserializer has to be in the target environment
assert( cloneLink.pClone ); //there should be absolutely no case where we can't clone a valid existing physics object
stackfree(pBuffer);
}
FullSyncPhysicsObject( cloneLink.pSource, cloneLink.pClone, pTransform, bTeleport );
//cloneLink.pClone->Wake();
m_CloneLinks.AddToTail( cloneLink );
}
//now go over the existing links, if any of them haven't been nullified, they need to be deleted
for( i = 0; i != iExistingLinkCount; ++i )
{
if( pExistingLinks[i].pClone )
m_pOwnerPhysEnvironment->DestroyObject( pExistingLinks[i].pClone ); //also destroys shadow controller
}
VPhysicsSetObject( NULL );
IPhysicsObject *pSource = m_hClonedEntity->VPhysicsGetObject();
for( i = m_CloneLinks.Count(); --i >= 0; )
{
if( m_CloneLinks[i].pSource == pSource )
{
//m_CloneLinks[i].pClone->Wake();
VPhysicsSetObject( m_CloneLinks[i].pClone );
break;
}
}
if( (i < 0) && (m_CloneLinks.Count() != 0) )
{
VPhysicsSetObject( m_CloneLinks[0].pClone );
}
stackfree( pExistingLinks );
//CollisionRulesChanged();
}
void CPhysicsShadowClone::PartialSync( bool bPullChanges )
{
VMatrix *pTransform;
if( bPullChanges )
{
if( m_bShadowTransformIsIdentity )
pTransform = NULL;
else
pTransform = &m_matrixShadowTransform;
for( int i = m_CloneLinks.Count(); --i >= 0; )
PartialSyncPhysicsObject( m_CloneLinks[i].pSource, m_CloneLinks[i].pClone, pTransform );
}
else
{
if( m_bShadowTransformIsIdentity )
pTransform = NULL;
else
pTransform = &m_matrixShadowTransform_Inverse;
for( int i = m_CloneLinks.Count(); --i >= 0; )
PartialSyncPhysicsObject( m_CloneLinks[i].pClone, m_CloneLinks[i].pSource, pTransform );
}
SyncEntity( bPullChanges );
}
int CPhysicsShadowClone::VPhysicsGetObjectList( IPhysicsObject **pList, int listMax )
{
int iCountStop = m_CloneLinks.Count();
if( iCountStop > listMax )
iCountStop = listMax;
for( int i = 0; i != iCountStop; ++i, ++pList )
*pList = m_CloneLinks[i].pClone;
return iCountStop;
}
void CPhysicsShadowClone::VPhysicsDestroyObject( void )
{
VPhysicsSetObject( NULL );
for( int i = m_CloneLinks.Count(); --i >= 0; )
{
Assert( m_CloneLinks[i].pClone != NULL );
m_pOwnerPhysEnvironment->DestroyObject( m_CloneLinks[i].pClone );
}
m_CloneLinks.RemoveAll();
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_NONE );
SetSolidFlags( 0 );
SetCollisionGroup( COLLISION_GROUP_NONE );
BaseClass::VPhysicsDestroyObject();
}
bool CPhysicsShadowClone::ShouldCollide( int collisionGroup, int contentsMask ) const
{
CBaseEntity *pClonedEntity = m_hClonedEntity.Get();
if( pClonedEntity )
return pClonedEntity->ShouldCollide( collisionGroup, contentsMask );
else
return false;
}
bool CPhysicsShadowClone::TestCollision( const Ray_t &ray, unsigned int fContentsMask, trace_t& trace )
{
return false;
/*CBaseEntity *pSourceEntity = m_hClonedEntity.Get();
if( pSourceEntity == NULL )
return false;
enginetrace->ClipRayToEntity( ray, fContentsMask, pSourceEntity, &trace );
return trace.DidHit();*/
}
int CPhysicsShadowClone::ObjectCaps( void )
{
return ((BaseClass::ObjectCaps() | FCAP_DONT_SAVE) & ~(FCAP_FORCE_TRANSITION | FCAP_ACROSS_TRANSITION | FCAP_MUST_SPAWN | FCAP_SAVE_NON_NETWORKABLE));
}
void CPhysicsShadowClone::SetCloneTransformationMatrix( const matrix3x4_t &sourceMatrix )
{
m_matrixShadowTransform = sourceMatrix;
m_bShadowTransformIsIdentity = m_matrixShadowTransform.IsIdentity();
if( m_matrixShadowTransform.InverseGeneral( m_matrixShadowTransform_Inverse ) == false )
{
m_matrixShadowTransform.InverseTR( m_matrixShadowTransform_Inverse ); //probably not the right matrix, but we're out of options
}
FullSync();
//PartialSync( true );
}
void CPhysicsShadowClone::SetClonedEntity( EHANDLE hEntToClone )
{
VPhysicsDestroyObject();
m_hClonedEntity = hEntToClone;
//FullSyncClonedPhysicsObjects();
}
EHANDLE CPhysicsShadowClone::GetClonedEntity( void )
{
return m_hClonedEntity;
}
//damage relays to source entity
bool CPhysicsShadowClone::PassesDamageFilter( const CTakeDamageInfo &info )
{
CBaseEntity *pClonedEntity = m_hClonedEntity.Get();
if( pClonedEntity )
return pClonedEntity->PassesDamageFilter( info );
else
return BaseClass::PassesDamageFilter( info );
}
bool CPhysicsShadowClone::CanBeHitByMeleeAttack( CBaseEntity *pAttacker )
{
CBaseEntity *pClonedEntity = m_hClonedEntity.Get();
if( pClonedEntity )
return pClonedEntity->CanBeHitByMeleeAttack( pAttacker );
else
return BaseClass::CanBeHitByMeleeAttack( pAttacker );
}
int CPhysicsShadowClone::OnTakeDamage( const CTakeDamageInfo &info )
{
CBaseEntity *pClonedEntity = m_hClonedEntity.Get();
if( pClonedEntity )
return pClonedEntity->OnTakeDamage( info );
else
return BaseClass::OnTakeDamage( info );
}
int CPhysicsShadowClone::TakeHealth( float flHealth, int bitsDamageType )
{
CBaseEntity *pClonedEntity = m_hClonedEntity.Get();
if( pClonedEntity )
return pClonedEntity->TakeHealth( flHealth, bitsDamageType );
else
return BaseClass::TakeHealth( flHealth, bitsDamageType );
}
void CPhysicsShadowClone::Event_Killed( const CTakeDamageInfo &info )
{
CBaseEntity *pClonedEntity = m_hClonedEntity.Get();
if( pClonedEntity )
pClonedEntity->Event_Killed( info );
else
BaseClass::Event_Killed( info );
}
CPhysicsShadowClone *CPhysicsShadowClone::CreateShadowClone( IPhysicsEnvironment *pInPhysicsEnvironment, EHANDLE hEntToClone, const char *szDebugMarker, const matrix3x4_t *pTransformationMatrix /*= NULL*/ )
{
AssertMsg( szDebugMarker != NULL, "All shadow clones must have a debug marker for where it came from in debug builds." );
if( !sv_use_shadow_clones.GetBool() )
return NULL;
CBaseEntity *pClonedEntity = hEntToClone.Get();
if( pClonedEntity == NULL )
return NULL;
AssertMsg( IsShadowClone( pClonedEntity ) == false, "Shouldn't attempt to clone clones" );
if( pClonedEntity->IsMarkedForDeletion() )
return NULL;
//if( pClonedEntity->IsPlayer() )
// return NULL;
IPhysicsObject *pPhysics = pClonedEntity->VPhysicsGetObject();
if( pPhysics == NULL )
return NULL;
if( pPhysics->IsStatic() )
return NULL;
if( pClonedEntity->GetSolid() == SOLID_BSP )
return NULL;
if( pClonedEntity->GetSolidFlags() & (FSOLID_NOT_SOLID | FSOLID_TRIGGER) )
return NULL;
if( pClonedEntity->GetFlags() & (FL_WORLDBRUSH | FL_STATICPROP) )
return NULL;
/*if( FClassnameIs( pClonedEntity, "func_door" ) )
{
//only clone func_door's that are in front of the portal
return NULL;
}*/
// Too many shadow clones breaks the game (too many entities)
if( g_iShadowCloneCount >= MAX_SHADOW_CLONE_COUNT )
{
AssertMsg( false, "Too many shadow clones, consider upping the limit or reducing the level's physics props" );
return NULL;
}
++g_iShadowCloneCount;
CPhysicsShadowClone *pClone = (CPhysicsShadowClone*)CreateEntityByName("physicsshadowclone");
s_IsShadowClone[pClone->entindex()] = true;
pClone->m_pOwnerPhysEnvironment = pInPhysicsEnvironment;
pClone->m_hClonedEntity = hEntToClone;
DBG_CODE_NOSCOPE( pClone->m_szDebugMarker = szDebugMarker; );
CPhysicsShadowCloneLL *pCloneLLEntry = s_SCLLManager.Alloc();
pCloneLLEntry->pClone = pClone;
pCloneLLEntry->pNext = s_EntityClones[pClonedEntity->entindex()];
s_EntityClones[pClonedEntity->entindex()] = pCloneLLEntry;
if( pTransformationMatrix )
{
pClone->m_matrixShadowTransform = *pTransformationMatrix;
pClone->m_bShadowTransformIsIdentity = pClone->m_matrixShadowTransform.IsIdentity();
if( !pClone->m_bShadowTransformIsIdentity )
{
if( pClone->m_matrixShadowTransform.InverseGeneral( pClone->m_matrixShadowTransform_Inverse ) == false )
{
pClone->m_matrixShadowTransform.InverseTR( pClone->m_matrixShadowTransform_Inverse ); //probably not the right matrix, but we're out of options
}
}
}
DispatchSpawn( pClone );
return pClone;
}
void CPhysicsShadowClone::Free( void )
{
VPhysicsDestroyObject();
UTIL_Remove( this );
//Too many shadow clones breaks the game (too many entities)
--g_iShadowCloneCount;
}
void CPhysicsShadowClone::FullSyncAllClones( void )
{
for( int i = s_ActiveShadowClones.Count(); --i >= 0; )
{
s_ActiveShadowClones[i]->FullSync( true );
}
}
IPhysicsObject *CPhysicsShadowClone::TranslatePhysicsToClonedEnt( const IPhysicsObject *pPhysics )
{
if( m_hClonedEntity.Get() != NULL )
{
for( int i = m_CloneLinks.Count(); --i >= 0; )
{
if( m_CloneLinks[i].pClone == pPhysics )
return m_CloneLinks[i].pSource;
}
}
return NULL;
}
void CPhysicsShadowClone::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
//the baseclass just screenshakes, makes sounds, and outputs dust, we rely on the original entity to do this when applicable
}
bool CPhysicsShadowClone::IsShadowClone( const CBaseEntity *pEntity )
{
return s_IsShadowClone[pEntity->entindex()];
}
CPhysicsShadowCloneLL *CPhysicsShadowClone::GetClonesOfEntity( const CBaseEntity *pEntity )
{
return s_EntityClones[pEntity->entindex()];
}
static void DrawDebugOverlayForShadowClone( CPhysicsShadowClone *pClone )
{
unsigned char iColorIntensity = (pClone->IsInAssumedSyncState())?(127):(255);
int iRed = (pClone->IsUntransformedClone())?(0):(iColorIntensity);
int iGreen = iColorIntensity;
int iBlue = iColorIntensity;
NDebugOverlay::EntityBounds( pClone, iRed, iGreen, iBlue, (iColorIntensity>>2), 0.05f );
}
bool CTraceFilterTranslateClones::ShouldHitEntity( IHandleEntity *pEntity, int contentsMask )
{
CBaseEntity *pEnt = EntityFromEntityHandle( pEntity );
if( CPhysicsShadowClone::IsShadowClone( pEnt ) )
{
CBaseEntity *pClonedEntity = ((CPhysicsShadowClone *)pEnt)->GetClonedEntity();
CPortalSimulator *pSimulator = CPortalSimulator::GetSimulatorThatOwnsEntity( pClonedEntity );
if( pSimulator->m_DataAccess.Simulation.Dynamic.EntFlags[pClonedEntity->entindex()] & PSEF_IS_IN_PORTAL_HOLE )
return m_pActualFilter->ShouldHitEntity( pClonedEntity, contentsMask );
else
return false;
}
else
{
return m_pActualFilter->ShouldHitEntity( pEntity, contentsMask );
}
}
TraceType_t CTraceFilterTranslateClones::GetTraceType() const
{
return m_pActualFilter->GetTraceType();
}