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.
 
 
 
 
 
 

6519 lines
181 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include "cbase.h"
#include "c_baseentity.h"
#include "prediction.h"
#include "model_types.h"
#include "iviewrender_beams.h"
#include "dlight.h"
#include "iviewrender.h"
#include "view.h"
#include "iefx.h"
#include "c_team.h"
#include "clientmode.h"
#include "usercmd.h"
#include "engine/IEngineSound.h"
#include "engine/IEngineTrace.h"
#include "engine/ivmodelinfo.h"
#include "tier0/vprof.h"
#include "fx_line.h"
#include "interface.h"
#include "materialsystem/imaterialsystem.h"
#include "soundinfo.h"
#include "mathlib/vmatrix.h"
#include "isaverestore.h"
#include "interval.h"
#include "engine/ivdebugoverlay.h"
#include "c_ai_basenpc.h"
#include "apparent_velocity_helper.h"
#include "c_baseanimatingoverlay.h"
#include "tier1/KeyValues.h"
#include "hltvcamera.h"
#include "datacache/imdlcache.h"
#include "toolframework/itoolframework.h"
#include "toolframework_client.h"
#include "decals.h"
#include "cdll_bounded_cvars.h"
#include "inetchannelinfo.h"
#include "proto_version.h"
#ifdef TF_CLIENT_DLL
#include "c_tf_player.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#ifdef INTERPOLATEDVAR_PARANOID_MEASUREMENT
int g_nInterpolatedVarsChanged = 0;
bool g_bRestoreInterpolatedVarValues = false;
#endif
static bool g_bWasSkipping = (bool)-1;
static bool g_bWasThreaded =(bool)-1;
static int g_nThreadModeTicks = 0;
void cc_cl_interp_all_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
ConVarRef var( pConVar );
if ( var.GetInt() )
{
C_BaseEntityIterator iterator;
C_BaseEntity *pEnt;
while ( (pEnt = iterator.Next()) != NULL )
{
if ( pEnt->ShouldInterpolate() )
{
pEnt->AddToInterpolationList();
}
}
}
}
static ConVar cl_extrapolate( "cl_extrapolate", "1", FCVAR_CHEAT, "Enable/disable extrapolation if interpolation history runs out." );
static ConVar cl_interp_npcs( "cl_interp_npcs", "0.0", FCVAR_USERINFO, "Interpolate NPC positions starting this many seconds in past (or cl_interp, if greater)" );
static ConVar cl_interp_all( "cl_interp_all", "0", 0, "Disable interpolation list optimizations.", 0, 0, 0, 0, cc_cl_interp_all_changed );
ConVar r_drawmodeldecals( "r_drawmodeldecals", "1", FCVAR_ALLOWED_IN_COMPETITIVE );
extern ConVar cl_showerror;
int C_BaseEntity::m_nPredictionRandomSeed = -1;
C_BasePlayer *C_BaseEntity::m_pPredictionPlayer = NULL;
bool C_BaseEntity::s_bAbsQueriesValid = true;
bool C_BaseEntity::s_bAbsRecomputationEnabled = true;
bool C_BaseEntity::s_bInterpolate = true;
bool C_BaseEntity::sm_bDisableTouchFuncs = false; // Disables PhysicsTouch and PhysicsStartTouch function calls
static ConVar r_drawrenderboxes( "r_drawrenderboxes", "0", FCVAR_CHEAT );
static bool g_bAbsRecomputationStack[8];
static unsigned short g_iAbsRecomputationStackPos = 0;
// All the entities that want Interpolate() called on them.
static CUtlLinkedList<C_BaseEntity*, unsigned short> g_InterpolationList;
static CUtlLinkedList<C_BaseEntity*, unsigned short> g_TeleportList;
#if !defined( NO_ENTITY_PREDICTION )
//-----------------------------------------------------------------------------
// Purpose: Maintains a list of predicted or client created entities
//-----------------------------------------------------------------------------
class CPredictableList : public IPredictableList
{
public:
virtual C_BaseEntity *GetPredictable( int slot );
virtual int GetPredictableCount( void );
protected:
void AddToPredictableList( ClientEntityHandle_t add );
void RemoveFromPredictablesList( ClientEntityHandle_t remove );
private:
CUtlVector< ClientEntityHandle_t > m_Predictables;
friend class C_BaseEntity;
};
// Create singleton
static CPredictableList g_Predictables;
IPredictableList *predictables = &g_Predictables;
//-----------------------------------------------------------------------------
// Purpose: Add entity to list
// Input : add -
// Output : int
//-----------------------------------------------------------------------------
void CPredictableList::AddToPredictableList( ClientEntityHandle_t add )
{
// This is a hack to remap slot to index
if ( m_Predictables.Find( add ) != m_Predictables.InvalidIndex() )
{
return;
}
// Add to general list
m_Predictables.AddToTail( add );
// Maintain sort order by entindex
int count = m_Predictables.Size();
if ( count < 2 )
return;
int i, j;
for ( i = 0; i < count; i++ )
{
for ( j = i + 1; j < count; j++ )
{
ClientEntityHandle_t h1 = m_Predictables[ i ];
ClientEntityHandle_t h2 = m_Predictables[ j ];
C_BaseEntity *p1 = cl_entitylist->GetBaseEntityFromHandle( h1 );
C_BaseEntity *p2 = cl_entitylist->GetBaseEntityFromHandle( h2 );
if ( !p1 || !p2 )
{
Assert( 0 );
continue;
}
if ( p1->entindex() != -1 &&
p2->entindex() != -1 )
{
if ( p1->entindex() < p2->entindex() )
continue;
}
if ( p2->entindex() == -1 )
continue;
m_Predictables[ i ] = h2;
m_Predictables[ j ] = h1;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : remove -
//-----------------------------------------------------------------------------
void CPredictableList::RemoveFromPredictablesList( ClientEntityHandle_t remove )
{
m_Predictables.FindAndRemove( remove );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : slot -
// Output : C_BaseEntity
//-----------------------------------------------------------------------------
C_BaseEntity *CPredictableList::GetPredictable( int slot )
{
return cl_entitylist->GetBaseEntityFromHandle( m_Predictables[ slot ] );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CPredictableList::GetPredictableCount( void )
{
return m_Predictables.Count();
}
//-----------------------------------------------------------------------------
// Purpose: Searc predictables for previously created entity (by testId)
// Input : testId -
// Output : static C_BaseEntity
//-----------------------------------------------------------------------------
static C_BaseEntity *FindPreviouslyCreatedEntity( CPredictableId& testId )
{
int c = predictables->GetPredictableCount();
int i;
for ( i = 0; i < c; i++ )
{
C_BaseEntity *e = predictables->GetPredictable( i );
if ( !e || !e->IsClientCreated() )
continue;
// Found it, note use of operator ==
if ( testId == e->m_PredictableID )
{
return e;
}
}
return NULL;
}
#endif
abstract_class IRecordingList
{
public:
virtual ~IRecordingList() {};
virtual void AddToList( ClientEntityHandle_t add ) = 0;
virtual void RemoveFromList( ClientEntityHandle_t remove ) = 0;
virtual int Count() = 0;
virtual IClientRenderable *Get( int index ) = 0;
};
class CRecordingList : public IRecordingList
{
public:
virtual void AddToList( ClientEntityHandle_t add );
virtual void RemoveFromList( ClientEntityHandle_t remove );
virtual int Count();
IClientRenderable *Get( int index );
private:
CUtlVector< ClientEntityHandle_t > m_Recording;
};
static CRecordingList g_RecordingList;
IRecordingList *recordinglist = &g_RecordingList;
//-----------------------------------------------------------------------------
// Purpose: Add entity to list
// Input : add -
// Output : int
//-----------------------------------------------------------------------------
void CRecordingList::AddToList( ClientEntityHandle_t add )
{
// This is a hack to remap slot to index
if ( m_Recording.Find( add ) != m_Recording.InvalidIndex() )
{
return;
}
// Add to general list
m_Recording.AddToTail( add );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : remove -
//-----------------------------------------------------------------------------
void CRecordingList::RemoveFromList( ClientEntityHandle_t remove )
{
m_Recording.FindAndRemove( remove );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : slot -
// Output : IClientRenderable
//-----------------------------------------------------------------------------
IClientRenderable *CRecordingList::Get( int index )
{
return cl_entitylist->GetClientRenderableFromHandle( m_Recording[ index ] );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CRecordingList::Count()
{
return m_Recording.Count();
}
// Should these be somewhere else?
#define PITCH 0
//-----------------------------------------------------------------------------
// Purpose: Decodes animtime and notes when it changes
// Input : *pStruct - ( C_BaseEntity * ) used to flag animtime is changine
// *pVarData -
// *pIn -
// objectID -
//-----------------------------------------------------------------------------
void RecvProxy_AnimTime( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
C_BaseEntity *pEntity = ( C_BaseEntity * )pStruct;
Assert( pOut == &pEntity->m_flAnimTime );
int t;
int tickbase;
int addt;
// Unpack the data.
addt = pData->m_Value.m_Int;
// Note, this needs to be encoded relative to packet timestamp, not raw client clock
tickbase = gpGlobals->GetNetworkBase( gpGlobals->tickcount, pEntity->entindex() );
t = tickbase;
// and then go back to floating point time.
t += addt; // Add in an additional up to 256 100ths from the server
// center m_flAnimTime around current time.
while (t < gpGlobals->tickcount - 127)
t += 256;
while (t > gpGlobals->tickcount + 127)
t -= 256;
pEntity->m_flAnimTime = ( t * TICK_INTERVAL );
}
void RecvProxy_SimulationTime( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
C_BaseEntity *pEntity = ( C_BaseEntity * )pStruct;
Assert( pOut == &pEntity->m_flSimulationTime );
int t;
int tickbase;
int addt;
// Unpack the data.
addt = pData->m_Value.m_Int;
// Note, this needs to be encoded relative to packet timestamp, not raw client clock
tickbase = gpGlobals->GetNetworkBase( gpGlobals->tickcount, pEntity->entindex() );
t = tickbase;
// and then go back to floating point time.
t += addt; // Add in an additional up to 256 100ths from the server
// center m_flSimulationTime around current time.
while (t < gpGlobals->tickcount - 127)
t += 256;
while (t > gpGlobals->tickcount + 127)
t -= 256;
pEntity->m_flSimulationTime = ( t * TICK_INTERVAL );
}
void RecvProxy_LocalVelocity( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
CBaseEntity *pEnt = (CBaseEntity *)pStruct;
Vector vecVelocity;
vecVelocity.x = pData->m_Value.m_Vector[0];
vecVelocity.y = pData->m_Value.m_Vector[1];
vecVelocity.z = pData->m_Value.m_Vector[2];
// SetLocalVelocity checks to see if the value has changed
pEnt->SetLocalVelocity( vecVelocity );
}
void RecvProxy_ToolRecording( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
if ( !ToolsEnabled() )
return;
CBaseEntity *pEnt = (CBaseEntity *)pStruct;
pEnt->SetToolRecording( pData->m_Value.m_Int != 0 );
}
// Expose it to the engine.
IMPLEMENT_CLIENTCLASS(C_BaseEntity, DT_BaseEntity, CBaseEntity);
static void RecvProxy_MoveType( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
((C_BaseEntity*)pStruct)->SetMoveType( (MoveType_t)(pData->m_Value.m_Int) );
}
static void RecvProxy_MoveCollide( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
((C_BaseEntity*)pStruct)->SetMoveCollide( (MoveCollide_t)(pData->m_Value.m_Int) );
}
static void RecvProxy_Solid( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
((C_BaseEntity*)pStruct)->SetSolid( (SolidType_t)pData->m_Value.m_Int );
}
static void RecvProxy_SolidFlags( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
((C_BaseEntity*)pStruct)->SetSolidFlags( pData->m_Value.m_Int );
}
void RecvProxy_EffectFlags( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
((C_BaseEntity*)pStruct)->SetEffects( pData->m_Value.m_Int );
}
BEGIN_RECV_TABLE_NOBASE( C_BaseEntity, DT_AnimTimeMustBeFirst )
RecvPropInt( RECVINFO(m_flAnimTime), 0, RecvProxy_AnimTime ),
END_RECV_TABLE()
#ifndef NO_ENTITY_PREDICTION
BEGIN_RECV_TABLE_NOBASE( C_BaseEntity, DT_PredictableId )
RecvPropPredictableId( RECVINFO( m_PredictableID ) ),
RecvPropInt( RECVINFO( m_bIsPlayerSimulated ) ),
END_RECV_TABLE()
#endif
BEGIN_RECV_TABLE_NOBASE(C_BaseEntity, DT_BaseEntity)
RecvPropDataTable( "AnimTimeMustBeFirst", 0, 0, &REFERENCE_RECV_TABLE(DT_AnimTimeMustBeFirst) ),
RecvPropInt( RECVINFO(m_flSimulationTime), 0, RecvProxy_SimulationTime ),
RecvPropInt( RECVINFO( m_ubInterpolationFrame ) ),
RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
#if PREDICTION_ERROR_CHECK_LEVEL > 1
RecvPropVector( RECVINFO_NAME( m_angNetworkAngles, m_angRotation ) ),
#else
RecvPropQAngles( RECVINFO_NAME( m_angNetworkAngles, m_angRotation ) ),
#endif
#ifdef DEMO_BACKWARDCOMPATABILITY
RecvPropInt( RECVINFO(m_nModelIndex), 0, RecvProxy_IntToModelIndex16_BackCompatible ),
#else
RecvPropInt( RECVINFO(m_nModelIndex) ),
#endif
RecvPropInt(RECVINFO(m_fEffects), 0, RecvProxy_EffectFlags ),
RecvPropInt(RECVINFO(m_nRenderMode)),
RecvPropInt(RECVINFO(m_nRenderFX)),
RecvPropInt(RECVINFO(m_clrRender)),
RecvPropInt(RECVINFO(m_iTeamNum)),
RecvPropInt(RECVINFO(m_CollisionGroup)),
RecvPropFloat(RECVINFO(m_flElasticity)),
RecvPropFloat(RECVINFO(m_flShadowCastDistance)),
RecvPropEHandle( RECVINFO(m_hOwnerEntity) ),
RecvPropEHandle( RECVINFO(m_hEffectEntity) ),
RecvPropInt( RECVINFO_NAME(m_hNetworkMoveParent, moveparent), 0, RecvProxy_IntToMoveParent ),
RecvPropInt( RECVINFO( m_iParentAttachment ) ),
RecvPropInt( "movetype", 0, SIZEOF_IGNORE, 0, RecvProxy_MoveType ),
RecvPropInt( "movecollide", 0, SIZEOF_IGNORE, 0, RecvProxy_MoveCollide ),
RecvPropDataTable( RECVINFO_DT( m_Collision ), 0, &REFERENCE_RECV_TABLE(DT_CollisionProperty) ),
RecvPropInt( RECVINFO ( m_iTextureFrameIndex ) ),
#if !defined( NO_ENTITY_PREDICTION )
RecvPropDataTable( "predictable_id", 0, 0, &REFERENCE_RECV_TABLE( DT_PredictableId ) ),
#endif
RecvPropInt ( RECVINFO( m_bSimulatedEveryTick ), 0, RecvProxy_InterpolationAmountChanged ),
RecvPropInt ( RECVINFO( m_bAnimatedEveryTick ), 0, RecvProxy_InterpolationAmountChanged ),
RecvPropBool ( RECVINFO( m_bAlternateSorting ) ),
#ifdef TF_CLIENT_DLL
RecvPropArray3( RECVINFO_ARRAY(m_nModelIndexOverrides), RecvPropInt( RECVINFO(m_nModelIndexOverrides[0]) ) ),
#endif
END_RECV_TABLE()
const float coordTolerance = 2.0f / (float)( 1 << COORD_FRACTIONAL_BITS );
BEGIN_PREDICTION_DATA_NO_BASE( C_BaseEntity )
// These have a special proxy to handle send/receive
DEFINE_PRED_TYPEDESCRIPTION( m_Collision, CCollisionProperty ),
DEFINE_PRED_FIELD( m_MoveType, FIELD_CHARACTER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_MoveCollide, FIELD_CHARACTER, FTYPEDESC_INSENDTABLE ),
DEFINE_FIELD( m_vecAbsVelocity, FIELD_VECTOR ),
DEFINE_PRED_FIELD_TOL( m_vecVelocity, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 0.5f ),
// DEFINE_PRED_FIELD( m_fEffects, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nRenderMode, FIELD_CHARACTER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nRenderFX, FIELD_CHARACTER, FTYPEDESC_INSENDTABLE ),
// DEFINE_PRED_FIELD( m_flAnimTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
// DEFINE_PRED_FIELD( m_flSimulationTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_fFlags, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD_TOL( m_vecViewOffset, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 0.25f ),
DEFINE_PRED_FIELD( m_nModelIndex, FIELD_SHORT, FTYPEDESC_INSENDTABLE | FTYPEDESC_MODELINDEX ),
DEFINE_PRED_FIELD( m_flFriction, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_iTeamNum, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_hOwnerEntity, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
// DEFINE_FIELD( m_nSimulationTick, FIELD_INTEGER ),
DEFINE_PRED_FIELD( m_hNetworkMoveParent, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
// DEFINE_PRED_FIELD( m_pMoveParent, FIELD_EHANDLE ),
// DEFINE_PRED_FIELD( m_pMoveChild, FIELD_EHANDLE ),
// DEFINE_PRED_FIELD( m_pMovePeer, FIELD_EHANDLE ),
// DEFINE_PRED_FIELD( m_pMovePrevPeer, FIELD_EHANDLE ),
DEFINE_PRED_FIELD_TOL( m_vecNetworkOrigin, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, coordTolerance ),
DEFINE_PRED_FIELD( m_angNetworkAngles, FIELD_VECTOR, FTYPEDESC_INSENDTABLE | FTYPEDESC_NOERRORCHECK ),
DEFINE_FIELD( m_vecAbsOrigin, FIELD_VECTOR ),
DEFINE_FIELD( m_angAbsRotation, FIELD_VECTOR ),
DEFINE_FIELD( m_vecOrigin, FIELD_VECTOR ),
DEFINE_FIELD( m_angRotation, FIELD_VECTOR ),
// DEFINE_FIELD( m_hGroundEntity, FIELD_EHANDLE ),
DEFINE_FIELD( m_nWaterLevel, FIELD_CHARACTER ),
DEFINE_FIELD( m_nWaterType, FIELD_CHARACTER ),
DEFINE_FIELD( m_vecAngVelocity, FIELD_VECTOR ),
// DEFINE_FIELD( m_vecAbsAngVelocity, FIELD_VECTOR ),
// DEFINE_FIELD( model, FIELD_INTEGER ), // writing pointer literally
// DEFINE_FIELD( index, FIELD_INTEGER ),
// DEFINE_FIELD( m_ClientHandle, FIELD_SHORT ),
// DEFINE_FIELD( m_Partition, FIELD_SHORT ),
// DEFINE_FIELD( m_hRender, FIELD_SHORT ),
DEFINE_FIELD( m_bDormant, FIELD_BOOLEAN ),
// DEFINE_FIELD( current_position, FIELD_INTEGER ),
// DEFINE_FIELD( m_flLastMessageTime, FIELD_FLOAT ),
DEFINE_FIELD( m_vecBaseVelocity, FIELD_VECTOR ),
DEFINE_FIELD( m_iEFlags, FIELD_INTEGER ),
DEFINE_FIELD( m_flGravity, FIELD_FLOAT ),
// DEFINE_FIELD( m_ModelInstance, FIELD_SHORT ),
DEFINE_FIELD( m_flProxyRandomValue, FIELD_FLOAT ),
// DEFINE_FIELD( m_PredictableID, FIELD_INTEGER ),
// DEFINE_FIELD( m_pPredictionContext, FIELD_POINTER ),
// Stuff specific to rendering and therefore not to be copied back and forth
// DEFINE_PRED_FIELD( m_clrRender, color32, FTYPEDESC_INSENDTABLE ),
// DEFINE_FIELD( m_bReadyToDraw, FIELD_BOOLEAN ),
// DEFINE_FIELD( anim, CLatchedAnim ),
// DEFINE_FIELD( mouth, CMouthInfo ),
// DEFINE_FIELD( GetAbsOrigin(), FIELD_VECTOR ),
// DEFINE_FIELD( GetAbsAngles(), FIELD_VECTOR ),
// DEFINE_FIELD( m_nNumAttachments, FIELD_SHORT ),
// DEFINE_FIELD( m_pAttachmentAngles, FIELD_VECTOR ),
// DEFINE_FIELD( m_pAttachmentOrigin, FIELD_VECTOR ),
// DEFINE_FIELD( m_listentry, CSerialEntity ),
// DEFINE_FIELD( m_ShadowHandle, ClientShadowHandle_t ),
// DEFINE_FIELD( m_hThink, ClientThinkHandle_t ),
// Definitely private and not copied around
// DEFINE_FIELD( m_bPredictable, FIELD_BOOLEAN ),
// DEFINE_FIELD( m_CollisionGroup, FIELD_INTEGER ),
// DEFINE_FIELD( m_DataChangeEventRef, FIELD_INTEGER ),
#if !defined( CLIENT_DLL )
// DEFINE_FIELD( m_bPredictionEligible, FIELD_BOOLEAN ),
#endif
END_PREDICTION_DATA()
//-----------------------------------------------------------------------------
// Helper functions.
//-----------------------------------------------------------------------------
void SpewInterpolatedVar( CInterpolatedVar< Vector > *pVar )
{
Msg( "--------------------------------------------------\n" );
int i = pVar->GetHead();
Vector v0(0, 0, 0);
CApparentVelocity<Vector> apparent(v0);
float prevtime = 0.0f;
while ( 1 )
{
float changetime;
Vector *pVal = pVar->GetHistoryValue( i, changetime );
if ( !pVal )
break;
float vel = apparent.AddSample( changetime, *pVal );
Msg( "%6.6f: (%.2f %.2f %.2f), vel: %.2f [dt %.1f]\n", changetime, VectorExpand( *pVal ), vel, prevtime == 0.0f ? 0.0f : 1000.0f * ( changetime - prevtime ) );
i = pVar->GetNext( i );
prevtime = changetime;
}
Msg( "--------------------------------------------------\n" );
}
void SpewInterpolatedVar( CInterpolatedVar< Vector > *pVar, float flNow, float flInterpAmount, bool bSpewAllEntries = true )
{
float target = flNow - flInterpAmount;
Msg( "--------------------------------------------------\n" );
int i = pVar->GetHead();
Vector v0(0, 0, 0);
CApparentVelocity<Vector> apparent(v0);
float newtime = 999999.0f;
Vector newVec( 0, 0, 0 );
bool bSpew = true;
while ( 1 )
{
float changetime;
Vector *pVal = pVar->GetHistoryValue( i, changetime );
if ( !pVal )
break;
if ( bSpew && target >= changetime )
{
Vector o;
pVar->DebugInterpolate( &o, flNow );
bool bInterp = newtime != 999999.0f;
float frac = 0.0f;
char desc[ 32 ];
if ( bInterp )
{
frac = ( target - changetime ) / ( newtime - changetime );
Q_snprintf( desc, sizeof( desc ), "interpolated [%.2f]", frac );
}
else
{
bSpew = true;
int savei = i;
i = pVar->GetNext( i );
float oldtertime = 0.0f;
pVar->GetHistoryValue( i, oldtertime );
if ( changetime != oldtertime )
{
frac = ( target - changetime ) / ( changetime - oldtertime );
}
Q_snprintf( desc, sizeof( desc ), "extrapolated [%.2f]", frac );
i = savei;
}
if ( bSpew )
{
Msg( " > %6.6f: (%.2f %.2f %.2f) %s for %.1f msec\n",
target,
VectorExpand( o ),
desc,
1000.0f * ( target - changetime ) );
bSpew = false;
}
}
float vel = apparent.AddSample( changetime, *pVal );
if ( bSpewAllEntries )
{
Msg( " %6.6f: (%.2f %.2f %.2f), vel: %.2f [dt %.1f]\n", changetime, VectorExpand( *pVal ), vel, newtime == 999999.0f ? 0.0f : 1000.0f * ( newtime - changetime ) );
}
i = pVar->GetNext( i );
newtime = changetime;
newVec = *pVal;
}
Msg( "--------------------------------------------------\n" );
}
void SpewInterpolatedVar( CInterpolatedVar< float > *pVar )
{
Msg( "--------------------------------------------------\n" );
int i = pVar->GetHead();
CApparentVelocity<float> apparent(0.0f);
while ( 1 )
{
float changetime;
float *pVal = pVar->GetHistoryValue( i, changetime );
if ( !pVal )
break;
float vel = apparent.AddSample( changetime, *pVal );
Msg( "%6.6f: (%.2f), vel: %.2f\n", changetime, *pVal, vel );
i = pVar->GetNext( i );
}
Msg( "--------------------------------------------------\n" );
}
template<class T>
void GetInterpolatedVarTimeRange( CInterpolatedVar<T> *pVar, float &flMin, float &flMax )
{
flMin = 1e23;
flMax = -1e23;
int i = pVar->GetHead();
Vector v0(0, 0, 0);
CApparentVelocity<Vector> apparent(v0);
while ( 1 )
{
float changetime;
if ( !pVar->GetHistoryValue( i, changetime ) )
return;
flMin = MIN( flMin, changetime );
flMax = MAX( flMax, changetime );
i = pVar->GetNext( i );
}
}
//-----------------------------------------------------------------------------
// Global methods related to when abs data is correct
//-----------------------------------------------------------------------------
void C_BaseEntity::SetAbsQueriesValid( bool bValid )
{
// @MULTICORE: Always allow in worker threads, assume higher level code is handling correctly
if ( !ThreadInMainThread() )
return;
if ( !bValid )
{
s_bAbsQueriesValid = false;
}
else
{
s_bAbsQueriesValid = true;
}
}
bool C_BaseEntity::IsAbsQueriesValid( void )
{
if ( !ThreadInMainThread() )
return true;
return s_bAbsQueriesValid;
}
void C_BaseEntity::PushEnableAbsRecomputations( bool bEnable )
{
if ( !ThreadInMainThread() )
return;
if ( g_iAbsRecomputationStackPos < ARRAYSIZE( g_bAbsRecomputationStack ) )
{
g_bAbsRecomputationStack[g_iAbsRecomputationStackPos] = s_bAbsRecomputationEnabled;
++g_iAbsRecomputationStackPos;
s_bAbsRecomputationEnabled = bEnable;
}
else
{
Assert( false );
}
}
void C_BaseEntity::PopEnableAbsRecomputations()
{
if ( !ThreadInMainThread() )
return;
if ( g_iAbsRecomputationStackPos > 0 )
{
--g_iAbsRecomputationStackPos;
s_bAbsRecomputationEnabled = g_bAbsRecomputationStack[g_iAbsRecomputationStackPos];
}
else
{
Assert( false );
}
}
void C_BaseEntity::EnableAbsRecomputations( bool bEnable )
{
if ( !ThreadInMainThread() )
return;
// This should only be called at the frame level. Use PushEnableAbsRecomputations
// if you're blocking out a section of code.
Assert( g_iAbsRecomputationStackPos == 0 );
s_bAbsRecomputationEnabled = bEnable;
}
bool C_BaseEntity::IsAbsRecomputationsEnabled()
{
if ( !ThreadInMainThread() )
return true;
return s_bAbsRecomputationEnabled;
}
int C_BaseEntity::GetTextureFrameIndex( void )
{
return m_iTextureFrameIndex;
}
void C_BaseEntity::SetTextureFrameIndex( int iIndex )
{
m_iTextureFrameIndex = iIndex;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *map -
//-----------------------------------------------------------------------------
void C_BaseEntity::Interp_SetupMappings( VarMapping_t *map )
{
if( !map )
return;
int c = map->m_Entries.Count();
for ( int i = 0; i < c; i++ )
{
VarMapEntry_t *e = &map->m_Entries[ i ];
IInterpolatedVar *watcher = e->watcher;
void *data = e->data;
int type = e->type;
watcher->Setup( data, type );
watcher->SetInterpolationAmount( GetInterpolationAmount( watcher->GetType() ) );
}
}
void C_BaseEntity::Interp_RestoreToLastNetworked( VarMapping_t *map )
{
VPROF( "C_BaseEntity::Interp_RestoreToLastNetworked" );
PREDICTION_TRACKVALUECHANGESCOPE_ENTITY( this, "restoretolastnetworked" );
Vector oldOrigin = GetLocalOrigin();
QAngle oldAngles = GetLocalAngles();
Vector oldVel = GetLocalVelocity();
int c = map->m_Entries.Count();
for ( int i = 0; i < c; i++ )
{
VarMapEntry_t *e = &map->m_Entries[ i ];
IInterpolatedVar *watcher = e->watcher;
watcher->RestoreToLastNetworked();
}
BaseInterpolatePart2( oldOrigin, oldAngles, oldVel, 0 );
}
void C_BaseEntity::Interp_UpdateInterpolationAmounts( VarMapping_t *map )
{
if( !map )
return;
int c = map->m_Entries.Count();
for ( int i = 0; i < c; i++ )
{
VarMapEntry_t *e = &map->m_Entries[ i ];
IInterpolatedVar *watcher = e->watcher;
watcher->SetInterpolationAmount( GetInterpolationAmount( watcher->GetType() ) );
}
}
void C_BaseEntity::Interp_HierarchyUpdateInterpolationAmounts()
{
Interp_UpdateInterpolationAmounts( GetVarMapping() );
for ( C_BaseEntity *pChild = FirstMoveChild(); pChild; pChild = pChild->NextMovePeer() )
{
pChild->Interp_HierarchyUpdateInterpolationAmounts();
}
}
inline int C_BaseEntity::Interp_Interpolate( VarMapping_t *map, float currentTime )
{
int bNoMoreChanges = 1;
if ( currentTime < map->m_lastInterpolationTime )
{
for ( int i = 0; i < map->m_nInterpolatedEntries; i++ )
{
VarMapEntry_t *e = &map->m_Entries[ i ];
e->m_bNeedsToInterpolate = true;
}
}
map->m_lastInterpolationTime = currentTime;
for ( int i = 0; i < map->m_nInterpolatedEntries; i++ )
{
VarMapEntry_t *e = &map->m_Entries[ i ];
if ( !e->m_bNeedsToInterpolate )
continue;
IInterpolatedVar *watcher = e->watcher;
Assert( !( watcher->GetType() & EXCLUDE_AUTO_INTERPOLATE ) );
if ( watcher->Interpolate( currentTime ) )
e->m_bNeedsToInterpolate = false;
else
bNoMoreChanges = 0;
}
return bNoMoreChanges;
}
//-----------------------------------------------------------------------------
// Functions.
//-----------------------------------------------------------------------------
C_BaseEntity::C_BaseEntity() :
m_iv_vecOrigin( "C_BaseEntity::m_iv_vecOrigin" ),
m_iv_angRotation( "C_BaseEntity::m_iv_angRotation" ),
m_iv_vecVelocity( "C_BaseEntity::m_iv_vecVelocity" )
{
m_pAttributes = NULL;
AddVar( &m_vecOrigin, &m_iv_vecOrigin, LATCH_SIMULATION_VAR );
AddVar( &m_angRotation, &m_iv_angRotation, LATCH_SIMULATION_VAR );
// Removing this until we figure out why velocity introduces view hitching.
// One possible fix is removing the player->ResetLatched() call in CGameMovement::FinishDuck(),
// but that re-introduces a third-person hitching bug. One possible cause is the abrupt change
// in player size/position that occurs when ducking, and how prediction tries to work through that.
//
// AddVar( &m_vecVelocity, &m_iv_vecVelocity, LATCH_SIMULATION_VAR );
m_DataChangeEventRef = -1;
m_EntClientFlags = 0;
m_iParentAttachment = 0;
m_nRenderFXBlend = 255;
SetPredictionEligible( false );
m_bPredictable = false;
m_bSimulatedEveryTick = false;
m_bAnimatedEveryTick = false;
m_pPhysicsObject = NULL;
#ifdef _DEBUG
m_vecAbsOrigin = vec3_origin;
m_angAbsRotation = vec3_angle;
m_vecNetworkOrigin.Init();
m_angNetworkAngles.Init();
m_vecAbsOrigin.Init();
// m_vecAbsAngVelocity.Init();
m_vecVelocity.Init();
m_vecAbsVelocity.Init();
m_vecViewOffset.Init();
m_vecBaseVelocity.Init();
m_iCurrentThinkContext = NO_THINK_CONTEXT;
#endif
m_nSimulationTick = -1;
// Assume drawing everything
m_bReadyToDraw = true;
m_flProxyRandomValue = 0.0f;
m_fBBoxVisFlags = 0;
#if !defined( NO_ENTITY_PREDICTION )
m_pPredictionContext = NULL;
#endif
//NOTE: not virtual! we are in the constructor!
C_BaseEntity::Clear();
m_InterpolationListEntry = 0xFFFF;
m_TeleportListEntry = 0xFFFF;
#ifndef NO_TOOLFRAMEWORK
m_bEnabledInToolView = true;
m_bToolRecording = false;
m_ToolHandle = 0;
m_nLastRecordedFrame = -1;
m_bRecordInTools = true;
#endif
#ifdef TF_CLIENT_DLL
m_bValidatedOwner = false;
m_bDeemedInvalid = false;
m_bWasDeemedInvalid = false;
#endif
ParticleProp()->Init( this );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
C_BaseEntity::~C_BaseEntity()
{
Term();
ClearDataChangedEvent( m_DataChangeEventRef );
#if !defined( NO_ENTITY_PREDICTION )
delete m_pPredictionContext;
#endif
RemoveFromInterpolationList();
RemoveFromTeleportList();
}
void C_BaseEntity::Clear( void )
{
m_bDormant = true;
m_nCreationTick = -1;
m_RefEHandle.Term();
m_ModelInstance = MODEL_INSTANCE_INVALID;
m_ShadowHandle = CLIENTSHADOW_INVALID_HANDLE;
m_hRender = INVALID_CLIENT_RENDER_HANDLE;
m_hThink = INVALID_THINK_HANDLE;
m_AimEntsListHandle = INVALID_AIMENTS_LIST_HANDLE;
index = -1;
m_Collision.Init( this );
SetLocalOrigin( vec3_origin );
SetLocalAngles( vec3_angle );
model = NULL;
m_vecAbsOrigin.Init();
m_angAbsRotation.Init();
m_vecVelocity.Init();
ClearFlags();
m_vecViewOffset.Init();
m_vecBaseVelocity.Init();
m_nModelIndex = 0;
m_flAnimTime = 0;
m_flSimulationTime = 0;
SetSolid( SOLID_NONE );
SetSolidFlags( 0 );
SetMoveCollide( MOVECOLLIDE_DEFAULT );
SetMoveType( MOVETYPE_NONE );
ClearEffects();
m_iEFlags = 0;
m_nRenderMode = 0;
m_nOldRenderMode = 0;
SetRenderColor( 255, 255, 255, 255 );
m_nRenderFX = 0;
m_flFriction = 0.0f;
m_flGravity = 0.0f;
SetCheckUntouch( false );
m_ShadowDirUseOtherEntity = NULL;
m_nLastThinkTick = gpGlobals->tickcount;
#if defined(SIXENSE)
m_vecEyeOffset.Init();
m_EyeAngleOffset.Init();
#endif
// Remove prediction context if it exists
#if !defined( NO_ENTITY_PREDICTION )
delete m_pPredictionContext;
m_pPredictionContext = NULL;
#endif
// Do not enable this on all entities. It forces bone setup for entities that
// don't need it.
//AddEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID );
UpdateVisibility();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::Spawn( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::Activate()
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::SpawnClientEntity( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::Precache( void )
{
}
//-----------------------------------------------------------------------------
// Purpose: Attach to entity
// Input : *pEnt -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseEntity::Init( int entnum, int iSerialNum )
{
Assert( entnum >= 0 && entnum < NUM_ENT_ENTRIES );
index = entnum;
cl_entitylist->AddNetworkableEntity( GetIClientUnknown(), entnum, iSerialNum );
CollisionProp()->CreatePartitionHandle();
Interp_SetupMappings( GetVarMapping() );
m_nCreationTick = gpGlobals->tickcount;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool C_BaseEntity::InitializeAsClientEntity( const char *pszModelName, RenderGroup_t renderGroup )
{
int nModelIndex;
if ( pszModelName != NULL )
{
nModelIndex = modelinfo->GetModelIndex( pszModelName );
if ( nModelIndex == -1 )
{
// Model could not be found
Assert( !"Model could not be found, index is -1" );
return false;
}
}
else
{
nModelIndex = -1;
}
Interp_SetupMappings( GetVarMapping() );
return InitializeAsClientEntityByIndex( nModelIndex, renderGroup );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool C_BaseEntity::InitializeAsClientEntityByIndex( int iIndex, RenderGroup_t renderGroup )
{
index = -1;
// Setup model data.
SetModelByIndex( iIndex );
// Add the client entity to the master entity list.
cl_entitylist->AddNonNetworkableEntity( GetIClientUnknown() );
Assert( GetClientHandle() != ClientEntityList().InvalidHandle() );
// Add the client entity to the renderable "leaf system." (Renderable)
AddToLeafSystem( renderGroup );
// Add the client entity to the spatial partition. (Collidable)
CollisionProp()->CreatePartitionHandle();
SpawnClientEntity();
return true;
}
void C_BaseEntity::TrackAngRotation( bool bTrack )
{
if ( bTrack )
AddVar( &m_angRotation, &m_iv_angRotation, LATCH_SIMULATION_VAR );
else
RemoveVar( &m_angRotation, false );
}
void C_BaseEntity::Term()
{
C_BaseEntity::PhysicsRemoveTouchedList( this );
C_BaseEntity::PhysicsRemoveGroundList( this );
DestroyAllDataObjects();
#if !defined( NO_ENTITY_PREDICTION )
// Remove from the predictables list
if ( GetPredictable() || IsClientCreated() )
{
g_Predictables.RemoveFromPredictablesList( GetClientHandle() );
}
// If it's play simulated, remove from simulation list if the player still exists...
if ( IsPlayerSimulated() && C_BasePlayer::GetLocalPlayer() )
{
C_BasePlayer::GetLocalPlayer()->RemoveFromPlayerSimulationList( this );
}
#endif
if ( GetClientHandle() != INVALID_CLIENTENTITY_HANDLE )
{
if ( GetThinkHandle() != INVALID_THINK_HANDLE )
{
ClientThinkList()->RemoveThinkable( GetClientHandle() );
}
// Remove from the client entity list.
ClientEntityList().RemoveEntity( GetClientHandle() );
m_RefEHandle = INVALID_CLIENTENTITY_HANDLE;
}
// Are we in the partition?
CollisionProp()->DestroyPartitionHandle();
// If Client side only entity index will be -1
if ( index != -1 )
{
beams->KillDeadBeams( this );
}
// Clean up the model instance
DestroyModelInstance();
// Clean up drawing
RemoveFromLeafSystem();
RemoveFromAimEntsList();
}
void C_BaseEntity::SetRefEHandle( const CBaseHandle &handle )
{
m_RefEHandle = handle;
}
const CBaseHandle& C_BaseEntity::GetRefEHandle() const
{
return m_RefEHandle;
}
//-----------------------------------------------------------------------------
// Purpose: Free beams and destroy object
//-----------------------------------------------------------------------------
void C_BaseEntity::Release()
{
{
C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, true );
UnlinkFromHierarchy();
}
// Note that this must be called from here, not the destructor, because otherwise the
// vtable is hosed and the derived classes function is not going to get called!!!
if ( IsIntermediateDataAllocated() )
{
DestroyIntermediateData();
}
UpdateOnRemove();
delete this;
}
//-----------------------------------------------------------------------------
// Only meant to be called from subclasses.
// Returns true if instance valid, false otherwise
//-----------------------------------------------------------------------------
void C_BaseEntity::CreateModelInstance()
{
if ( m_ModelInstance == MODEL_INSTANCE_INVALID )
{
m_ModelInstance = modelrender->CreateInstance( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::DestroyModelInstance()
{
if (m_ModelInstance != MODEL_INSTANCE_INVALID)
{
modelrender->DestroyInstance( m_ModelInstance );
m_ModelInstance = MODEL_INSTANCE_INVALID;
}
}
void C_BaseEntity::SetRemovalFlag( bool bRemove )
{
if (bRemove)
m_iEFlags |= EFL_KILLME;
else
m_iEFlags &= ~EFL_KILLME;
}
//-----------------------------------------------------------------------------
// VPhysics objects..
//-----------------------------------------------------------------------------
int C_BaseEntity::VPhysicsGetObjectList( IPhysicsObject **pList, int listMax )
{
IPhysicsObject *pPhys = VPhysicsGetObject();
if ( pPhys )
{
// multi-object entities must implement this function
Assert( !(pPhys->GetGameFlags() & FVPHYSICS_MULTIOBJECT_ENTITY) );
if ( listMax > 0 )
{
pList[0] = pPhys;
return 1;
}
}
return 0;
}
bool C_BaseEntity::VPhysicsIsFlesh( void )
{
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int count = VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
for ( int i = 0; i < count; i++ )
{
int material = pList[i]->GetMaterialIndex();
const surfacedata_t *pSurfaceData = physprops->GetSurfaceData( material );
// Is flesh ?, don't allow pickup
if ( pSurfaceData->game.material == CHAR_TEX_ANTLION || pSurfaceData->game.material == CHAR_TEX_FLESH || pSurfaceData->game.material == CHAR_TEX_BLOODYFLESH || pSurfaceData->game.material == CHAR_TEX_ALIENFLESH )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Retrieves the coordinate frame for this entity.
// Input : forward - Receives the entity's forward vector.
// right - Receives the entity's right vector.
// up - Receives the entity's up vector.
//-----------------------------------------------------------------------------
void C_BaseEntity::GetVectors(Vector* pForward, Vector* pRight, Vector* pUp) const
{
// This call is necessary to cause m_rgflCoordinateFrame to be recomputed
const matrix3x4_t &entityToWorld = EntityToWorldTransform();
if (pForward != NULL)
{
MatrixGetColumn( entityToWorld, 0, *pForward );
}
if (pRight != NULL)
{
MatrixGetColumn( entityToWorld, 1, *pRight );
*pRight *= -1.0f;
}
if (pUp != NULL)
{
MatrixGetColumn( entityToWorld, 2, *pUp );
}
}
void C_BaseEntity::UpdateVisibility()
{
#ifdef TF_CLIENT_DLL
// TF prevents drawing of any entity attached to players that aren't items in the inventory of the player.
// This is to prevent servers creating fake cosmetic items and attaching them to players.
if ( !engine->IsPlayingDemo() )
{
static bool bIsStaging = ( engine->GetAppID() == 810 );
if ( !m_bValidatedOwner )
{
bool bRetry = false;
// Check it the first time we call update visibility (Source TV doesn't bother doing validation)
m_bDeemedInvalid = engine->IsHLTV() ? false : !ValidateEntityAttachedToPlayer( bRetry );
m_bValidatedOwner = !bRetry;
}
if ( m_bDeemedInvalid )
{
if ( bIsStaging )
{
if ( !m_bWasDeemedInvalid )
{
m_PreviousRenderMode = GetRenderMode();
m_PreviousRenderColor = GetRenderColor();
m_bWasDeemedInvalid = true;
}
SetRenderMode( kRenderTransColor );
SetRenderColor( 255, 0, 0, 200 );
}
else
{
RemoveFromLeafSystem();
return;
}
}
else if ( m_bWasDeemedInvalid )
{
if ( bIsStaging )
{
// We need to fix up the rendering.
SetRenderMode( m_PreviousRenderMode );
SetRenderColor( m_PreviousRenderColor.r, m_PreviousRenderColor.g, m_PreviousRenderColor.b, m_PreviousRenderColor.a );
}
m_bWasDeemedInvalid = false;
}
}
#endif
if ( ShouldDraw() && !IsDormant() && ( !ToolsEnabled() || IsEnabledInToolView() ) )
{
// add/update leafsystem
AddToLeafSystem();
}
else
{
// remove from leaf system
RemoveFromLeafSystem();
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether object should render.
//-----------------------------------------------------------------------------
bool C_BaseEntity::ShouldDraw()
{
// Only test this in tf2
#if defined( INVASION_CLIENT_DLL )
// Let the client mode (like commander mode) reject drawing entities.
if (g_pClientMode && !g_pClientMode->ShouldDrawEntity(this) )
return false;
#endif
// Some rendermodes prevent rendering
if ( m_nRenderMode == kRenderNone )
return false;
return (model != 0) && !IsEffectActive(EF_NODRAW) && (index != 0);
}
bool C_BaseEntity::TestCollision( const Ray_t& ray, unsigned int mask, trace_t& trace )
{
return false;
}
bool C_BaseEntity::TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr )
{
return false;
}
//-----------------------------------------------------------------------------
// Used when the collision prop is told to ask game code for the world-space surrounding box
//-----------------------------------------------------------------------------
void C_BaseEntity::ComputeWorldSpaceSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs )
{
// This should only be called if you're using USE_GAME_CODE on the server
// and you forgot to implement the client-side version of this method.
Assert(0);
}
//-----------------------------------------------------------------------------
// Purpose: Derived classes will have to write their own message cracking routines!!!
// Input : length -
// *data -
//-----------------------------------------------------------------------------
void C_BaseEntity::ReceiveMessage( int classID, bf_read &msg )
{
// BaseEntity doesn't have a base class we could relay this message to
Assert( classID == GetClientClass()->m_ClassID );
int messageType = msg.ReadByte();
switch( messageType )
{
case BASEENTITY_MSG_REMOVE_DECALS: RemoveAllDecals();
break;
}
}
void* C_BaseEntity::GetDataTableBasePtr()
{
return this;
}
//-----------------------------------------------------------------------------
// Should this object cast shadows?
//-----------------------------------------------------------------------------
ShadowType_t C_BaseEntity::ShadowCastType()
{
if (IsEffectActive(EF_NODRAW | EF_NOSHADOW))
return SHADOWS_NONE;
int modelType = modelinfo->GetModelType( model );
return (modelType == mod_studio) ? SHADOWS_RENDER_TO_TEXTURE : SHADOWS_NONE;
}
//-----------------------------------------------------------------------------
// Per-entity shadow cast distance + direction
//-----------------------------------------------------------------------------
bool C_BaseEntity::GetShadowCastDistance( float *pDistance, ShadowType_t shadowType ) const
{
if ( m_flShadowCastDistance != 0.0f )
{
*pDistance = m_flShadowCastDistance;
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
C_BaseEntity *C_BaseEntity::GetShadowUseOtherEntity( void ) const
{
return m_ShadowDirUseOtherEntity;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::SetShadowUseOtherEntity( C_BaseEntity *pEntity )
{
m_ShadowDirUseOtherEntity = pEntity;
}
CInterpolatedVar< QAngle >& C_BaseEntity::GetRotationInterpolator()
{
return m_iv_angRotation;
}
CInterpolatedVar< Vector >& C_BaseEntity::GetOriginInterpolator()
{
return m_iv_vecOrigin;
}
//-----------------------------------------------------------------------------
// Purpose: Return a per-entity shadow cast direction
//-----------------------------------------------------------------------------
bool C_BaseEntity::GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const
{
if ( m_ShadowDirUseOtherEntity )
return m_ShadowDirUseOtherEntity->GetShadowCastDirection( pDirection, shadowType );
return false;
}
//-----------------------------------------------------------------------------
// Should this object receive shadows?
//-----------------------------------------------------------------------------
bool C_BaseEntity::ShouldReceiveProjectedTextures( int flags )
{
Assert( flags & SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK );
if ( IsEffectActive( EF_NODRAW ) )
return false;
if( flags & SHADOW_FLAGS_FLASHLIGHT )
{
if ( GetRenderMode() > kRenderNormal && GetRenderColor().a == 0 )
return false;
return true;
}
Assert( flags & SHADOW_FLAGS_SHADOW );
if ( IsEffectActive( EF_NORECEIVESHADOW ) )
return false;
if (modelinfo->GetModelType( model ) == mod_studio)
return false;
return true;
}
//-----------------------------------------------------------------------------
// Shadow-related methods
//-----------------------------------------------------------------------------
bool C_BaseEntity::IsShadowDirty( )
{
return IsEFlagSet( EFL_DIRTY_SHADOWUPDATE );
}
void C_BaseEntity::MarkShadowDirty( bool bDirty )
{
if ( bDirty )
{
AddEFlags( EFL_DIRTY_SHADOWUPDATE );
}
else
{
RemoveEFlags( EFL_DIRTY_SHADOWUPDATE );
}
}
IClientRenderable *C_BaseEntity::GetShadowParent()
{
C_BaseEntity *pParent = GetMoveParent();
return pParent ? pParent->GetClientRenderable() : NULL;
}
IClientRenderable *C_BaseEntity::FirstShadowChild()
{
C_BaseEntity *pChild = FirstMoveChild();
return pChild ? pChild->GetClientRenderable() : NULL;
}
IClientRenderable *C_BaseEntity::NextShadowPeer()
{
C_BaseEntity *pPeer = NextMovePeer();
return pPeer ? pPeer->GetClientRenderable() : NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Returns index into entities list for this entity
// Output : Index
//-----------------------------------------------------------------------------
int C_BaseEntity::entindex( void ) const
{
return index;
}
int C_BaseEntity::GetSoundSourceIndex() const
{
#ifdef _DEBUG
if ( index != -1 )
{
Assert( index == GetRefEHandle().GetEntryIndex() );
}
#endif
return GetRefEHandle().GetEntryIndex();
}
//-----------------------------------------------------------------------------
// Get render origin and angles
//-----------------------------------------------------------------------------
const Vector& C_BaseEntity::GetRenderOrigin( void )
{
return GetAbsOrigin();
}
const QAngle& C_BaseEntity::GetRenderAngles( void )
{
return GetAbsAngles();
}
const matrix3x4_t &C_BaseEntity::RenderableToWorldTransform()
{
return EntityToWorldTransform();
}
IPVSNotify* C_BaseEntity::GetPVSNotifyInterface()
{
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : theMins -
// theMaxs -
//-----------------------------------------------------------------------------
void C_BaseEntity::GetRenderBounds( Vector& theMins, Vector& theMaxs )
{
int nModelType = modelinfo->GetModelType( model );
if (nModelType == mod_studio || nModelType == mod_brush)
{
modelinfo->GetModelRenderBounds( GetModel(), theMins, theMaxs );
}
else
{
// By default, we'll just snack on the collision bounds, transform
// them into entity-space, and call it a day.
if ( GetRenderAngles() == CollisionProp()->GetCollisionAngles() )
{
theMins = CollisionProp()->OBBMins();
theMaxs = CollisionProp()->OBBMaxs();
}
else
{
Assert( CollisionProp()->GetCollisionAngles() == vec3_angle );
if ( IsPointSized() )
{
//theMins = CollisionProp()->GetCollisionOrigin();
//theMaxs = theMins;
theMins = theMaxs = vec3_origin;
}
else
{
// NOTE: This shouldn't happen! Or at least, I haven't run
// into a valid case where it should yet.
// Assert(0);
IRotateAABB( EntityToWorldTransform(), CollisionProp()->OBBMins(), CollisionProp()->OBBMaxs(), theMins, theMaxs );
}
}
}
}
void C_BaseEntity::GetRenderBoundsWorldspace( Vector& mins, Vector& maxs )
{
DefaultRenderBoundsWorldspace( this, mins, maxs );
}
void C_BaseEntity::GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType )
{
m_EntClientFlags |= ENTCLIENTFLAG_GETTINGSHADOWRENDERBOUNDS;
GetRenderBounds( mins, maxs );
m_EntClientFlags &= ~ENTCLIENTFLAG_GETTINGSHADOWRENDERBOUNDS;
}
//-----------------------------------------------------------------------------
// Purpose: Last received origin
// Output : const float
//-----------------------------------------------------------------------------
const Vector& C_BaseEntity::GetAbsOrigin( void ) const
{
//Assert( s_bAbsQueriesValid );
const_cast<C_BaseEntity*>(this)->CalcAbsolutePosition();
return m_vecAbsOrigin;
}
//-----------------------------------------------------------------------------
// Purpose: Last received angles
// Output : const
//-----------------------------------------------------------------------------
const QAngle& C_BaseEntity::GetAbsAngles( void ) const
{
//Assert( s_bAbsQueriesValid );
const_cast<C_BaseEntity*>(this)->CalcAbsolutePosition();
return m_angAbsRotation;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : org -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetNetworkOrigin( const Vector& org )
{
m_vecNetworkOrigin = org;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : ang -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetNetworkAngles( const QAngle& ang )
{
m_angNetworkAngles = ang;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : index -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetModelIndex( int index_ )
{
m_nModelIndex = index_;
const model_t *pModel = modelinfo->GetModel( m_nModelIndex );
SetModelPointer( pModel );
}
void C_BaseEntity::SetModelPointer( const model_t *pModel )
{
if ( pModel != model )
{
DestroyModelInstance();
model = pModel;
OnNewModel();
UpdateVisibility();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : val -
// moveCollide -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetMoveType( MoveType_t val, MoveCollide_t moveCollide /*= MOVECOLLIDE_DEFAULT*/ )
{
// Make sure the move type + move collide are compatible...
#ifdef _DEBUG
if ((val != MOVETYPE_FLY) && (val != MOVETYPE_FLYGRAVITY))
{
Assert( moveCollide == MOVECOLLIDE_DEFAULT );
}
#endif
m_MoveType = val;
SetMoveCollide( moveCollide );
}
void C_BaseEntity::SetMoveCollide( MoveCollide_t val )
{
m_MoveCollide = val;
}
//-----------------------------------------------------------------------------
// Purpose: Get rendermode
// Output : int - the render mode
//-----------------------------------------------------------------------------
bool C_BaseEntity::IsTransparent( void )
{
bool modelIsTransparent = modelinfo->IsTranslucent(model);
return modelIsTransparent || (m_nRenderMode != kRenderNormal);
}
bool C_BaseEntity::IsTwoPass( void )
{
return modelinfo->IsTranslucentTwoPass( GetModel() );
}
bool C_BaseEntity::UsesPowerOfTwoFrameBufferTexture()
{
return false;
}
bool C_BaseEntity::UsesFullFrameBufferTexture()
{
return false;
}
bool C_BaseEntity::IgnoresZBuffer( void ) const
{
return m_nRenderMode == kRenderGlow || m_nRenderMode == kRenderWorldGlow;
}
//-----------------------------------------------------------------------------
// Purpose: Get pointer to CMouthInfo data
// Output : CMouthInfo
//-----------------------------------------------------------------------------
CMouthInfo *C_BaseEntity::GetMouth( void )
{
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Retrieve sound spatialization info for the specified sound on this entity
// Input : info -
// Output : Return false to indicate sound is not audible
//-----------------------------------------------------------------------------
bool C_BaseEntity::GetSoundSpatialization( SpatializationInfo_t& info )
{
// World is always audible
if ( entindex() == 0 )
{
return true;
}
// Out of PVS
if ( IsDormant() )
{
return false;
}
// pModel might be NULL, but modelinfo can handle that
const model_t *pModel = GetModel();
if ( info.pflRadius )
{
*info.pflRadius = modelinfo->GetModelRadius( pModel );
}
if ( info.pOrigin )
{
*info.pOrigin = GetAbsOrigin();
// move origin to middle of brush
if ( modelinfo->GetModelType( pModel ) == mod_brush )
{
Vector mins, maxs, center;
modelinfo->GetModelBounds( pModel, mins, maxs );
VectorAdd( mins, maxs, center );
VectorScale( center, 0.5f, center );
(*info.pOrigin) += center;
}
}
if ( info.pAngles )
{
VectorCopy( GetAbsAngles(), *info.pAngles );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Get attachment point by index
// Input : number - which point
// Output : float * - the attachment point
//-----------------------------------------------------------------------------
bool C_BaseEntity::GetAttachment( int number, Vector &origin, QAngle &angles )
{
origin = GetAbsOrigin();
angles = GetAbsAngles();
return true;
}
bool C_BaseEntity::GetAttachment( int number, Vector &origin )
{
origin = GetAbsOrigin();
return true;
}
bool C_BaseEntity::GetAttachment( int number, matrix3x4_t &matrix )
{
MatrixCopy( EntityToWorldTransform(), matrix );
return true;
}
bool C_BaseEntity::GetAttachmentVelocity( int number, Vector &originVel, Quaternion &angleVel )
{
originVel = GetAbsVelocity();
angleVel.Init();
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Get this entity's rendering clip plane if one is defined
// Output : float * - The clip plane to use, or NULL if no clip plane is defined
//-----------------------------------------------------------------------------
float *C_BaseEntity::GetRenderClipPlane( void )
{
if( m_bEnableRenderingClipPlane )
return m_fRenderingClipPlane;
else
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int C_BaseEntity::DrawBrushModel( bool bDrawingTranslucency, int nFlags, bool bTwoPass )
{
VPROF_BUDGET( "C_BaseEntity::DrawBrushModel", VPROF_BUDGETGROUP_BRUSHMODEL_RENDERING );
// Identity brushes are drawn in view->DrawWorld as an optimization
Assert ( modelinfo->GetModelType( model ) == mod_brush );
ERenderDepthMode DepthMode = DEPTH_MODE_NORMAL;
if ( ( nFlags & STUDIO_SSAODEPTHTEXTURE ) != 0 )
{
DepthMode = DEPTH_MODE_SSA0;
}
else if ( ( nFlags & STUDIO_SHADOWDEPTHTEXTURE ) != 0 )
{
DepthMode = DEPTH_MODE_SHADOW;
}
if ( DepthMode != DEPTH_MODE_NORMAL )
{
render->DrawBrushModelShadowDepth( this, (model_t *)model, GetAbsOrigin(), GetAbsAngles(), DepthMode );
}
else
{
DrawBrushModelMode_t mode = DBM_DRAW_ALL;
if ( bTwoPass )
{
mode = bDrawingTranslucency ? DBM_DRAW_TRANSLUCENT_ONLY : DBM_DRAW_OPAQUE_ONLY;
}
render->DrawBrushModelEx( this, (model_t *)model, GetAbsOrigin(), GetAbsAngles(), mode );
}
return 1;
}
//-----------------------------------------------------------------------------
// Purpose: Draws the object
// Input : flags -
//-----------------------------------------------------------------------------
int C_BaseEntity::DrawModel( int flags )
{
if ( !m_bReadyToDraw )
return 0;
int drawn = 0;
if ( !model )
{
return drawn;
}
int modelType = modelinfo->GetModelType( model );
switch ( modelType )
{
case mod_brush:
drawn = DrawBrushModel( flags & STUDIO_TRANSPARENCY ? true : false, flags, ( flags & STUDIO_TWOPASS ) ? true : false );
break;
case mod_studio:
// All studio models must be derived from C_BaseAnimating. Issue warning.
Warning( "ERROR: Can't draw studio model %s because %s is not derived from C_BaseAnimating\n",
modelinfo->GetModelName( model ), GetClientClass()->m_pNetworkName ? GetClientClass()->m_pNetworkName : "unknown" );
break;
case mod_sprite:
//drawn = DrawSprite();
Warning( "ERROR: Sprite model's not supported any more except in legacy temp ents\n" );
break;
default:
break;
}
// If we're visualizing our bboxes, draw them
DrawBBoxVisualizations();
return drawn;
}
//-----------------------------------------------------------------------------
// Purpose: Setup the bones for drawing
//-----------------------------------------------------------------------------
bool C_BaseEntity::SetupBones( matrix3x4_t *pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime )
{
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Setup vertex weights for drawing
//-----------------------------------------------------------------------------
void C_BaseEntity::SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights )
{
}
//-----------------------------------------------------------------------------
// Purpose: Process any local client-side animation events
//-----------------------------------------------------------------------------
void C_BaseEntity::DoAnimationEvents( )
{
}
void C_BaseEntity::UpdatePartitionListEntry()
{
// Don't add the world entity
CollideType_t shouldCollide = GetCollideType();
// Choose the list based on what kind of collisions we want
int list = PARTITION_CLIENT_NON_STATIC_EDICTS;
if (shouldCollide == ENTITY_SHOULD_COLLIDE)
list |= PARTITION_CLIENT_SOLID_EDICTS;
else if (shouldCollide == ENTITY_SHOULD_RESPOND)
list |= PARTITION_CLIENT_RESPONSIVE_EDICTS;
// add the entity to the KD tree so we will collide against it
::partition->RemoveAndInsert( PARTITION_CLIENT_SOLID_EDICTS | PARTITION_CLIENT_RESPONSIVE_EDICTS | PARTITION_CLIENT_NON_STATIC_EDICTS, list, CollisionProp()->GetPartitionHandle() );
}
void C_BaseEntity::NotifyShouldTransmit( ShouldTransmitState_t state )
{
// Init should have been called before we get in here.
Assert( CollisionProp()->GetPartitionHandle() != PARTITION_INVALID_HANDLE );
if ( entindex() < 0 )
return;
switch( state )
{
case SHOULDTRANSMIT_START:
{
// We've just been sent by the server. Become active.
SetDormant( false );
UpdatePartitionListEntry();
#if !defined( NO_ENTITY_PREDICTION )
// Note that predictables get a chance to hook up to their server counterparts here
if ( m_PredictableID.IsActive() )
{
// Find corresponding client side predicted entity and remove it from predictables
m_PredictableID.SetAcknowledged( true );
C_BaseEntity *otherEntity = FindPreviouslyCreatedEntity( m_PredictableID );
if ( otherEntity )
{
Assert( otherEntity->IsClientCreated() );
Assert( otherEntity->m_PredictableID.IsActive() );
Assert( ClientEntityList().IsHandleValid( otherEntity->GetClientHandle() ) );
otherEntity->m_PredictableID.SetAcknowledged( true );
if ( OnPredictedEntityRemove( false, otherEntity ) )
{
// Mark it for delete after receive all network data
otherEntity->Release();
}
}
}
#endif
}
break;
case SHOULDTRANSMIT_END:
{
// Clear out links if we're out of the picture...
UnlinkFromHierarchy();
// We're no longer being sent by the server. Become dormant.
SetDormant( true );
// remove the entity from the KD tree so we won't collide against it
::partition->Remove( PARTITION_CLIENT_SOLID_EDICTS | PARTITION_CLIENT_RESPONSIVE_EDICTS | PARTITION_CLIENT_NON_STATIC_EDICTS, CollisionProp()->GetPartitionHandle() );
}
break;
default:
Assert( 0 );
break;
}
}
//-----------------------------------------------------------------------------
// Call this in PostDataUpdate if you don't chain it down!
//-----------------------------------------------------------------------------
void C_BaseEntity::MarkMessageReceived()
{
m_flLastMessageTime = engine->GetLastTimeStamp();
}
//-----------------------------------------------------------------------------
// Purpose: Entity is about to be decoded from the network stream
// Input : bnewentity - is this a new entity this update?
//-----------------------------------------------------------------------------
void C_BaseEntity::PreDataUpdate( DataUpdateType_t updateType )
{
VPROF( "C_BaseEntity::PreDataUpdate" );
// Register for an OnDataChanged call and call OnPreDataChanged().
if ( AddDataChangeEvent( this, updateType, &m_DataChangeEventRef ) )
{
OnPreDataChanged( updateType );
}
// Need to spawn on client before receiving original network data
// in case it overrides any values set up in spawn ( e.g., m_iState )
bool bnewentity = (updateType == DATA_UPDATE_CREATED);
if ( !bnewentity )
{
Interp_RestoreToLastNetworked( GetVarMapping() );
}
if ( bnewentity && !IsClientCreated() )
{
m_flSpawnTime = engine->GetLastTimeStamp();
MDLCACHE_CRITICAL_SECTION();
Spawn();
}
#if 0 // Yahn suggesting commenting this out as a fix to demo recording not working
// If the entity moves itself every FRAME on the server but doesn't update animtime,
// then use the current server time as the time for interpolation.
if ( IsSelfAnimating() )
{
m_flAnimTime = engine->GetLastTimeStamp();
}
#endif
m_vecOldOrigin = GetNetworkOrigin();
m_vecOldAngRotation = GetNetworkAngles();
m_flOldAnimTime = m_flAnimTime;
m_flOldSimulationTime = m_flSimulationTime;
m_nOldRenderMode = m_nRenderMode;
if ( m_hRender != INVALID_CLIENT_RENDER_HANDLE )
{
ClientLeafSystem()->EnableAlternateSorting( m_hRender, m_bAlternateSorting );
}
m_ubOldInterpolationFrame = m_ubInterpolationFrame;
m_bOldShouldDraw = ShouldDraw();
}
const Vector& C_BaseEntity::GetOldOrigin()
{
return m_vecOldOrigin;
}
void C_BaseEntity::UnlinkChild( C_BaseEntity *pParent, C_BaseEntity *pChild )
{
Assert( pChild );
Assert( pParent != pChild );
Assert( pChild->GetMoveParent() == pParent );
// Unlink from parent
// NOTE: pParent *may well be NULL*! This occurs
// when a child has unlinked from a parent, and the child
// remains in the PVS but the parent has not
if (pParent && (pParent->m_pMoveChild == pChild))
{
Assert( !(pChild->m_pMovePrevPeer.IsValid()) );
pParent->m_pMoveChild = pChild->m_pMovePeer;
}
// Unlink from siblings...
if (pChild->m_pMovePrevPeer)
{
pChild->m_pMovePrevPeer->m_pMovePeer = pChild->m_pMovePeer;
}
if (pChild->m_pMovePeer)
{
pChild->m_pMovePeer->m_pMovePrevPeer = pChild->m_pMovePrevPeer;
}
pChild->m_pMovePeer = NULL;
pChild->m_pMovePrevPeer = NULL;
pChild->m_pMoveParent = NULL;
pChild->RemoveFromAimEntsList();
Interp_HierarchyUpdateInterpolationAmounts();
}
void C_BaseEntity::LinkChild( C_BaseEntity *pParent, C_BaseEntity *pChild )
{
Assert( !pChild->m_pMovePeer.IsValid() );
Assert( !pChild->m_pMovePrevPeer.IsValid() );
Assert( !pChild->m_pMoveParent.IsValid() );
Assert( pParent != pChild );
#ifdef _DEBUG
// Make sure the child isn't already in this list
C_BaseEntity *pExistingChild;
for ( pExistingChild = pParent->FirstMoveChild(); pExistingChild; pExistingChild = pExistingChild->NextMovePeer() )
{
Assert( pChild != pExistingChild );
}
#endif
pChild->m_pMovePrevPeer = NULL;
pChild->m_pMovePeer = pParent->m_pMoveChild;
if (pChild->m_pMovePeer)
{
pChild->m_pMovePeer->m_pMovePrevPeer = pChild;
}
pParent->m_pMoveChild = pChild;
pChild->m_pMoveParent = pParent;
pChild->AddToAimEntsList();
Interp_HierarchyUpdateInterpolationAmounts();
}
CUtlVector< C_BaseEntity * > g_AimEntsList;
//-----------------------------------------------------------------------------
// Moves all aiments
//-----------------------------------------------------------------------------
void C_BaseEntity::MarkAimEntsDirty()
{
// FIXME: With the dirty bits hooked into cycle + sequence, it's unclear
// that this is even necessary any more (provided aiments are always accessing
// joints or attachments of the move parent).
//
// NOTE: This is a tricky algorithm. This list does not actually contain
// all aim-ents in its list. It actually contains all hierarchical children,
// of which aim-ents are a part. We can tell if something is an aiment if it has
// the EF_BONEMERGE effect flag set.
//
// We will first iterate over all aiments and clear their DIRTY_ABSTRANSFORM flag,
// which is necessary to cause them to recompute their aim-ent origin
// the next time CalcAbsPosition is called. Because CalcAbsPosition calls MoveToAimEnt
// and MoveToAimEnt calls SetAbsOrigin/SetAbsAngles, that is how CalcAbsPosition
// will cause the aim-ent's (and all its children's) dirty state to be correctly updated.
//
// Then we will iterate over the loop a second time and call CalcAbsPosition on them,
int i;
int c = g_AimEntsList.Count();
for ( i = 0; i < c; ++i )
{
C_BaseEntity *pEnt = g_AimEntsList[ i ];
Assert( pEnt && pEnt->GetMoveParent() );
if ( pEnt->IsEffectActive(EF_BONEMERGE | EF_PARENT_ANIMATES) )
{
pEnt->AddEFlags( EFL_DIRTY_ABSTRANSFORM );
}
}
}
void C_BaseEntity::CalcAimEntPositions()
{
VPROF("CalcAimEntPositions");
int i;
int c = g_AimEntsList.Count();
for ( i = 0; i < c; ++i )
{
C_BaseEntity *pEnt = g_AimEntsList[ i ];
Assert( pEnt );
Assert( pEnt->GetMoveParent() );
if ( pEnt->IsEffectActive(EF_BONEMERGE) )
{
pEnt->CalcAbsolutePosition( );
}
}
}
void C_BaseEntity::AddToAimEntsList()
{
// Already in list
if ( m_AimEntsListHandle != INVALID_AIMENTS_LIST_HANDLE )
return;
m_AimEntsListHandle = g_AimEntsList.AddToTail( this );
}
void C_BaseEntity::RemoveFromAimEntsList()
{
// Not in list yet
if ( INVALID_AIMENTS_LIST_HANDLE == m_AimEntsListHandle )
{
return;
}
unsigned int c = g_AimEntsList.Count();
Assert( m_AimEntsListHandle < c );
unsigned int last = c - 1;
if ( last == m_AimEntsListHandle )
{
// Just wipe the final entry
g_AimEntsList.FastRemove( last );
}
else
{
C_BaseEntity *lastEntity = g_AimEntsList[ last ];
// Remove the last entry
g_AimEntsList.FastRemove( last );
// And update it's handle to point to this slot.
lastEntity->m_AimEntsListHandle = m_AimEntsListHandle;
g_AimEntsList[ m_AimEntsListHandle ] = lastEntity;
}
// Invalidate our handle no matter what.
m_AimEntsListHandle = INVALID_AIMENTS_LIST_HANDLE;
}
//-----------------------------------------------------------------------------
// Update move-parent if needed. For SourceTV.
//-----------------------------------------------------------------------------
void C_BaseEntity::HierarchyUpdateMoveParent()
{
if ( m_hNetworkMoveParent.ToInt() == m_pMoveParent.ToInt() )
return;
HierarchySetParent( m_hNetworkMoveParent );
}
//-----------------------------------------------------------------------------
// Connects us up to hierarchy
//-----------------------------------------------------------------------------
void C_BaseEntity::HierarchySetParent( C_BaseEntity *pNewParent )
{
// NOTE: When this is called, we expect to have a valid
// local origin, etc. that we received from network daa
EHANDLE newParentHandle;
newParentHandle.Set( pNewParent );
if (newParentHandle.ToInt() == m_pMoveParent.ToInt())
return;
if (m_pMoveParent.IsValid())
{
UnlinkChild( m_pMoveParent, this );
}
if (pNewParent)
{
LinkChild( pNewParent, this );
}
InvalidatePhysicsRecursive( POSITION_CHANGED | ANGLES_CHANGED | VELOCITY_CHANGED );
#ifdef TF_CLIENT_DLL
m_bValidatedOwner = false;
#endif
}
//-----------------------------------------------------------------------------
// Unlinks from hierarchy
//-----------------------------------------------------------------------------
void C_BaseEntity::SetParent( C_BaseEntity *pParentEntity, int iParentAttachment )
{
// NOTE: This version is meant to be called *outside* of PostDataUpdate
// as it assumes the moveparent has a valid handle
EHANDLE newParentHandle;
newParentHandle.Set( pParentEntity );
if (newParentHandle.ToInt() == m_pMoveParent.ToInt())
return;
// NOTE: Have to do this before the unlink to ensure local coords are valid
Vector vecAbsOrigin = GetAbsOrigin();
QAngle angAbsRotation = GetAbsAngles();
Vector vecAbsVelocity = GetAbsVelocity();
// First deal with unlinking
if (m_pMoveParent.IsValid())
{
UnlinkChild( m_pMoveParent, this );
}
if (pParentEntity)
{
LinkChild( pParentEntity, this );
}
if ( !IsServerEntity() )
{
m_hNetworkMoveParent = pParentEntity;
}
m_iParentAttachment = iParentAttachment;
m_vecAbsOrigin.Init( FLT_MAX, FLT_MAX, FLT_MAX );
m_angAbsRotation.Init( FLT_MAX, FLT_MAX, FLT_MAX );
m_vecAbsVelocity.Init( FLT_MAX, FLT_MAX, FLT_MAX );
SetAbsOrigin(vecAbsOrigin);
SetAbsAngles(angAbsRotation);
SetAbsVelocity(vecAbsVelocity);
}
//-----------------------------------------------------------------------------
// Unlinks from hierarchy
//-----------------------------------------------------------------------------
void C_BaseEntity::UnlinkFromHierarchy()
{
// Clear out links if we're out of the picture...
if ( m_pMoveParent.IsValid() )
{
UnlinkChild( m_pMoveParent, this );
}
//Adrian: This was causing problems with the local network backdoor with entities coming in and out of the PVS at certain times.
//This would work fine if a full entity update was coming (caused by certain factors like too many entities entering the pvs at once).
//but otherwise it would not detect the change on the client (since the server and client shouldn't be out of sync) and the var would not be updated like it should.
//m_iParentAttachment = 0;
// unlink also all move children
C_BaseEntity *pChild = FirstMoveChild();
while( pChild )
{
if ( pChild->m_pMoveParent != this )
{
Warning( "C_BaseEntity::UnlinkFromHierarchy(): Entity has a child with the wrong parent!\n" );
Assert( 0 );
UnlinkChild( this, pChild );
pChild->UnlinkFromHierarchy();
}
else
pChild->UnlinkFromHierarchy();
pChild = FirstMoveChild();
}
}
//-----------------------------------------------------------------------------
// Purpose: Make sure that the correct model is referenced for this entity
//-----------------------------------------------------------------------------
void C_BaseEntity::ValidateModelIndex( void )
{
#ifdef TF_CLIENT_DLL
if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_HALLOWEEN ) )
{
if ( m_nModelIndexOverrides[VISION_MODE_HALLOWEEN] > 0 )
{
SetModelByIndex( m_nModelIndexOverrides[VISION_MODE_HALLOWEEN] );
return;
}
}
if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) )
{
if ( m_nModelIndexOverrides[VISION_MODE_PYRO] > 0 )
{
SetModelByIndex( m_nModelIndexOverrides[VISION_MODE_PYRO] );
return;
}
}
if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_ROME ) )
{
if ( m_nModelIndexOverrides[VISION_MODE_ROME] > 0 )
{
SetModelByIndex( m_nModelIndexOverrides[VISION_MODE_ROME] );
return;
}
}
if ( m_nModelIndexOverrides[VISION_MODE_NONE] > 0 )
{
SetModelByIndex( m_nModelIndexOverrides[VISION_MODE_NONE] );
return;
}
#endif
SetModelByIndex( m_nModelIndex );
}
//-----------------------------------------------------------------------------
// Purpose: Entity data has been parsed and unpacked. Now do any necessary decoding, munging
// Input : bnewentity - was this entity new in this update packet?
//-----------------------------------------------------------------------------
void C_BaseEntity::PostDataUpdate( DataUpdateType_t updateType )
{
MDLCACHE_CRITICAL_SECTION();
PREDICTION_TRACKVALUECHANGESCOPE_ENTITY( this, "postdataupdate" );
// NOTE: This *has* to happen first. Otherwise, Origin + angles may be wrong
if ( m_nRenderFX == kRenderFxRagdoll && updateType == DATA_UPDATE_CREATED )
{
MoveToLastReceivedPosition( true );
}
else
{
MoveToLastReceivedPosition( false );
}
// If it's the world, force solid flags
if ( index == 0 )
{
m_nModelIndex = 1;
SetSolid( SOLID_BSP );
// FIXME: Should these be assertions?
SetAbsOrigin( vec3_origin );
SetAbsAngles( vec3_angle );
}
if ( m_nOldRenderMode != m_nRenderMode )
{
SetRenderMode( (RenderMode_t)m_nRenderMode, true );
}
bool animTimeChanged = ( m_flAnimTime != m_flOldAnimTime ) ? true : false;
bool originChanged = ( m_vecOldOrigin != GetLocalOrigin() ) ? true : false;
bool anglesChanged = ( m_vecOldAngRotation != GetLocalAngles() ) ? true : false;
bool simTimeChanged = ( m_flSimulationTime != m_flOldSimulationTime ) ? true : false;
// Detect simulation changes
bool simulationChanged = originChanged || anglesChanged || simTimeChanged;
bool bPredictable = GetPredictable();
// For non-predicted and non-client only ents, we need to latch network values into the interpolation histories
if ( !bPredictable && !IsClientCreated() )
{
if ( animTimeChanged )
{
OnLatchInterpolatedVariables( LATCH_ANIMATION_VAR );
}
if ( simulationChanged )
{
OnLatchInterpolatedVariables( LATCH_SIMULATION_VAR );
}
}
// For predictables, we also need to store off the last networked value
else if ( bPredictable )
{
// Just store off last networked value for use in prediction
OnStoreLastNetworkedValue();
}
// Deal with hierarchy. Have to do it here (instead of in a proxy)
// because this is the only point at which all entities are loaded
// If this condition isn't met, then a child was sent without its parent
Assert( m_hNetworkMoveParent.Get() || !m_hNetworkMoveParent.IsValid() );
HierarchySetParent(m_hNetworkMoveParent);
MarkMessageReceived();
// Make sure that the correct model is referenced for this entity
ValidateModelIndex();
// If this entity was new, then latch in various values no matter what.
if ( updateType == DATA_UPDATE_CREATED )
{
// Construct a random value for this instance
m_flProxyRandomValue = random->RandomFloat( 0, 1 );
ResetLatched();
m_nCreationTick = gpGlobals->tickcount;
}
CheckInitPredictable( "PostDataUpdate" );
// It's possible that a new entity will need to be forceably added to the
// player simulation list. If so, do this here
#if !defined( NO_ENTITY_PREDICTION )
C_BasePlayer *local = C_BasePlayer::GetLocalPlayer();
if ( IsPlayerSimulated() &&
( NULL != local ) &&
( local == m_hOwnerEntity ) )
{
// Make sure player is driving simulation (field is only ever sent to local player)
SetPlayerSimulated( local );
}
#endif
UpdatePartitionListEntry();
// Add the entity to the nointerp list.
if ( !IsClientCreated() )
{
if ( Teleported() || IsNoInterpolationFrame() )
AddToTeleportList();
}
// if we changed parents, recalculate visibility
if ( m_hOldMoveParent != m_hNetworkMoveParent )
{
UpdateVisibility();
}
// if ShouldDraw state changes, recalculate visibility
if ( m_bOldShouldDraw != ShouldDraw() )
{
UpdateVisibility();
}
}
//-----------------------------------------------------------------------------
// Purpose: Latch simulation values when the entity has not changed
//-----------------------------------------------------------------------------
void C_BaseEntity::OnDataUnchangedInPVS()
{
Assert( m_hNetworkMoveParent.Get() || !m_hNetworkMoveParent.IsValid() );
HierarchySetParent(m_hNetworkMoveParent);
MarkMessageReceived();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *context -
//-----------------------------------------------------------------------------
void C_BaseEntity::CheckInitPredictable( const char *context )
{
#if !defined( NO_ENTITY_PREDICTION )
// Prediction is disabled
if ( !cl_predict->GetInt() )
return;
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
if ( !player )
return;
if ( !GetPredictionEligible() )
{
if ( m_PredictableID.IsActive() &&
( player->index - 1 ) == m_PredictableID.GetPlayer() )
{
// If it comes through with an ID, it should be eligible
SetPredictionEligible( true );
}
else
{
return;
}
}
if ( IsClientCreated() )
return;
if ( !ShouldPredict() )
return;
if ( IsIntermediateDataAllocated() )
return;
// Msg( "Predicting init %s at %s\n", GetClassname(), context );
InitPredictable();
#endif
}
bool C_BaseEntity::IsSelfAnimating()
{
return true;
}
//-----------------------------------------------------------------------------
// EFlags..
//-----------------------------------------------------------------------------
int C_BaseEntity::GetEFlags() const
{
return m_iEFlags;
}
void C_BaseEntity::SetEFlags( int iEFlags )
{
m_iEFlags = iEFlags;
}
//-----------------------------------------------------------------------------
// Sets the model...
//-----------------------------------------------------------------------------
void C_BaseEntity::SetModelByIndex( int nModelIndex )
{
SetModelIndex( nModelIndex );
}
//-----------------------------------------------------------------------------
// Set model... (NOTE: Should only be used by client-only entities
//-----------------------------------------------------------------------------
bool C_BaseEntity::SetModel( const char *pModelName )
{
if ( pModelName )
{
int nModelIndex = modelinfo->GetModelIndex( pModelName );
SetModelByIndex( nModelIndex );
return ( nModelIndex != -1 );
}
else
{
SetModelByIndex( -1 );
return false;
}
}
void C_BaseEntity::OnStoreLastNetworkedValue()
{
bool bRestore = false;
Vector savePos;
QAngle saveAng;
// Kind of a hack, but we want to latch the actual networked value for origin/angles, not what's sitting in m_vecOrigin in the
// ragdoll case where we don't copy it over in MoveToLastNetworkOrigin
if ( m_nRenderFX == kRenderFxRagdoll && GetPredictable() )
{
bRestore = true;
savePos = GetLocalOrigin();
saveAng = GetLocalAngles();
MoveToLastReceivedPosition( true );
}
int c = m_VarMap.m_Entries.Count();
for ( int i = 0; i < c; i++ )
{
VarMapEntry_t *e = &m_VarMap.m_Entries[ i ];
IInterpolatedVar *watcher = e->watcher;
int type = watcher->GetType();
if ( type & EXCLUDE_AUTO_LATCH )
continue;
watcher->NoteLastNetworkedValue();
}
if ( bRestore )
{
SetLocalOrigin( savePos );
SetLocalAngles( saveAng );
}
}
//-----------------------------------------------------------------------------
// Purpose: The animtime is about to be changed in a network update, store off various fields so that
// we can use them to do blended sequence transitions, etc.
// Input : *pState - the (mostly) previous state data
//-----------------------------------------------------------------------------
void C_BaseEntity::OnLatchInterpolatedVariables( int flags )
{
float changetime = GetLastChangeTime( flags );
bool bUpdateLastNetworkedValue = !(flags & INTERPOLATE_OMIT_UPDATE_LAST_NETWORKED) ? true : false;
PREDICTION_TRACKVALUECHANGESCOPE_ENTITY( this, bUpdateLastNetworkedValue ? "latch+net" : "latch" );
int c = m_VarMap.m_Entries.Count();
for ( int i = 0; i < c; i++ )
{
VarMapEntry_t *e = &m_VarMap.m_Entries[ i ];
IInterpolatedVar *watcher = e->watcher;
int type = watcher->GetType();
if ( !(type & flags) )
continue;
if ( type & EXCLUDE_AUTO_LATCH )
continue;
if ( watcher->NoteChanged( changetime, bUpdateLastNetworkedValue ) )
e->m_bNeedsToInterpolate = true;
}
if ( ShouldInterpolate() )
{
AddToInterpolationList();
}
}
int CBaseEntity::BaseInterpolatePart1( float &currentTime, Vector &oldOrigin, QAngle &oldAngles, Vector &oldVel, int &bNoMoreChanges )
{
// Don't mess with the world!!!
bNoMoreChanges = 1;
// These get moved to the parent position automatically
if ( IsFollowingEntity() || !IsInterpolationEnabled() )
{
// Assume current origin ( no interpolation )
MoveToLastReceivedPosition();
return INTERPOLATE_STOP;
}
if ( GetPredictable() || IsClientCreated() )
{
C_BasePlayer *localplayer = C_BasePlayer::GetLocalPlayer();
if ( localplayer && currentTime == gpGlobals->curtime )
{
currentTime = localplayer->GetFinalPredictedTime();
currentTime -= TICK_INTERVAL;
currentTime += ( gpGlobals->interpolation_amount * TICK_INTERVAL );
}
}
oldOrigin = m_vecOrigin;
oldAngles = m_angRotation;
oldVel = m_vecVelocity;
bNoMoreChanges = Interp_Interpolate( GetVarMapping(), currentTime );
if ( cl_interp_all.GetInt() || (m_EntClientFlags & ENTCLIENTFLAG_ALWAYS_INTERPOLATE) )
bNoMoreChanges = 0;
return INTERPOLATE_CONTINUE;
}
#if 0
static ConVar cl_watchplayer( "cl_watchplayer", "-1", 0 );
#endif
void C_BaseEntity::BaseInterpolatePart2( Vector &oldOrigin, QAngle &oldAngles, Vector &oldVel, int nChangeFlags )
{
if ( m_vecOrigin != oldOrigin )
{
nChangeFlags |= POSITION_CHANGED;
}
if( m_angRotation != oldAngles )
{
nChangeFlags |= ANGLES_CHANGED;
}
if ( m_vecVelocity != oldVel )
{
nChangeFlags |= VELOCITY_CHANGED;
}
if ( nChangeFlags != 0 )
{
InvalidatePhysicsRecursive( nChangeFlags );
}
#if 0
if ( index == 1 )
{
SpewInterpolatedVar( &m_iv_vecOrigin, gpGlobals->curtime, GetInterpolationAmount( LATCH_SIMULATION_VAR ), true );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Default interpolation for entities
// Output : true means entity should be drawn, false means probably not
//-----------------------------------------------------------------------------
bool C_BaseEntity::Interpolate( float currentTime )
{
VPROF( "C_BaseEntity::Interpolate" );
Vector oldOrigin;
QAngle oldAngles;
Vector oldVel;
int bNoMoreChanges;
int retVal = BaseInterpolatePart1( currentTime, oldOrigin, oldAngles, oldVel, bNoMoreChanges );
// If all the Interpolate() calls returned that their values aren't going to
// change anymore, then get us out of the interpolation list.
if ( bNoMoreChanges )
RemoveFromInterpolationList();
if ( retVal == INTERPOLATE_STOP )
return true;
int nChangeFlags = 0;
BaseInterpolatePart2( oldOrigin, oldAngles, oldVel, nChangeFlags );
return true;
}
CStudioHdr *C_BaseEntity::OnNewModel()
{
#ifdef TF_CLIENT_DLL
m_bValidatedOwner = false;
#endif
return NULL;
}
void C_BaseEntity::OnNewParticleEffect( const char *pszParticleName, CNewParticleEffect *pNewParticleEffect )
{
return;
}
// Above this velocity and we'll assume a warp/teleport
#define MAX_INTERPOLATE_VELOCITY 4000.0f
#define MAX_INTERPOLATE_VELOCITY_PLAYER 1250.0f
//-----------------------------------------------------------------------------
// Purpose: Determine whether entity was teleported ( so we can disable interpolation )
// Input : *ent -
// Output : bool
//-----------------------------------------------------------------------------
bool C_BaseEntity::Teleported( void )
{
// Disable interpolation when hierarchy changes
if (m_hOldMoveParent != m_hNetworkMoveParent || m_iOldParentAttachment != m_iParentAttachment)
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Is this a submodel of the world ( model name starts with * )?
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseEntity::IsSubModel( void )
{
if ( model &&
modelinfo->GetModelType( model ) == mod_brush &&
modelinfo->GetModelName( model )[0] == '*' )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Create entity lighting effects
//-----------------------------------------------------------------------------
void C_BaseEntity::CreateLightEffects( void )
{
dlight_t *dl;
// Is this for player flashlights only, if so move to linkplayers?
if ( index == render->GetViewEntity() )
return;
if (IsEffectActive(EF_BRIGHTLIGHT))
{
dl = effects->CL_AllocDlight ( index );
dl->origin = GetAbsOrigin();
dl->origin[2] += 16;
dl->color.r = dl->color.g = dl->color.b = 250;
dl->radius = random->RandomFloat(400,431);
dl->die = gpGlobals->curtime + 0.001;
}
if (IsEffectActive(EF_DIMLIGHT))
{
dl = effects->CL_AllocDlight ( index );
dl->origin = GetAbsOrigin();
dl->color.r = dl->color.g = dl->color.b = 100;
dl->radius = random->RandomFloat(200,231);
dl->die = gpGlobals->curtime + 0.001;
}
}
void C_BaseEntity::MoveToLastReceivedPosition( bool force )
{
if ( force || ( m_nRenderFX != kRenderFxRagdoll ) )
{
SetLocalOrigin( GetNetworkOrigin() );
SetLocalAngles( GetNetworkAngles() );
}
}
bool C_BaseEntity::ShouldInterpolate()
{
if ( render->GetViewEntity() == index )
return true;
if ( index == 0 || !GetModel() )
return false;
// always interpolate if visible
if ( IsVisible() )
return true;
// if any movement child needs interpolation, we have to interpolate too
C_BaseEntity *pChild = FirstMoveChild();
while( pChild )
{
if ( pChild->ShouldInterpolate() )
return true;
pChild = pChild->NextMovePeer();
}
// don't interpolate
return false;
}
void C_BaseEntity::ProcessTeleportList()
{
int iNext;
for ( int iCur=g_TeleportList.Head(); iCur != g_TeleportList.InvalidIndex(); iCur=iNext )
{
iNext = g_TeleportList.Next( iCur );
C_BaseEntity *pCur = g_TeleportList[iCur];
bool teleport = pCur->Teleported();
bool ef_nointerp = pCur->IsNoInterpolationFrame();
if ( teleport || ef_nointerp )
{
// Undo the teleport flag..
pCur->m_hOldMoveParent = pCur->m_hNetworkMoveParent;
pCur->m_iOldParentAttachment = pCur->m_iParentAttachment;
// Zero out all but last update.
pCur->MoveToLastReceivedPosition( true );
pCur->ResetLatched();
}
else
{
// Get it out of the list as soon as we can.
pCur->RemoveFromTeleportList();
}
}
}
void C_BaseEntity::CheckInterpolatedVarParanoidMeasurement()
{
// What we're doing here is to check all the entities that were not in the interpolation
// list and make sure that there's no entity that should be in the list that isn't.
#ifdef INTERPOLATEDVAR_PARANOID_MEASUREMENT
int iHighest = ClientEntityList().GetHighestEntityIndex();
for ( int i=0; i <= iHighest; i++ )
{
C_BaseEntity *pEnt = ClientEntityList().GetBaseEntity( i );
if ( !pEnt || pEnt->m_InterpolationListEntry != 0xFFFF || !pEnt->ShouldInterpolate() )
continue;
// Player angles always generates this error when the console is up.
if ( pEnt->entindex() == 1 && engine->Con_IsVisible() )
continue;
// View models tend to screw up this test unnecesarily because they modify origin,
// angles, and
if ( dynamic_cast<C_BaseViewModel*>( pEnt ) )
continue;
g_bRestoreInterpolatedVarValues = true;
g_nInterpolatedVarsChanged = 0;
pEnt->Interpolate( gpGlobals->curtime );
g_bRestoreInterpolatedVarValues = false;
if ( g_nInterpolatedVarsChanged > 0 )
{
static int iWarningCount = 0;
Warning( "(%d): An entity (%d) should have been in g_InterpolationList.\n", iWarningCount++, pEnt->entindex() );
break;
}
}
#endif
}
void C_BaseEntity::ProcessInterpolatedList()
{
CheckInterpolatedVarParanoidMeasurement();
// Interpolate the minimal set of entities that need it.
int iNext;
for ( int iCur=g_InterpolationList.Head(); iCur != g_InterpolationList.InvalidIndex(); iCur=iNext )
{
iNext = g_InterpolationList.Next( iCur );
C_BaseEntity *pCur = g_InterpolationList[iCur];
pCur->m_bReadyToDraw = pCur->Interpolate( gpGlobals->curtime );
}
}
//-----------------------------------------------------------------------------
// Purpose: Add entity to visibile entities list
//-----------------------------------------------------------------------------
void C_BaseEntity::AddEntity( void )
{
// Don't ever add the world, it's drawn separately
if ( index == 0 )
return;
// Create flashlight effects, etc.
CreateLightEffects();
}
//-----------------------------------------------------------------------------
// Returns the aiment render origin + angles
//-----------------------------------------------------------------------------
void C_BaseEntity::GetAimEntOrigin( IClientEntity *pAttachedTo, Vector *pOrigin, QAngle *pAngles )
{
// Should be overridden for things that attach to attchment points
// Slam origin to the origin of the entity we are attached to...
*pOrigin = pAttachedTo->GetAbsOrigin();
*pAngles = pAttachedTo->GetAbsAngles();
}
void C_BaseEntity::StopFollowingEntity( )
{
Assert( IsFollowingEntity() );
SetParent( NULL );
RemoveEffects( EF_BONEMERGE );
RemoveSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_NONE );
}
bool C_BaseEntity::IsFollowingEntity()
{
return IsEffectActive(EF_BONEMERGE) && (GetMoveType() == MOVETYPE_NONE) && GetMoveParent();
}
C_BaseEntity *CBaseEntity::GetFollowedEntity()
{
if (!IsFollowingEntity())
return NULL;
return GetMoveParent();
}
//-----------------------------------------------------------------------------
// Default implementation for GetTextureAnimationStartTime
//-----------------------------------------------------------------------------
float C_BaseEntity::GetTextureAnimationStartTime()
{
return m_flSpawnTime;
}
//-----------------------------------------------------------------------------
// Default implementation, indicates that a texture animation has wrapped
//-----------------------------------------------------------------------------
void C_BaseEntity::TextureAnimationWrapped()
{
}
void C_BaseEntity::ClientThink()
{
}
void C_BaseEntity::Simulate()
{
AddEntity(); // Legacy support. Once-per-frame stuff should go in Simulate().
}
// Defined in engine
static ConVar cl_interpolate( "cl_interpolate", "1.0f", FCVAR_USERINFO | FCVAR_DEVELOPMENTONLY );
// (static function)
void C_BaseEntity::InterpolateServerEntities()
{
VPROF_BUDGET( "C_BaseEntity::InterpolateServerEntities", VPROF_BUDGETGROUP_INTERPOLATION );
s_bInterpolate = cl_interpolate.GetBool();
// Don't interpolate during timedemo playback
if ( engine->IsPlayingTimeDemo() || engine->IsPaused() )
{
s_bInterpolate = false;
}
if ( !engine->IsPlayingDemo() )
{
// Don't interpolate, either, if we are timing out
INetChannelInfo *nci = engine->GetNetChannelInfo();
if ( nci && nci->GetTimeSinceLastReceived() > 0.5f )
{
s_bInterpolate = false;
}
}
if ( IsSimulatingOnAlternateTicks() != g_bWasSkipping || IsEngineThreaded() != g_bWasThreaded )
{
g_bWasSkipping = IsSimulatingOnAlternateTicks();
g_bWasThreaded = IsEngineThreaded();
C_BaseEntityIterator iterator;
C_BaseEntity *pEnt;
while ( (pEnt = iterator.Next()) != NULL )
{
pEnt->Interp_UpdateInterpolationAmounts( pEnt->GetVarMapping() );
}
}
// Enable extrapolation?
CInterpolationContext context;
context.SetLastTimeStamp( engine->GetLastTimeStamp() );
if ( cl_extrapolate.GetBool() && !engine->IsPaused() )
{
context.EnableExtrapolation( true );
}
// Smoothly interpolate position for server entities.
ProcessTeleportList();
ProcessInterpolatedList();
}
// (static function)
void C_BaseEntity::AddVisibleEntities()
{
#if !defined( NO_ENTITY_PREDICTION )
VPROF_BUDGET( "C_BaseEntity::AddVisibleEntities", VPROF_BUDGETGROUP_WORLD_RENDERING );
// Let non-dormant client created predictables get added, too
int c = predictables->GetPredictableCount();
for ( int i = 0 ; i < c ; i++ )
{
C_BaseEntity *pEnt = predictables->GetPredictable( i );
if ( !pEnt )
continue;
if ( !pEnt->IsClientCreated() )
continue;
// Only draw until it's ack'd since that means a real entity has arrived
if ( pEnt->m_PredictableID.GetAcknowledged() )
continue;
// Don't draw if dormant
if ( pEnt->IsDormantPredictable() )
continue;
pEnt->UpdateVisibility();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : type -
//-----------------------------------------------------------------------------
void C_BaseEntity::OnPreDataChanged( DataUpdateType_t type )
{
m_hOldMoveParent = m_hNetworkMoveParent;
m_iOldParentAttachment = m_iParentAttachment;
}
void C_BaseEntity::OnDataChanged( DataUpdateType_t type )
{
// See if it needs to allocate prediction stuff
CheckInitPredictable( "OnDataChanged" );
// Set up shadows; do it here so that objects can change shadowcasting state
CreateShadow();
if ( type == DATA_UPDATE_CREATED )
{
UpdateVisibility();
}
}
ClientThinkHandle_t C_BaseEntity::GetThinkHandle()
{
return m_hThink;
}
void C_BaseEntity::SetThinkHandle( ClientThinkHandle_t hThink )
{
m_hThink = hThink;
}
//-----------------------------------------------------------------------------
// Purpose: This routine modulates renderamt according to m_nRenderFX's value
// This is a client side effect and will not be in-sync on machines across a
// network game.
// Input : origin -
// alpha -
// Output : int
//-----------------------------------------------------------------------------
void C_BaseEntity::ComputeFxBlend( void )
{
// Don't recompute if we've already computed this frame
if ( m_nFXComputeFrame == gpGlobals->framecount )
return;
int blend=0;
float offset;
offset = ((int)index) * 363.0;// Use ent index to de-sync these fx
switch( m_nRenderFX )
{
case kRenderFxPulseSlowWide:
blend = m_clrRender->a + 0x40 * sin( gpGlobals->curtime * 2 + offset );
break;
case kRenderFxPulseFastWide:
blend = m_clrRender->a + 0x40 * sin( gpGlobals->curtime * 8 + offset );
break;
case kRenderFxPulseFastWider:
blend = ( 0xff * fabs(sin( gpGlobals->curtime * 12 + offset ) ) );
break;
case kRenderFxPulseSlow:
blend = m_clrRender->a + 0x10 * sin( gpGlobals->curtime * 2 + offset );
break;
case kRenderFxPulseFast:
blend = m_clrRender->a + 0x10 * sin( gpGlobals->curtime * 8 + offset );
break;
// JAY: HACK for now -- not time based
case kRenderFxFadeSlow:
if ( m_clrRender->a > 0 )
{
SetRenderColorA( m_clrRender->a - 1 );
}
else
{
SetRenderColorA( 0 );
}
blend = m_clrRender->a;
break;
case kRenderFxFadeFast:
if ( m_clrRender->a > 3 )
{
SetRenderColorA( m_clrRender->a - 4 );
}
else
{
SetRenderColorA( 0 );
}
blend = m_clrRender->a;
break;
case kRenderFxSolidSlow:
if ( m_clrRender->a < 255 )
{
SetRenderColorA( m_clrRender->a + 1 );
}
else
{
SetRenderColorA( 255 );
}
blend = m_clrRender->a;
break;
case kRenderFxSolidFast:
if ( m_clrRender->a < 252 )
{
SetRenderColorA( m_clrRender->a + 4 );
}
else
{
SetRenderColorA( 255 );
}
blend = m_clrRender->a;
break;
case kRenderFxStrobeSlow:
blend = 20 * sin( gpGlobals->curtime * 4 + offset );
if ( blend < 0 )
{
blend = 0;
}
else
{
blend = m_clrRender->a;
}
break;
case kRenderFxStrobeFast:
blend = 20 * sin( gpGlobals->curtime * 16 + offset );
if ( blend < 0 )
{
blend = 0;
}
else
{
blend = m_clrRender->a;
}
break;
case kRenderFxStrobeFaster:
blend = 20 * sin( gpGlobals->curtime * 36 + offset );
if ( blend < 0 )
{
blend = 0;
}
else
{
blend = m_clrRender->a;
}
break;
case kRenderFxFlickerSlow:
blend = 20 * (sin( gpGlobals->curtime * 2 ) + sin( gpGlobals->curtime * 17 + offset ));
if ( blend < 0 )
{
blend = 0;
}
else
{
blend = m_clrRender->a;
}
break;
case kRenderFxFlickerFast:
blend = 20 * (sin( gpGlobals->curtime * 16 ) + sin( gpGlobals->curtime * 23 + offset ));
if ( blend < 0 )
{
blend = 0;
}
else
{
blend = m_clrRender->a;
}
break;
case kRenderFxHologram:
case kRenderFxDistort:
{
Vector tmp;
float dist;
VectorCopy( GetAbsOrigin(), tmp );
VectorSubtract( tmp, CurrentViewOrigin(), tmp );
dist = DotProduct( tmp, CurrentViewForward() );
// Turn off distance fade
if ( m_nRenderFX == kRenderFxDistort )
{
dist = 1;
}
if ( dist <= 0 )
{
blend = 0;
}
else
{
SetRenderColorA( 180 );
if ( dist <= 100 )
blend = m_clrRender->a;
else
blend = (int) ((1.0 - (dist - 100) * (1.0 / 400.0)) * m_clrRender->a);
blend += random->RandomInt(-32,31);
}
}
break;
case kRenderFxNone:
case kRenderFxClampMinScale:
default:
if (m_nRenderMode == kRenderNormal)
blend = 255;
else
blend = m_clrRender->a;
break;
}
blend = clamp( blend, 0, 255 );
// Look for client-side fades
unsigned char nFadeAlpha = GetClientSideFade();
if ( nFadeAlpha != 255 )
{
float flBlend = blend / 255.0f;
float flFade = nFadeAlpha / 255.0f;
blend = (int)( flBlend * flFade * 255.0f + 0.5f );
blend = clamp( blend, 0, 255 );
}
m_nRenderFXBlend = blend;
m_nFXComputeFrame = gpGlobals->framecount;
// Update the render group
if ( GetRenderHandle() != INVALID_CLIENT_RENDER_HANDLE )
{
ClientLeafSystem()->SetRenderGroup( GetRenderHandle(), GetRenderGroup() );
}
// Tell our shadow
if ( m_ShadowHandle != CLIENTSHADOW_INVALID_HANDLE )
{
g_pClientShadowMgr->SetFalloffBias( m_ShadowHandle, (255 - m_nRenderFXBlend) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int C_BaseEntity::GetFxBlend( void )
{
Assert( m_nFXComputeFrame == gpGlobals->framecount );
return m_nRenderFXBlend;
}
//-----------------------------------------------------------------------------
// Determine the color modulation amount
//-----------------------------------------------------------------------------
void C_BaseEntity::GetColorModulation( float* color )
{
color[0] = m_clrRender->r / 255.0f;
color[1] = m_clrRender->g / 255.0f;
color[2] = m_clrRender->b / 255.0f;
}
//-----------------------------------------------------------------------------
// Returns true if we should add this to the collision list
//-----------------------------------------------------------------------------
CollideType_t C_BaseEntity::GetCollideType( void )
{
if ( !m_nModelIndex || !model )
return ENTITY_SHOULD_NOT_COLLIDE;
if ( !IsSolid( ) )
return ENTITY_SHOULD_NOT_COLLIDE;
// If the model is a bsp or studio (i.e. it can collide with the player
if ( ( modelinfo->GetModelType( model ) != mod_brush ) && ( modelinfo->GetModelType( model ) != mod_studio ) )
return ENTITY_SHOULD_NOT_COLLIDE;
// Don't get stuck on point sized entities ( world doesn't count )
if ( m_nModelIndex != 1 )
{
if ( IsPointSized() )
return ENTITY_SHOULD_NOT_COLLIDE;
}
return ENTITY_SHOULD_COLLIDE;
}
//-----------------------------------------------------------------------------
// Is this a brush model?
//-----------------------------------------------------------------------------
bool C_BaseEntity::IsBrushModel() const
{
int modelType = modelinfo->GetModelType( model );
return (modelType == mod_brush);
}
//-----------------------------------------------------------------------------
// This method works when we've got a studio model
//-----------------------------------------------------------------------------
void C_BaseEntity::AddStudioDecal( const Ray_t& ray, int hitbox, int decalIndex,
bool doTrace, trace_t& tr, int maxLODToDecal )
{
if (doTrace)
{
enginetrace->ClipRayToEntity( ray, MASK_SHOT, this, &tr );
// Trace the ray against the entity
if (tr.fraction == 1.0f)
return;
// Set the trace index appropriately...
tr.m_pEnt = this;
}
// Exit out after doing the trace so any other effects that want to happen can happen.
if ( !r_drawmodeldecals.GetBool() )
return;
// Found the point, now lets apply the decals
CreateModelInstance();
// FIXME: Pass in decal up?
Vector up(0, 0, 1);
if (doTrace && (GetSolid() == SOLID_VPHYSICS) && !tr.startsolid && !tr.allsolid)
{
// Choose a more accurate normal direction
// Also, since we have more accurate info, we can avoid pokethru
Vector temp;
VectorSubtract( tr.endpos, tr.plane.normal, temp );
Ray_t betterRay;
betterRay.Init( tr.endpos, temp );
modelrender->AddDecal( m_ModelInstance, betterRay, up, decalIndex, GetStudioBody(), true, maxLODToDecal );
}
else
{
modelrender->AddDecal( m_ModelInstance, ray, up, decalIndex, GetStudioBody(), false, maxLODToDecal );
}
}
//-----------------------------------------------------------------------------
void C_BaseEntity::AddColoredStudioDecal( const Ray_t& ray, int hitbox, int decalIndex,
bool doTrace, trace_t& tr, Color cColor, int maxLODToDecal )
{
if (doTrace)
{
enginetrace->ClipRayToEntity( ray, MASK_SHOT, this, &tr );
// Trace the ray against the entity
if (tr.fraction == 1.0f)
return;
// Set the trace index appropriately...
tr.m_pEnt = this;
}
// Exit out after doing the trace so any other effects that want to happen can happen.
if ( !r_drawmodeldecals.GetBool() )
return;
// Found the point, now lets apply the decals
CreateModelInstance();
// FIXME: Pass in decal up?
Vector up(0, 0, 1);
if (doTrace && (GetSolid() == SOLID_VPHYSICS) && !tr.startsolid && !tr.allsolid)
{
// Choose a more accurate normal direction
// Also, since we have more accurate info, we can avoid pokethru
Vector temp;
VectorSubtract( tr.endpos, tr.plane.normal, temp );
Ray_t betterRay;
betterRay.Init( tr.endpos, temp );
modelrender->AddColoredDecal( m_ModelInstance, betterRay, up, decalIndex, GetStudioBody(), cColor, true, maxLODToDecal );
}
else
{
modelrender->AddColoredDecal( m_ModelInstance, ray, up, decalIndex, GetStudioBody(), cColor, false, maxLODToDecal );
}
}
//-----------------------------------------------------------------------------
// This method works when we've got a brush model
//-----------------------------------------------------------------------------
void C_BaseEntity::AddBrushModelDecal( const Ray_t& ray, const Vector& decalCenter,
int decalIndex, bool doTrace, trace_t& tr )
{
if ( doTrace )
{
enginetrace->ClipRayToEntity( ray, MASK_SHOT, this, &tr );
if ( tr.fraction == 1.0f )
return;
}
effects->DecalShoot( decalIndex, index,
model, GetAbsOrigin(), GetAbsAngles(), decalCenter, 0, 0 );
}
//-----------------------------------------------------------------------------
// A method to apply a decal to an entity
//-----------------------------------------------------------------------------
void C_BaseEntity::AddDecal( const Vector& rayStart, const Vector& rayEnd,
const Vector& decalCenter, int hitbox, int decalIndex, bool doTrace, trace_t& tr, int maxLODToDecal )
{
Ray_t ray;
ray.Init( rayStart, rayEnd );
// FIXME: Better bloat?
// Bloat a little bit so we get the intersection
ray.m_Delta *= 1.1f;
int modelType = modelinfo->GetModelType( model );
switch ( modelType )
{
case mod_studio:
AddStudioDecal( ray, hitbox, decalIndex, doTrace, tr, maxLODToDecal );
break;
case mod_brush:
AddBrushModelDecal( ray, decalCenter, decalIndex, doTrace, tr );
break;
default:
// By default, no collision
tr.fraction = 1.0f;
break;
}
}
//-----------------------------------------------------------------------------
void C_BaseEntity::AddColoredDecal( const Vector& rayStart, const Vector& rayEnd,
const Vector& decalCenter, int hitbox, int decalIndex, bool doTrace, trace_t& tr, Color cColor, int maxLODToDecal )
{
Ray_t ray;
ray.Init( rayStart, rayEnd );
// FIXME: Better bloat?
// Bloat a little bit so we get the intersection
ray.m_Delta *= 1.1f;
int modelType = modelinfo->GetModelType( model );
if ( doTrace )
{
enginetrace->ClipRayToEntity( ray, MASK_SHOT, this, &tr );
switch ( modelType )
{
case mod_studio:
tr.m_pEnt = this;
break;
case mod_brush:
if ( tr.fraction == 1.0f )
return; // Explicitly end
default:
// By default, no collision
tr.fraction = 1.0f;
break;
}
}
switch ( modelType )
{
case mod_studio:
AddColoredStudioDecal( ray, hitbox, decalIndex, doTrace, tr, cColor, maxLODToDecal );
break;
case mod_brush:
{
color32 cColor32 = { (byte)cColor.r(), (byte)cColor.g(), (byte)cColor.b(), (byte)cColor.a() };
effects->DecalColorShoot( decalIndex, index, model, GetAbsOrigin(), GetAbsAngles(), decalCenter, 0, 0, cColor32 );
}
break;
default:
// By default, no collision
tr.fraction = 1.0f;
break;
}
}
//-----------------------------------------------------------------------------
// A method to remove all decals from an entity
//-----------------------------------------------------------------------------
void C_BaseEntity::RemoveAllDecals( void )
{
// For now, we only handle removing decals from studiomodels
if ( modelinfo->GetModelType( model ) == mod_studio )
{
CreateModelInstance();
modelrender->RemoveAllDecals( m_ModelInstance );
}
}
bool C_BaseEntity::SnatchModelInstance( C_BaseEntity *pToEntity )
{
if ( !modelrender->ChangeInstance( GetModelInstance(), pToEntity ) )
return false; // engine could move modle handle
// remove old handle from toentity if any
if ( pToEntity->GetModelInstance() != MODEL_INSTANCE_INVALID )
pToEntity->DestroyModelInstance();
// move the handle to other entity
pToEntity->SetModelInstance( GetModelInstance() );
// delete own reference
SetModelInstance( MODEL_INSTANCE_INVALID );
return true;
}
#include "tier0/memdbgoff.h"
//-----------------------------------------------------------------------------
// C_BaseEntity new/delete
// All fields in the object are all initialized to 0.
//-----------------------------------------------------------------------------
void *C_BaseEntity::operator new( size_t stAllocateBlock )
{
Assert( stAllocateBlock != 0 );
MEM_ALLOC_CREDIT();
void *pMem = MemAlloc_Alloc( stAllocateBlock );
memset( pMem, 0, stAllocateBlock );
return pMem;
}
void *C_BaseEntity::operator new[]( size_t stAllocateBlock )
{
Assert( stAllocateBlock != 0 );
MEM_ALLOC_CREDIT();
void *pMem = MemAlloc_Alloc( stAllocateBlock );
memset( pMem, 0, stAllocateBlock );
return pMem;
}
void *C_BaseEntity::operator new( size_t stAllocateBlock, int nBlockUse, const char *pFileName, int nLine )
{
Assert( stAllocateBlock != 0 );
void *pMem = MemAlloc_Alloc( stAllocateBlock, pFileName, nLine );
memset( pMem, 0, stAllocateBlock );
return pMem;
}
void *C_BaseEntity::operator new[]( size_t stAllocateBlock, int nBlockUse, const char *pFileName, int nLine )
{
Assert( stAllocateBlock != 0 );
void *pMem = MemAlloc_Alloc( stAllocateBlock, pFileName, nLine );
memset( pMem, 0, stAllocateBlock );
return pMem;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pMem -
//-----------------------------------------------------------------------------
void C_BaseEntity::operator delete( void *pMem )
{
// get the engine to free the memory
MemAlloc_Free( pMem );
}
#include "tier0/memdbgon.h"
//========================================================================================
// TEAM HANDLING
//========================================================================================
C_Team *C_BaseEntity::GetTeam( void ) const
{
return GetGlobalTeam( m_iTeamNum );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int C_BaseEntity::GetTeamNumber( void ) const
{
return m_iTeamNum;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int C_BaseEntity::GetRenderTeamNumber( void )
{
return GetTeamNumber();
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if these entities are both in at least one team together
//-----------------------------------------------------------------------------
bool C_BaseEntity::InSameTeam( const C_BaseEntity *pEntity ) const
{
if ( !pEntity )
return false;
return ( pEntity->GetTeam() == GetTeam() );
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if the entity's on the same team as the local player
//-----------------------------------------------------------------------------
bool C_BaseEntity::InLocalTeam( void )
{
return ( GetTeam() == GetLocalTeam() );
}
void C_BaseEntity::SetNextClientThink( float nextThinkTime )
{
Assert( GetClientHandle() != INVALID_CLIENTENTITY_HANDLE );
ClientThinkList()->SetNextClientThink( GetClientHandle(), nextThinkTime );
}
void C_BaseEntity::AddToLeafSystem()
{
AddToLeafSystem( GetRenderGroup() );
}
void C_BaseEntity::AddToLeafSystem( RenderGroup_t group )
{
if( m_hRender == INVALID_CLIENT_RENDER_HANDLE )
{
// create new renderer handle
ClientLeafSystem()->AddRenderable( this, group );
ClientLeafSystem()->EnableAlternateSorting( m_hRender, m_bAlternateSorting );
}
else
{
// handle already exists, just update group & origin
ClientLeafSystem()->SetRenderGroup( m_hRender, group );
ClientLeafSystem()->RenderableChanged( m_hRender );
}
}
//-----------------------------------------------------------------------------
// Creates the shadow (if it doesn't already exist) based on shadow cast type
//-----------------------------------------------------------------------------
void C_BaseEntity::CreateShadow()
{
ShadowType_t shadowType = ShadowCastType();
if (shadowType == SHADOWS_NONE)
{
DestroyShadow();
}
else
{
if (m_ShadowHandle == CLIENTSHADOW_INVALID_HANDLE)
{
int flags = SHADOW_FLAGS_SHADOW;
if (shadowType != SHADOWS_SIMPLE)
flags |= SHADOW_FLAGS_USE_RENDER_TO_TEXTURE;
if (shadowType == SHADOWS_RENDER_TO_TEXTURE_DYNAMIC)
flags |= SHADOW_FLAGS_ANIMATING_SOURCE;
m_ShadowHandle = g_pClientShadowMgr->CreateShadow(GetClientHandle(), flags);
}
}
}
//-----------------------------------------------------------------------------
// Removes the shadow
//-----------------------------------------------------------------------------
void C_BaseEntity::DestroyShadow()
{
// NOTE: This will actually cause the shadow type to be recomputed
// if the entity doesn't immediately go away
if (m_ShadowHandle != CLIENTSHADOW_INVALID_HANDLE)
{
g_pClientShadowMgr->DestroyShadow(m_ShadowHandle);
m_ShadowHandle = CLIENTSHADOW_INVALID_HANDLE;
}
}
//-----------------------------------------------------------------------------
// Removes the entity from the leaf system
//-----------------------------------------------------------------------------
void C_BaseEntity::RemoveFromLeafSystem()
{
// Detach from the leaf lists.
if( m_hRender != INVALID_CLIENT_RENDER_HANDLE )
{
ClientLeafSystem()->RemoveRenderable( m_hRender );
m_hRender = INVALID_CLIENT_RENDER_HANDLE;
}
DestroyShadow();
}
//-----------------------------------------------------------------------------
// Purpose: Flags this entity as being inside or outside of this client's PVS
// on the server.
// NOTE: this is meaningless for client-side only entities.
// Input : inside_pvs -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetDormant( bool bDormant )
{
Assert( IsServerEntity() );
m_bDormant = bDormant;
// Kill drawing if we became dormant.
UpdateVisibility();
ParticleProp()->OwnerSetDormantTo( bDormant );
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether this entity is dormant. Client/server entities become
// dormant when they leave the PVS on the server. Client side entities
// can decide for themselves whether to become dormant.
//-----------------------------------------------------------------------------
bool C_BaseEntity::IsDormant( void )
{
if ( IsServerEntity() )
{
return m_bDormant;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Tells the entity that it's about to be destroyed due to the client receiving
// an uncompressed update that's caused it to destroy all entities & recreate them.
//-----------------------------------------------------------------------------
void C_BaseEntity::SetDestroyedOnRecreateEntities( void )
{
// Robin: We need to destroy all our particle systems immediately, because
// we're about to be recreated, and their owner EHANDLEs will match up to
// the new entity, but it won't know anything about them.
ParticleProp()->StopEmissionAndDestroyImmediately();
}
//-----------------------------------------------------------------------------
// These methods recompute local versions as well as set abs versions
//-----------------------------------------------------------------------------
void C_BaseEntity::SetAbsOrigin( const Vector& absOrigin )
{
// This is necessary to get the other fields of m_rgflCoordinateFrame ok
CalcAbsolutePosition();
if ( m_vecAbsOrigin == absOrigin )
return;
// All children are invalid, but we are not
InvalidatePhysicsRecursive( POSITION_CHANGED );
RemoveEFlags( EFL_DIRTY_ABSTRANSFORM );
m_vecAbsOrigin = absOrigin;
MatrixSetColumn( absOrigin, 3, m_rgflCoordinateFrame );
C_BaseEntity *pMoveParent = GetMoveParent();
if (!pMoveParent)
{
m_vecOrigin = absOrigin;
return;
}
// Moveparent case: transform the abs position into local space
VectorITransform( absOrigin, pMoveParent->EntityToWorldTransform(), (Vector&)m_vecOrigin );
}
void C_BaseEntity::SetAbsAngles( const QAngle& absAngles )
{
// This is necessary to get the other fields of m_rgflCoordinateFrame ok
CalcAbsolutePosition();
// FIXME: The normalize caused problems in server code like momentary_rot_button that isn't
// handling things like +/-180 degrees properly. This should be revisited.
//QAngle angleNormalize( AngleNormalize( absAngles.x ), AngleNormalize( absAngles.y ), AngleNormalize( absAngles.z ) );
if ( m_angAbsRotation == absAngles )
return;
InvalidatePhysicsRecursive( ANGLES_CHANGED );
RemoveEFlags( EFL_DIRTY_ABSTRANSFORM );
m_angAbsRotation = absAngles;
AngleMatrix( absAngles, m_rgflCoordinateFrame );
MatrixSetColumn( m_vecAbsOrigin, 3, m_rgflCoordinateFrame );
C_BaseEntity *pMoveParent = GetMoveParent();
if (!pMoveParent)
{
m_angRotation = absAngles;
return;
}
// Moveparent case: we're aligned with the move parent
if ( m_angAbsRotation == pMoveParent->GetAbsAngles() )
{
m_angRotation.Init( );
}
else
{
// Moveparent case: transform the abs transform into local space
matrix3x4_t worldToParent, localMatrix;
MatrixInvert( pMoveParent->EntityToWorldTransform(), worldToParent );
ConcatTransforms( worldToParent, m_rgflCoordinateFrame, localMatrix );
MatrixAngles( localMatrix, (QAngle &)m_angRotation );
}
}
void C_BaseEntity::SetAbsVelocity( const Vector &vecAbsVelocity )
{
if ( m_vecAbsVelocity == vecAbsVelocity )
return;
// The abs velocity won't be dirty since we're setting it here
InvalidatePhysicsRecursive( VELOCITY_CHANGED );
m_iEFlags &= ~EFL_DIRTY_ABSVELOCITY;
m_vecAbsVelocity = vecAbsVelocity;
C_BaseEntity *pMoveParent = GetMoveParent();
if (!pMoveParent)
{
m_vecVelocity = vecAbsVelocity;
return;
}
// First subtract out the parent's abs velocity to get a relative
// velocity measured in world space
Vector relVelocity;
VectorSubtract( vecAbsVelocity, pMoveParent->GetAbsVelocity(), relVelocity );
// Transform velocity into parent space
VectorIRotate( relVelocity, pMoveParent->EntityToWorldTransform(), m_vecVelocity );
}
/*
void C_BaseEntity::SetAbsAngularVelocity( const QAngle &vecAbsAngVelocity )
{
// The abs velocity won't be dirty since we're setting it here
InvalidatePhysicsRecursive( EFL_DIRTY_ABSANGVELOCITY );
m_iEFlags &= ~EFL_DIRTY_ABSANGVELOCITY;
m_vecAbsAngVelocity = vecAbsAngVelocity;
C_BaseEntity *pMoveParent = GetMoveParent();
if (!pMoveParent)
{
m_vecAngVelocity = vecAbsAngVelocity;
return;
}
// First subtract out the parent's abs velocity to get a relative
// angular velocity measured in world space
QAngle relAngVelocity;
relAngVelocity = vecAbsAngVelocity - pMoveParent->GetAbsAngularVelocity();
matrix3x4_t entityToWorld;
AngleMatrix( relAngVelocity, entityToWorld );
// Moveparent case: transform the abs angular vel into local space
matrix3x4_t worldToParent, localMatrix;
MatrixInvert( pMoveParent->EntityToWorldTransform(), worldToParent );
ConcatTransforms( worldToParent, entityToWorld, localMatrix );
MatrixAngles( localMatrix, m_vecAngVelocity );
}
*/
// Prevent these for now until hierarchy is properly networked
const Vector& C_BaseEntity::GetLocalOrigin( void ) const
{
return m_vecOrigin;
}
vec_t C_BaseEntity::GetLocalOriginDim( int iDim ) const
{
return m_vecOrigin[iDim];
}
// Prevent these for now until hierarchy is properly networked
void C_BaseEntity::SetLocalOrigin( const Vector& origin )
{
if (m_vecOrigin != origin)
{
InvalidatePhysicsRecursive( POSITION_CHANGED );
m_vecOrigin = origin;
}
}
void C_BaseEntity::SetLocalOriginDim( int iDim, vec_t flValue )
{
if (m_vecOrigin[iDim] != flValue)
{
InvalidatePhysicsRecursive( POSITION_CHANGED );
m_vecOrigin[iDim] = flValue;
}
}
// Prevent these for now until hierarchy is properly networked
const QAngle& C_BaseEntity::GetLocalAngles( void ) const
{
return m_angRotation;
}
vec_t C_BaseEntity::GetLocalAnglesDim( int iDim ) const
{
return m_angRotation[iDim];
}
// Prevent these for now until hierarchy is properly networked
void C_BaseEntity::SetLocalAngles( const QAngle& angles )
{
// NOTE: The angle normalize is a little expensive, but we can save
// a bunch of time in interpolation if we don't have to invalidate everything
// and sometimes it's off by a normalization amount
// FIXME: The normalize caused problems in server code like momentary_rot_button that isn't
// handling things like +/-180 degrees properly. This should be revisited.
//QAngle angleNormalize( AngleNormalize( angles.x ), AngleNormalize( angles.y ), AngleNormalize( angles.z ) );
if (m_angRotation != angles)
{
// This will cause the velocities of all children to need recomputation
InvalidatePhysicsRecursive( ANGLES_CHANGED );
m_angRotation = angles;
}
}
void C_BaseEntity::SetLocalAnglesDim( int iDim, vec_t flValue )
{
flValue = AngleNormalize( flValue );
if (m_angRotation[iDim] != flValue)
{
// This will cause the velocities of all children to need recomputation
InvalidatePhysicsRecursive( ANGLES_CHANGED );
m_angRotation[iDim] = flValue;
}
}
void C_BaseEntity::SetLocalVelocity( const Vector &vecVelocity )
{
if (m_vecVelocity != vecVelocity)
{
InvalidatePhysicsRecursive( VELOCITY_CHANGED );
m_vecVelocity = vecVelocity;
}
}
void C_BaseEntity::SetLocalAngularVelocity( const QAngle &vecAngVelocity )
{
if (m_vecAngVelocity != vecAngVelocity)
{
// InvalidatePhysicsRecursive( ANG_VELOCITY_CHANGED );
m_vecAngVelocity = vecAngVelocity;
}
}
//-----------------------------------------------------------------------------
// Sets the local position from a transform
//-----------------------------------------------------------------------------
void C_BaseEntity::SetLocalTransform( const matrix3x4_t &localTransform )
{
Vector vecLocalOrigin;
QAngle vecLocalAngles;
MatrixGetColumn( localTransform, 3, vecLocalOrigin );
MatrixAngles( localTransform, vecLocalAngles );
SetLocalOrigin( vecLocalOrigin );
SetLocalAngles( vecLocalAngles );
}
//-----------------------------------------------------------------------------
// FIXME: REMOVE!!!
//-----------------------------------------------------------------------------
void C_BaseEntity::MoveToAimEnt( )
{
Vector vecAimEntOrigin;
QAngle vecAimEntAngles;
GetAimEntOrigin( GetMoveParent(), &vecAimEntOrigin, &vecAimEntAngles );
SetAbsOrigin( vecAimEntOrigin );
SetAbsAngles( vecAimEntAngles );
}
void C_BaseEntity::BoneMergeFastCullBloat( Vector &localMins, Vector &localMaxs, const Vector &thisEntityMins, const Vector &thisEntityMaxs ) const
{
// By default, we bloat the bbox for fastcull ents by the maximum length it could hang out of the parent bbox,
// it one corner were touching the edge of the parent's box, and the whole diagonal stretched out.
float flExpand = (thisEntityMaxs - thisEntityMins).Length();
localMins.x -= flExpand;
localMins.y -= flExpand;
localMins.z -= flExpand;
localMaxs.x += flExpand;
localMaxs.y += flExpand;
localMaxs.z += flExpand;
}
matrix3x4_t& C_BaseEntity::GetParentToWorldTransform( matrix3x4_t &tempMatrix )
{
CBaseEntity *pMoveParent = GetMoveParent();
if ( !pMoveParent )
{
Assert( false );
SetIdentityMatrix( tempMatrix );
return tempMatrix;
}
if ( m_iParentAttachment != 0 )
{
Vector vOrigin;
QAngle vAngles;
if ( pMoveParent->GetAttachment( m_iParentAttachment, vOrigin, vAngles ) )
{
AngleMatrix( vAngles, vOrigin, tempMatrix );
return tempMatrix;
}
}
// If we fall through to here, then just use the move parent's abs origin and angles.
return pMoveParent->EntityToWorldTransform();
}
//-----------------------------------------------------------------------------
// Purpose: Calculates the absolute position of an edict in the world
// assumes the parent's absolute origin has already been calculated
//-----------------------------------------------------------------------------
void C_BaseEntity::CalcAbsolutePosition( )
{
// There are periods of time where we're gonna have to live with the
// fact that we're in an indeterminant state and abs queries (which
// shouldn't be happening at all; I have assertions for those), will
// just have to accept stale data.
if (!s_bAbsRecomputationEnabled)
return;
// FIXME: Recompute absbox!!!
if ((m_iEFlags & EFL_DIRTY_ABSTRANSFORM) == 0)
{
// quick check to make sure we really don't need an update
// Assert( m_pMoveParent || m_vecAbsOrigin == GetLocalOrigin() );
return;
}
AUTO_LOCK( m_CalcAbsolutePositionMutex );
if ((m_iEFlags & EFL_DIRTY_ABSTRANSFORM) == 0) // need second check in event another thread grabbed mutex and did the calculation
{
return;
}
RemoveEFlags( EFL_DIRTY_ABSTRANSFORM );
if (!m_pMoveParent)
{
// Construct the entity-to-world matrix
// Start with making an entity-to-parent matrix
AngleMatrix( GetLocalAngles(), GetLocalOrigin(), m_rgflCoordinateFrame );
m_vecAbsOrigin = GetLocalOrigin();
m_angAbsRotation = GetLocalAngles();
NormalizeAngles( m_angAbsRotation );
return;
}
if ( IsEffectActive(EF_BONEMERGE) )
{
MoveToAimEnt();
return;
}
// Construct the entity-to-world matrix
// Start with making an entity-to-parent matrix
matrix3x4_t matEntityToParent;
AngleMatrix( GetLocalAngles(), matEntityToParent );
MatrixSetColumn( GetLocalOrigin(), 3, matEntityToParent );
// concatenate with our parent's transform
matrix3x4_t scratchMatrix;
ConcatTransforms( GetParentToWorldTransform( scratchMatrix ), matEntityToParent, m_rgflCoordinateFrame );
// pull our absolute position out of the matrix
MatrixGetColumn( m_rgflCoordinateFrame, 3, m_vecAbsOrigin );
// if we have any angles, we have to extract our absolute angles from our matrix
if ( m_angRotation == vec3_angle && m_iParentAttachment == 0 )
{
// just copy our parent's absolute angles
VectorCopy( m_pMoveParent->GetAbsAngles(), m_angAbsRotation );
}
else
{
MatrixAngles( m_rgflCoordinateFrame, m_angAbsRotation );
}
// This is necessary because it's possible that our moveparent's CalculateIKLocks will trigger its move children
// (ie: this entity) to call GetAbsOrigin(), and they'll use the moveparent's OLD bone transforms to get their attachments
// since the moveparent is right in the middle of setting up new transforms.
//
// So here, we keep our absorigin invalidated. It means we're returning an origin that is a frame old to CalculateIKLocks,
// but we'll still render with the right origin.
if ( m_iParentAttachment != 0 && (m_pMoveParent->GetEFlags() & EFL_SETTING_UP_BONES) )
{
m_iEFlags |= EFL_DIRTY_ABSTRANSFORM;
}
}
void C_BaseEntity::CalcAbsoluteVelocity()
{
if ((m_iEFlags & EFL_DIRTY_ABSVELOCITY ) == 0)
return;
AUTO_LOCK( m_CalcAbsoluteVelocityMutex );
if ((m_iEFlags & EFL_DIRTY_ABSVELOCITY) == 0) // need second check in event another thread grabbed mutex and did the calculation
{
return;
}
m_iEFlags &= ~EFL_DIRTY_ABSVELOCITY;
CBaseEntity *pMoveParent = GetMoveParent();
if ( !pMoveParent )
{
m_vecAbsVelocity = m_vecVelocity;
return;
}
VectorRotate( m_vecVelocity, pMoveParent->EntityToWorldTransform(), m_vecAbsVelocity );
// Add in the attachments velocity if it exists
if ( m_iParentAttachment != 0 )
{
Vector vOriginVel;
Quaternion vAngleVel;
if ( pMoveParent->GetAttachmentVelocity( m_iParentAttachment, vOriginVel, vAngleVel ) )
{
m_vecAbsVelocity += vOriginVel;
return;
}
}
// Now add in the parent abs velocity
m_vecAbsVelocity += pMoveParent->GetAbsVelocity();
}
/*
void C_BaseEntity::CalcAbsoluteAngularVelocity()
{
if ((m_iEFlags & EFL_DIRTY_ABSANGVELOCITY ) == 0)
return;
m_iEFlags &= ~EFL_DIRTY_ABSANGVELOCITY;
CBaseEntity *pMoveParent = GetMoveParent();
if ( !pMoveParent )
{
m_vecAbsAngVelocity = m_vecAngVelocity;
return;
}
matrix3x4_t angVelToParent, angVelToWorld;
AngleMatrix( m_vecAngVelocity, angVelToParent );
ConcatTransforms( pMoveParent->EntityToWorldTransform(), angVelToParent, angVelToWorld );
MatrixAngles( angVelToWorld, m_vecAbsAngVelocity );
// Now add in the parent abs angular velocity
m_vecAbsAngVelocity += pMoveParent->GetAbsAngularVelocity();
}
*/
//-----------------------------------------------------------------------------
// Computes the abs position of a point specified in local space
//-----------------------------------------------------------------------------
void C_BaseEntity::ComputeAbsPosition( const Vector &vecLocalPosition, Vector *pAbsPosition )
{
C_BaseEntity *pMoveParent = GetMoveParent();
if ( !pMoveParent )
{
*pAbsPosition = vecLocalPosition;
}
else
{
VectorTransform( vecLocalPosition, pMoveParent->EntityToWorldTransform(), *pAbsPosition );
}
}
//-----------------------------------------------------------------------------
// Computes the abs position of a point specified in local space
//-----------------------------------------------------------------------------
void C_BaseEntity::ComputeAbsDirection( const Vector &vecLocalDirection, Vector *pAbsDirection )
{
C_BaseEntity *pMoveParent = GetMoveParent();
if ( !pMoveParent )
{
*pAbsDirection = vecLocalDirection;
}
else
{
VectorRotate( vecLocalDirection, pMoveParent->EntityToWorldTransform(), *pAbsDirection );
}
}
//-----------------------------------------------------------------------------
// Mark shadow as dirty
//-----------------------------------------------------------------------------
void C_BaseEntity::MarkRenderHandleDirty( )
{
// Invalidate render leaf too
ClientRenderHandle_t handle = GetRenderHandle();
if ( handle != INVALID_CLIENT_RENDER_HANDLE )
{
ClientLeafSystem()->RenderableChanged( handle );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::ShutdownPredictable( void )
{
#if !defined( NO_ENTITY_PREDICTION )
Assert( GetPredictable() );
g_Predictables.RemoveFromPredictablesList( GetClientHandle() );
DestroyIntermediateData();
SetPredictable( false );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Turn entity into something the predicts locally
//-----------------------------------------------------------------------------
void C_BaseEntity::InitPredictable( void )
{
#if !defined( NO_ENTITY_PREDICTION )
Assert( !GetPredictable() );
// Mark as predictable
SetPredictable( true );
// Allocate buffers into which we copy data
AllocateIntermediateData();
// Add to list of predictables
g_Predictables.AddToPredictableList( GetClientHandle() );
// Copy everything from "this" into the original_state_data
// object. Don't care about client local stuff, so pull from slot 0 which
// should be empty anyway...
PostNetworkDataReceived( 0 );
// Copy original data into all prediction slots, so we don't get an error saying we "mispredicted" any
// values which are still at their initial values
for ( int i = 0; i < MULTIPLAYER_BACKUP; i++ )
{
SaveData( "InitPredictable", i, PC_EVERYTHING );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : state -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetPredictable( bool state )
{
m_bPredictable = state;
// update interpolation times
Interp_UpdateInterpolationAmounts( GetVarMapping() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseEntity::GetPredictable( void ) const
{
return m_bPredictable;
}
//-----------------------------------------------------------------------------
// Purpose: Transfer data for intermediate frame to current entity
// Input : copyintermediate -
// last_predicted -
//-----------------------------------------------------------------------------
void C_BaseEntity::PreEntityPacketReceived( int commands_acknowledged )
{
#if !defined( NO_ENTITY_PREDICTION )
// Don't need to copy intermediate data if server did ack any new commands
bool copyintermediate = ( commands_acknowledged > 0 ) ? true : false;
Assert( GetPredictable() );
Assert( cl_predict->GetInt() );
// First copy in any intermediate predicted data for non-networked fields
if ( copyintermediate )
{
RestoreData( "PreEntityPacketReceived", commands_acknowledged - 1, PC_NON_NETWORKED_ONLY );
RestoreData( "PreEntityPacketReceived", SLOT_ORIGINALDATA, PC_NETWORKED_ONLY );
}
else
{
RestoreData( "PreEntityPacketReceived(no commands ack)", SLOT_ORIGINALDATA, PC_EVERYTHING );
}
// At this point the entity has original network data restored as of the last time the
// networking was updated, and it has any intermediate predicted values properly copied over
// Unpacked and OnDataChanged will fill in any changed, networked fields.
// That networked data will be copied forward into the starting slot for the next prediction round
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Called every time PreEntityPacket received is called
// copy any networked data into original_state
// Input : errorcheck -
// last_predicted -
//-----------------------------------------------------------------------------
void C_BaseEntity::PostEntityPacketReceived( void )
{
#if !defined( NO_ENTITY_PREDICTION )
Assert( GetPredictable() );
Assert( cl_predict->GetInt() );
// Always mark as changed
AddDataChangeEvent( this, DATA_UPDATE_DATATABLE_CHANGED, &m_DataChangeEventRef );
// Save networked fields into "original data" store
SaveData( "PostEntityPacketReceived", SLOT_ORIGINALDATA, PC_NETWORKED_ONLY );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Called once per frame after all updating is done
// Input : errorcheck -
// last_predicted -
//-----------------------------------------------------------------------------
bool C_BaseEntity::PostNetworkDataReceived( int commands_acknowledged )
{
bool haderrors = false;
#if !defined( NO_ENTITY_PREDICTION )
Assert( GetPredictable() );
bool errorcheck = ( commands_acknowledged > 0 ) ? true : false;
// Store network data into post networking pristine state slot (slot 64)
SaveData( "PostNetworkDataReceived", SLOT_ORIGINALDATA, PC_EVERYTHING );
// Show any networked fields that are different
bool showthis = cl_showerror.GetInt() >= 2;
if ( cl_showerror.GetInt() < 0 )
{
if ( entindex() == -cl_showerror.GetInt() )
{
showthis = true;
}
else
{
showthis = false;
}
}
if ( errorcheck )
{
void *predicted_state_data = GetPredictedFrame( commands_acknowledged - 1 );
Assert( predicted_state_data );
const void *original_state_data = GetOriginalNetworkDataObject();
Assert( original_state_data );
bool counterrors = true;
bool reporterrors = showthis;
bool copydata = false;
CPredictionCopy errorCheckHelper( PC_NETWORKED_ONLY,
predicted_state_data, PC_DATA_PACKED,
original_state_data, PC_DATA_PACKED,
counterrors, reporterrors, copydata );
// Suppress debugging output
int ecount = errorCheckHelper.TransferData( "", -1, GetPredDescMap() );
if ( ecount > 0 )
{
haderrors = true;
// Msg( "%i errors %i on entity %i %s\n", gpGlobals->tickcount, ecount, index, IsClientCreated() ? "true" : "false" );
}
}
#endif
return haderrors;
}
// Stuff implemented for weapon prediction code
void C_BaseEntity::SetSize( const Vector &vecMin, const Vector &vecMax )
{
SetCollisionBounds( vecMin, vecMax );
}
//-----------------------------------------------------------------------------
// Purpose: Just look up index
// Input : *name -
// Output : int
//-----------------------------------------------------------------------------
int C_BaseEntity::PrecacheModel( const char *name )
{
return modelinfo->GetModelIndex( name );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *obj -
//-----------------------------------------------------------------------------
void C_BaseEntity::Remove( )
{
// Nothing for now, if it's a predicted entity, could flag as "delete" or dormant
if ( GetPredictable() || IsClientCreated() )
{
// Make it solid
AddSolidFlags( FSOLID_NOT_SOLID );
SetMoveType( MOVETYPE_NONE );
AddEFlags( EFL_KILLME ); // Make sure to ignore further calls into here or UTIL_Remove.
}
Release();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseEntity::GetPredictionEligible( void ) const
{
#if !defined( NO_ENTITY_PREDICTION )
return m_bPredictionEligible;
#else
return false;
#endif
}
C_BaseEntity* C_BaseEntity::Instance( CBaseHandle hEnt )
{
return ClientEntityList().GetBaseEntityFromHandle( hEnt );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : iEnt -
// Output : C_BaseEntity
//-----------------------------------------------------------------------------
C_BaseEntity *C_BaseEntity::Instance( int iEnt )
{
return ClientEntityList().GetBaseEntity( iEnt );
}
#ifdef WIN32
#pragma warning( push )
#include <typeinfo>
#pragma warning( pop )
#endif
//-----------------------------------------------------------------------------
// Purpose:
// Output : char const
//-----------------------------------------------------------------------------
const char *C_BaseEntity::GetClassname( void )
{
static char outstr[ 256 ];
outstr[ 0 ] = 0;
bool gotname = false;
#ifndef NO_ENTITY_PREDICTION
if ( GetPredDescMap() )
{
const char *mapname = GetClassMap().Lookup( GetPredDescMap()->dataClassName );
if ( mapname && mapname[ 0 ] )
{
Q_strncpy( outstr, mapname, sizeof( outstr ) );
gotname = true;
}
}
#endif
if ( !gotname )
{
Q_strncpy( outstr, typeid( *this ).name(), sizeof( outstr ) );
}
return outstr;
}
const char *C_BaseEntity::GetDebugName( void )
{
return GetClassname();
}
//-----------------------------------------------------------------------------
// Purpose: Creates an entity by string name, but does not spawn it
// Input : *className -
// Output : C_BaseEntity
//-----------------------------------------------------------------------------
C_BaseEntity *CreateEntityByName( const char *className )
{
C_BaseEntity *ent = GetClassMap().CreateEntity( className );
if ( ent )
{
return ent;
}
Warning( "Can't find factory for entity: %s\n", className );
return NULL;
}
#ifdef _DEBUG
CON_COMMAND( cl_sizeof, "Determines the size of the specified client class." )
{
if ( args.ArgC() != 2 )
{
Msg( "cl_sizeof <gameclassname>\n" );
return;
}
int size = GetClassMap().GetClassSize( args[ 1 ] );
Msg( "%s is %i bytes\n", args[ 1 ], size );
}
#endif
CON_COMMAND_F( dlight_debug, "Creates a dlight in front of the player", FCVAR_CHEAT )
{
dlight_t *el = effects->CL_AllocDlight( 1 );
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
if ( !player )
return;
Vector start = player->EyePosition();
Vector forward;
player->EyeVectors( &forward );
Vector end = start + forward * MAX_TRACE_LENGTH;
trace_t tr;
UTIL_TraceLine( start, end, MASK_SHOT_HULL & (~CONTENTS_GRATE), player, COLLISION_GROUP_NONE, &tr );
el->origin = tr.endpos - forward * 12.0f;
el->radius = 200;
el->decay = el->radius / 5.0f;
el->die = gpGlobals->curtime + 5.0f;
el->color.r = 255;
el->color.g = 192;
el->color.b = 64;
el->color.exponent = 5;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseEntity::IsClientCreated( void ) const
{
#ifndef NO_ENTITY_PREDICTION
if ( m_pPredictionContext != NULL )
{
// For now can't be both
Assert( !GetPredictable() );
return true;
}
#endif
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *classname -
// *module -
// line -
// Output : C_BaseEntity
//-----------------------------------------------------------------------------
C_BaseEntity *C_BaseEntity::CreatePredictedEntityByName( const char *classname, const char *module, int line, bool persist /*= false */ )
{
#if !defined( NO_ENTITY_PREDICTION )
C_BasePlayer *player = C_BaseEntity::GetPredictionPlayer();
Assert( player );
Assert( player->m_pCurrentCommand );
Assert( prediction->InPrediction() );
C_BaseEntity *ent = NULL;
// What's my birthday (should match server)
int command_number = player->m_pCurrentCommand->command_number;
// Who's my daddy?
int player_index = player->entindex() - 1;
// Create id/context
CPredictableId testId;
testId.Init( player_index, command_number, classname, module, line );
// If repredicting, should be able to find the entity in the previously created list
if ( !prediction->IsFirstTimePredicted() )
{
// Only find previous instance if entity was created with persist set
if ( persist )
{
ent = FindPreviouslyCreatedEntity( testId );
if ( ent )
{
return ent;
}
}
return NULL;
}
// Try to create it
ent = CreateEntityByName( classname );
if ( !ent )
{
return NULL;
}
// It's predictable
ent->SetPredictionEligible( true );
// Set up "shared" id number
ent->m_PredictableID.SetRaw( testId.GetRaw() );
// Get a context (mostly for debugging purposes)
PredictionContext *context = new PredictionContext;
context->m_bActive = true;
context->m_nCreationCommandNumber = command_number;
context->m_nCreationLineNumber = line;
context->m_pszCreationModule = module;
// Attach to entity
ent->m_pPredictionContext = context;
// Add to client entity list
ClientEntityList().AddNonNetworkableEntity( ent );
// and predictables
g_Predictables.AddToPredictableList( ent->GetClientHandle() );
// Duhhhh..., but might as well be safe
Assert( !ent->GetPredictable() );
Assert( ent->IsClientCreated() );
// Add the client entity to the spatial partition. (Collidable)
ent->CollisionProp()->CreatePartitionHandle();
// CLIENT ONLY FOR NOW!!!
ent->index = -1;
if ( AddDataChangeEvent( ent, DATA_UPDATE_CREATED, &ent->m_DataChangeEventRef ) )
{
ent->OnPreDataChanged( DATA_UPDATE_CREATED );
}
ent->Interp_UpdateInterpolationAmounts( ent->GetVarMapping() );
return ent;
#else
return NULL;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Called each packet that the entity is created on and finally gets called after the next packet
// that doesn't have a create message for the "parent" entity so that the predicted version
// can be removed. Return true to delete entity right away.
//-----------------------------------------------------------------------------
bool C_BaseEntity::OnPredictedEntityRemove( bool isbeingremoved, C_BaseEntity *predicted )
{
#if !defined( NO_ENTITY_PREDICTION )
// Nothing right now, but in theory you could look at the error in origins and set
// up something to smooth out the error
PredictionContext *ctx = predicted->m_pPredictionContext;
Assert( ctx );
if ( ctx )
{
// Create backlink to actual entity
ctx->m_hServerEntity = this;
/*
Msg( "OnPredictedEntity%s: %s created %s(%i) instance(%i)\n",
isbeingremoved ? "Remove" : "Acknowledge",
predicted->GetClassname(),
ctx->m_pszCreationModule,
ctx->m_nCreationLineNumber,
predicted->m_PredictableID.GetInstanceNumber() );
*/
}
// If it comes through with an ID, it should be eligible
SetPredictionEligible( true );
// Start predicting simulation forward from here
CheckInitPredictable( "OnPredictedEntityRemove" );
// Always mark it dormant since we are the "real" entity now
predicted->SetDormantPredictable( true );
InvalidatePhysicsRecursive( POSITION_CHANGED | ANGLES_CHANGED | VELOCITY_CHANGED );
// By default, signal that it should be deleted right away
// If a derived class implements this method, it might chain to here but return
// false if it wants to keep the dormant predictable around until the chain of
// DATA_UPDATE_CREATED messages passes
#endif
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pOwner -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetOwnerEntity( C_BaseEntity *pOwner )
{
m_hOwnerEntity = pOwner;
}
//-----------------------------------------------------------------------------
// Purpose: Put the entity in the specified team
//-----------------------------------------------------------------------------
void C_BaseEntity::ChangeTeam( int iTeamNum )
{
m_iTeamNum = iTeamNum;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : name -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetModelName( string_t name )
{
m_ModelName = name;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : string_t
//-----------------------------------------------------------------------------
string_t C_BaseEntity::GetModelName( void ) const
{
return m_ModelName;
}
//-----------------------------------------------------------------------------
// Purpose: Nothing yet, could eventually supercede Term()
//-----------------------------------------------------------------------------
void C_BaseEntity::UpdateOnRemove( void )
{
VPhysicsDestroyObject();
Assert( !GetMoveParent() );
UnlinkFromHierarchy();
SetGroundEntity( NULL );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : canpredict -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetPredictionEligible( bool canpredict )
{
#if !defined( NO_ENTITY_PREDICTION )
m_bPredictionEligible = canpredict;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Returns a value that scales all damage done by this entity.
//-----------------------------------------------------------------------------
float C_BaseEntity::GetAttackDamageScale( void )
{
float flScale = 1;
// Not hooked up to prediction yet
#if 0
FOR_EACH_LL( m_DamageModifiers, i )
{
if ( !m_DamageModifiers[i]->IsDamageDoneToMe() )
{
flScale *= m_DamageModifiers[i]->GetModifier();
}
}
#endif
return flScale;
}
#if !defined( NO_ENTITY_PREDICTION )
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseEntity::IsDormantPredictable( void ) const
{
return m_bDormantPredictable;
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
// Input : dormant -
//-----------------------------------------------------------------------------
void C_BaseEntity::SetDormantPredictable( bool dormant )
{
#if !defined( NO_ENTITY_PREDICTION )
Assert( IsClientCreated() );
m_bDormantPredictable = true;
m_nIncomingPacketEntityBecameDormant = prediction->GetIncomingPacketNumber();
// Do we need to do the following kinds of things?
#if 0
// Remove from collisions
SetSolid( SOLID_NOT );
// Don't render
AddEffects( EF_NODRAW );
#endif
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Used to determine when a dorman client predictable can be safely deleted
// Note that it can be deleted earlier than this by OnPredictedEntityRemove returning true
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseEntity::BecameDormantThisPacket( void ) const
{
#if !defined( NO_ENTITY_PREDICTION )
Assert( IsDormantPredictable() );
if ( m_nIncomingPacketEntityBecameDormant != prediction->GetIncomingPacketNumber() )
return false;
return true;
#else
return false;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseEntity::IsIntermediateDataAllocated( void ) const
{
#if !defined( NO_ENTITY_PREDICTION )
return m_pOriginalData != NULL ? true : false;
#else
return false;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::AllocateIntermediateData( void )
{
#if !defined( NO_ENTITY_PREDICTION )
if ( m_pOriginalData )
return;
size_t allocsize = GetIntermediateDataSize();
Assert( allocsize > 0 );
m_pOriginalData = new unsigned char[ allocsize ];
Q_memset( m_pOriginalData, 0, allocsize );
for ( int i = 0; i < MULTIPLAYER_BACKUP; i++ )
{
m_pIntermediateData[ i ] = new unsigned char[ allocsize ];
Q_memset( m_pIntermediateData[ i ], 0, allocsize );
}
m_nIntermediateDataCount = 0;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::DestroyIntermediateData( void )
{
#if !defined( NO_ENTITY_PREDICTION )
if ( !m_pOriginalData )
return;
for ( int i = 0; i < MULTIPLAYER_BACKUP; i++ )
{
delete[] m_pIntermediateData[ i ];
m_pIntermediateData[ i ] = NULL;
}
delete[] m_pOriginalData;
m_pOriginalData = NULL;
m_nIntermediateDataCount = 0;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : slots_to_remove -
// number_of_commands_run -
//-----------------------------------------------------------------------------
void C_BaseEntity::ShiftIntermediateDataForward( int slots_to_remove, int number_of_commands_run )
{
#if !defined( NO_ENTITY_PREDICTION )
Assert( m_pIntermediateData );
if ( !m_pIntermediateData )
return;
Assert( number_of_commands_run >= slots_to_remove );
// Just moving pointers, yeah
CUtlVector< unsigned char * > saved;
// Remember first slots
int i = 0;
for ( ; i < slots_to_remove; i++ )
{
saved.AddToTail( m_pIntermediateData[ i ] );
}
// Move rest of slots forward up to last slot
for ( ; i < number_of_commands_run; i++ )
{
m_pIntermediateData[ i - slots_to_remove ] = m_pIntermediateData[ i ];
}
// Put remembered slots onto end
for ( i = 0; i < slots_to_remove; i++ )
{
int slot = number_of_commands_run - slots_to_remove + i;
m_pIntermediateData[ slot ] = saved[ i ];
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : framenumber -
//-----------------------------------------------------------------------------
void *C_BaseEntity::GetPredictedFrame( int framenumber )
{
#if !defined( NO_ENTITY_PREDICTION )
Assert( framenumber >= 0 );
if ( !m_pOriginalData )
{
Assert( 0 );
return NULL;
}
return (void *)m_pIntermediateData[ framenumber % MULTIPLAYER_BACKUP ];
#else
return NULL;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void *C_BaseEntity::GetOriginalNetworkDataObject( void )
{
#if !defined( NO_ENTITY_PREDICTION )
if ( !m_pOriginalData )
{
Assert( 0 );
return NULL;
}
return (void *)m_pOriginalData;
#else
return NULL;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::ComputePackedOffsets( void )
{
#if !defined( NO_ENTITY_PREDICTION )
datamap_t *map = GetPredDescMap();
if ( !map )
return;
if ( map->packed_offsets_computed )
return;
ComputePackedSize_R( map );
Assert( map->packed_offsets_computed );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int C_BaseEntity::GetIntermediateDataSize( void )
{
#if !defined( NO_ENTITY_PREDICTION )
ComputePackedOffsets();
const datamap_t *map = GetPredDescMap();
Assert( map->packed_offsets_computed );
int size = map->packed_size;
Assert( size > 0 );
// At least 4 bytes to avoid some really bad stuff
return MAX( size, 4 );
#else
return 0;
#endif
}
static int g_FieldSizes[FIELD_TYPECOUNT] =
{
0, // FIELD_VOID
sizeof(float), // FIELD_FLOAT
sizeof(int), // FIELD_STRING
sizeof(Vector), // FIELD_VECTOR
sizeof(Quaternion), // FIELD_QUATERNION
sizeof(int), // FIELD_INTEGER
sizeof(char), // FIELD_BOOLEAN
sizeof(short), // FIELD_SHORT
sizeof(char), // FIELD_CHARACTER
sizeof(color32), // FIELD_COLOR32
sizeof(int), // FIELD_EMBEDDED (handled specially)
sizeof(int), // FIELD_CUSTOM (handled specially)
//---------------------------------
sizeof(int), // FIELD_CLASSPTR
sizeof(EHANDLE), // FIELD_EHANDLE
sizeof(int), // FIELD_EDICT
sizeof(Vector), // FIELD_POSITION_VECTOR
sizeof(float), // FIELD_TIME
sizeof(int), // FIELD_TICK
sizeof(int), // FIELD_MODELNAME
sizeof(int), // FIELD_SOUNDNAME
sizeof(int), // FIELD_INPUT (uses custom type)
#ifdef GNUC
// pointer to members under gnuc are 8bytes if you have a virtual func
sizeof(uint64), // FIELD_FUNCTION
#else
sizeof(int *), // FIELD_FUNCTION
#endif
sizeof(VMatrix), // FIELD_VMATRIX
sizeof(VMatrix), // FIELD_VMATRIX_WORLDSPACE
sizeof(matrix3x4_t),// FIELD_MATRIX3X4_WORLDSPACE // NOTE: Use array(FIELD_FLOAT, 12) for matrix3x4_t NOT in worldspace
sizeof(interval_t), // FIELD_INTERVAL
sizeof(int), // FIELD_MODELINDEX
};
//-----------------------------------------------------------------------------
// Purpose:
// Input : *map -
// Output : int
//-----------------------------------------------------------------------------
int C_BaseEntity::ComputePackedSize_R( datamap_t *map )
{
if ( !map )
{
Assert( 0 );
return 0;
}
// Already computed
if ( map->packed_offsets_computed )
{
return map->packed_size;
}
int current_position = 0;
// Recurse to base classes first...
if ( map->baseMap )
{
current_position += ComputePackedSize_R( map->baseMap );
}
int c = map->dataNumFields;
int i;
typedescription_t *field;
for ( i = 0; i < c; i++ )
{
field = &map->dataDesc[ i ];
// Always descend into embedded types...
if ( field->fieldType != FIELD_EMBEDDED )
{
// Skip all private fields
if ( field->flags & FTYPEDESC_PRIVATE )
continue;
}
switch ( field->fieldType )
{
default:
case FIELD_MODELINDEX:
case FIELD_MODELNAME:
case FIELD_SOUNDNAME:
case FIELD_TIME:
case FIELD_TICK:
case FIELD_CUSTOM:
case FIELD_CLASSPTR:
case FIELD_EDICT:
case FIELD_POSITION_VECTOR:
case FIELD_FUNCTION:
Assert( 0 );
break;
case FIELD_EMBEDDED:
{
Assert( field->td != NULL );
int embeddedsize = ComputePackedSize_R( field->td );
field->fieldOffset[ TD_OFFSET_PACKED ] = current_position;
current_position += embeddedsize;
}
break;
case FIELD_FLOAT:
case FIELD_VECTOR:
case FIELD_QUATERNION:
case FIELD_INTEGER:
case FIELD_EHANDLE:
{
// These should be dword aligned
current_position = (current_position + 3) & ~3;
field->fieldOffset[ TD_OFFSET_PACKED ] = current_position;
Assert( field->fieldSize >= 1 );
current_position += g_FieldSizes[ field->fieldType ] * field->fieldSize;
}
break;
case FIELD_SHORT:
{
// This should be word aligned
current_position = (current_position + 1) & ~1;
field->fieldOffset[ TD_OFFSET_PACKED ] = current_position;
Assert( field->fieldSize >= 1 );
current_position += g_FieldSizes[ field->fieldType ] * field->fieldSize;
}
break;
case FIELD_STRING:
case FIELD_COLOR32:
case FIELD_BOOLEAN:
case FIELD_CHARACTER:
{
field->fieldOffset[ TD_OFFSET_PACKED ] = current_position;
Assert( field->fieldSize >= 1 );
current_position += g_FieldSizes[ field->fieldType ] * field->fieldSize;
}
break;
case FIELD_VOID:
{
// Special case, just skip it
}
break;
}
}
map->packed_size = current_position;
map->packed_offsets_computed = true;
return current_position;
}
// Convenient way to delay removing oneself
void C_BaseEntity::SUB_Remove( void )
{
if (m_iHealth > 0)
{
// this situation can screw up NPCs who can't tell their entity pointers are invalid.
m_iHealth = 0;
DevWarning( 2, "SUB_Remove called on entity with health > 0\n");
}
Remove( );
}
CBaseEntity *FindEntityInFrontOfLocalPlayer()
{
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( pPlayer )
{
// Get the entity under my crosshair
trace_t tr;
Vector forward;
pPlayer->EyeVectors( &forward );
UTIL_TraceLine( pPlayer->EyePosition(), pPlayer->EyePosition() + forward * MAX_COORD_RANGE, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 && tr.DidHitNonWorldEntity() )
{
return tr.m_pEnt;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Debug command to wipe the decals off an entity
//-----------------------------------------------------------------------------
static void RemoveDecals_f( void )
{
CBaseEntity *pHit = FindEntityInFrontOfLocalPlayer();
if ( pHit )
{
pHit->RemoveAllDecals();
}
}
static ConCommand cl_removedecals( "cl_removedecals", RemoveDecals_f, "Remove the decals from the entity under the crosshair.", FCVAR_CHEAT );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::ToggleBBoxVisualization( int fVisFlags )
{
if ( m_fBBoxVisFlags & fVisFlags )
{
m_fBBoxVisFlags &= ~fVisFlags;
}
else
{
m_fBBoxVisFlags |= fVisFlags;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static void ToggleBBoxVisualization( int fVisFlags, const CCommand &args )
{
CBaseEntity *pHit;
int iEntity = -1;
if ( args.ArgC() >= 2 )
{
iEntity = atoi( args[ 1 ] );
}
if ( iEntity == -1 )
{
pHit = FindEntityInFrontOfLocalPlayer();
}
else
{
pHit = cl_entitylist->GetBaseEntity( iEntity );
}
if ( pHit )
{
pHit->ToggleBBoxVisualization( fVisFlags );
}
}
//-----------------------------------------------------------------------------
// Purpose: Command to toggle visualizations of bboxes on the client
//-----------------------------------------------------------------------------
CON_COMMAND_F( cl_ent_bbox, "Displays the client's bounding box for the entity under the crosshair.", FCVAR_CHEAT )
{
ToggleBBoxVisualization( CBaseEntity::VISUALIZE_COLLISION_BOUNDS, args );
}
//-----------------------------------------------------------------------------
// Purpose: Command to toggle visualizations of bboxes on the client
//-----------------------------------------------------------------------------
CON_COMMAND_F( cl_ent_absbox, "Displays the client's absbox for the entity under the crosshair.", FCVAR_CHEAT )
{
ToggleBBoxVisualization( CBaseEntity::VISUALIZE_SURROUNDING_BOUNDS, args );
}
//-----------------------------------------------------------------------------
// Purpose: Command to toggle visualizations of bboxes on the client
//-----------------------------------------------------------------------------
CON_COMMAND_F( cl_ent_rbox, "Displays the client's render box for the entity under the crosshair.", FCVAR_CHEAT )
{
ToggleBBoxVisualization( CBaseEntity::VISUALIZE_RENDER_BOUNDS, args );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseEntity::DrawBBoxVisualizations( void )
{
if ( m_fBBoxVisFlags & VISUALIZE_COLLISION_BOUNDS )
{
if ( debugoverlay )
{
debugoverlay->AddBoxOverlay( CollisionProp()->GetCollisionOrigin(), CollisionProp()->OBBMins(),
CollisionProp()->OBBMaxs(), CollisionProp()->GetCollisionAngles(), 190, 190, 0, 0, 0.01 );
}
}
if ( m_fBBoxVisFlags & VISUALIZE_SURROUNDING_BOUNDS )
{
Vector vecSurroundMins, vecSurroundMaxs;
CollisionProp()->WorldSpaceSurroundingBounds( &vecSurroundMins, &vecSurroundMaxs );
if ( debugoverlay )
{
debugoverlay->AddBoxOverlay( vec3_origin, vecSurroundMins,
vecSurroundMaxs, vec3_angle, 0, 255, 255, 0, 0.01 );
}
}
if ( m_fBBoxVisFlags & VISUALIZE_RENDER_BOUNDS || r_drawrenderboxes.GetInt() )
{
Vector vecRenderMins, vecRenderMaxs;
GetRenderBounds( vecRenderMins, vecRenderMaxs );
debugoverlay->AddBoxOverlay( GetRenderOrigin(), vecRenderMins, vecRenderMaxs,
GetRenderAngles(), 255, 0, 255, 0, 0.01 );
}
}
//-----------------------------------------------------------------------------
// Sets the render mode
//-----------------------------------------------------------------------------
void C_BaseEntity::SetRenderMode( RenderMode_t nRenderMode, bool bForceUpdate )
{
m_nRenderMode = nRenderMode;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : RenderGroup_t
//-----------------------------------------------------------------------------
RenderGroup_t C_BaseEntity::GetRenderGroup()
{
// Don't sort things that don't need rendering
if ( m_nRenderMode == kRenderNone )
return RENDER_GROUP_OPAQUE_ENTITY;
// NOTE: Bypassing the GetFXBlend protection logic because we want this to
// be able to be called from AddToLeafSystem.
int nTempComputeFrame = m_nFXComputeFrame;
m_nFXComputeFrame = gpGlobals->framecount;
int nFXBlend = GetFxBlend();
m_nFXComputeFrame = nTempComputeFrame;
// Don't need to sort invisible stuff
if ( nFXBlend == 0 )
return RENDER_GROUP_OPAQUE_ENTITY;
// Figure out its RenderGroup.
int modelType = modelinfo->GetModelType( model );
RenderGroup_t renderGroup = (modelType == mod_brush) ? RENDER_GROUP_OPAQUE_BRUSH : RENDER_GROUP_OPAQUE_ENTITY;
if ( ( nFXBlend != 255 ) || IsTransparent() )
{
if ( m_nRenderMode != kRenderEnvironmental )
{
renderGroup = RENDER_GROUP_TRANSLUCENT_ENTITY;
}
else
{
renderGroup = RENDER_GROUP_OTHER;
}
}
if ( ( renderGroup == RENDER_GROUP_TRANSLUCENT_ENTITY ) &&
( modelinfo->IsTranslucentTwoPass( model ) ) )
{
renderGroup = RENDER_GROUP_TWOPASS;
}
return renderGroup;
}
//-----------------------------------------------------------------------------
// Purpose: Copy from this entity into one of the save slots (original or intermediate)
// Input : slot -
// type -
// false -
// false -
// true -
// false -
// NULL -
// Output : int
//-----------------------------------------------------------------------------
int C_BaseEntity::SaveData( const char *context, int slot, int type )
{
#if !defined( NO_ENTITY_PREDICTION )
VPROF( "C_BaseEntity::SaveData" );
void *dest = ( slot == SLOT_ORIGINALDATA ) ? GetOriginalNetworkDataObject() : GetPredictedFrame( slot );
Assert( dest );
char sz[ 64 ];
sz[0] = 0;
// don't build debug strings per entity per frame, unless we are watching the entity
static ConVarRef pwatchent( "pwatchent" );
if ( pwatchent.GetInt() == entindex() )
{
if ( slot == SLOT_ORIGINALDATA )
{
Q_snprintf( sz, sizeof( sz ), "%s SaveData(original)", context );
}
else
{
Q_snprintf( sz, sizeof( sz ), "%s SaveData(slot %02i)", context, slot );
}
}
if ( slot != SLOT_ORIGINALDATA )
{
// Remember high water mark so that we can detect below if we are reading from a slot not yet predicted into...
m_nIntermediateDataCount = slot;
}
CPredictionCopy copyHelper( type, dest, PC_DATA_PACKED, this, PC_DATA_NORMAL );
int error_count = copyHelper.TransferData( sz, entindex(), GetPredDescMap() );
return error_count;
#else
return 0;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Restore data from specified slot into current entity
// Input : slot -
// type -
// false -
// false -
// true -
// false -
// NULL -
// Output : int
//-----------------------------------------------------------------------------
int C_BaseEntity::RestoreData( const char *context, int slot, int type )
{
#if !defined( NO_ENTITY_PREDICTION )
VPROF( "C_BaseEntity::RestoreData" );
const void *src = ( slot == SLOT_ORIGINALDATA ) ? GetOriginalNetworkDataObject() : GetPredictedFrame( slot );
Assert( src );
// This assert will fire if the server ack'd a CUserCmd which we hadn't predicted yet...
// In that case, we'd be comparing "old" data from this "unused" slot with the networked data and reporting all kinds of prediction errors possibly.
Assert( slot == SLOT_ORIGINALDATA || slot <= m_nIntermediateDataCount );
char sz[ 64 ];
sz[0] = 0;
// don't build debug strings per entity per frame, unless we are watching the entity
static ConVarRef pwatchent( "pwatchent" );
if ( pwatchent.GetInt() == entindex() )
{
if ( slot == SLOT_ORIGINALDATA )
{
Q_snprintf( sz, sizeof( sz ), "%s RestoreData(original)", context );
}
else
{
Q_snprintf( sz, sizeof( sz ), "%s RestoreData(slot %02i)", context, slot );
}
}
// some flags shouldn't be predicted - as we find them, add them to the savedEFlagsMask
const int savedEFlagsMask = EFL_DIRTY_SHADOWUPDATE;
int savedEFlags = GetEFlags() & savedEFlagsMask;
// model index needs to be set manually for dynamic model refcounting purposes
int oldModelIndex = m_nModelIndex;
CPredictionCopy copyHelper( type, this, PC_DATA_NORMAL, src, PC_DATA_PACKED );
int error_count = copyHelper.TransferData( sz, entindex(), GetPredDescMap() );
// set non-predicting flags back to their prior state
RemoveEFlags( savedEFlagsMask );
AddEFlags( savedEFlags );
// restore original model index and change via SetModelIndex
int newModelIndex = m_nModelIndex;
m_nModelIndex = oldModelIndex;
int overrideModelIndex = CalcOverrideModelIndex();
if( overrideModelIndex != -1 )
newModelIndex = overrideModelIndex;
if ( oldModelIndex != newModelIndex )
{
MDLCACHE_CRITICAL_SECTION(); // ???
SetModelIndex( newModelIndex );
}
OnPostRestoreData();
return error_count;
#else
return 0;
#endif
}
void C_BaseEntity::OnPostRestoreData()
{
// HACK Force recomputation of origin
InvalidatePhysicsRecursive( POSITION_CHANGED | ANGLES_CHANGED | VELOCITY_CHANGED );
if ( GetMoveParent() )
{
AddToAimEntsList();
}
// If our model index has changed, then make sure it's reflected in our model pointer.
// (Mostly superseded by new modelindex delta check in RestoreData, but I'm leaving it
// because it might be band-aiding any other missed calls to SetModelByIndex --henryg)
if ( GetModel() != modelinfo->GetModel( GetModelIndex() ) )
{
MDLCACHE_CRITICAL_SECTION();
SetModelByIndex( GetModelIndex() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Determine approximate velocity based on updates from server
// Input : vel -
//-----------------------------------------------------------------------------
void C_BaseEntity::EstimateAbsVelocity( Vector& vel )
{
if ( this == C_BasePlayer::GetLocalPlayer() )
{
// This is interpolated and networked
vel = GetAbsVelocity();
return;
}
CInterpolationContext context;
context.EnableExtrapolation( true );
m_iv_vecOrigin.GetDerivative_SmoothVelocity( &vel, gpGlobals->curtime );
}
void C_BaseEntity::Interp_Reset( VarMapping_t *map )
{
PREDICTION_TRACKVALUECHANGESCOPE_ENTITY( this, "reset" );
int c = map->m_Entries.Count();
for ( int i = 0; i < c; i++ )
{
VarMapEntry_t *e = &map->m_Entries[ i ];
IInterpolatedVar *watcher = e->watcher;
watcher->Reset();
}
}
void C_BaseEntity::ResetLatched()
{
if ( IsClientCreated() )
return;
Interp_Reset( GetVarMapping() );
}
//-----------------------------------------------------------------------------
// Purpose: Fixme, this needs a better solution
// Input : flags -
// Output : float
//-----------------------------------------------------------------------------
static float AdjustInterpolationAmount( C_BaseEntity *pEntity, float baseInterpolation )
{
if ( cl_interp_npcs.GetFloat() > 0 )
{
const float minNPCInterpolationTime = cl_interp_npcs.GetFloat();
const float minNPCInterpolation = TICK_INTERVAL * ( TIME_TO_TICKS( minNPCInterpolationTime ) + 1 );
if ( minNPCInterpolation > baseInterpolation )
{
while ( pEntity )
{
if ( pEntity->IsNPC() )
return minNPCInterpolation;
pEntity = pEntity->GetMoveParent();
}
}
}
return baseInterpolation;
}
//-------------------------------------
float C_BaseEntity::GetInterpolationAmount( int flags )
{
// If single player server is "skipping ticks" everything needs to interpolate for a bit longer
int serverTickMultiple = 1;
if ( IsSimulatingOnAlternateTicks() )
{
serverTickMultiple = 2;
}
if ( GetPredictable() || IsClientCreated() )
{
return TICK_INTERVAL * serverTickMultiple;
}
// Always fully interpolate during multi-player or during demo playback, if the recorded
// demo was recorded locally.
const bool bPlayingDemo = engine->IsPlayingDemo();
const bool bPlayingMultiplayer = !bPlayingDemo && ( gpGlobals->maxClients > 1 );
const bool bPlayingNonLocallyRecordedDemo = bPlayingDemo && !engine->IsPlayingDemoALocallyRecordedDemo();
if ( bPlayingMultiplayer || bPlayingNonLocallyRecordedDemo )
{
return AdjustInterpolationAmount( this, TICKS_TO_TIME( TIME_TO_TICKS( GetClientInterpAmount() ) + serverTickMultiple ) );
}
int expandedServerTickMultiple = serverTickMultiple;
if ( IsEngineThreaded() )
{
expandedServerTickMultiple += g_nThreadModeTicks;
}
if ( IsAnimatedEveryTick() && IsSimulatedEveryTick() )
{
return TICK_INTERVAL * expandedServerTickMultiple;
}
if ( ( flags & LATCH_ANIMATION_VAR ) && IsAnimatedEveryTick() )
{
return TICK_INTERVAL * expandedServerTickMultiple;
}
if ( ( flags & LATCH_SIMULATION_VAR ) && IsSimulatedEveryTick() )
{
return TICK_INTERVAL * expandedServerTickMultiple;
}
return AdjustInterpolationAmount( this, TICKS_TO_TIME( TIME_TO_TICKS( GetClientInterpAmount() ) + serverTickMultiple ) );
}
float C_BaseEntity::GetLastChangeTime( int flags )
{
if ( GetPredictable() || IsClientCreated() )
{
return gpGlobals->curtime;
}
// make sure not both flags are set, we can't resolve that
Assert( !( (flags & LATCH_ANIMATION_VAR) && (flags & LATCH_SIMULATION_VAR) ) );
if ( flags & LATCH_ANIMATION_VAR )
{
return GetAnimTime();
}
if ( flags & LATCH_SIMULATION_VAR )
{
float st = GetSimulationTime();
if ( st == 0.0f )
{
return gpGlobals->curtime;
}
return st;
}
Assert( 0 );
return gpGlobals->curtime;
}
const Vector& C_BaseEntity::GetPrevLocalOrigin() const
{
return m_iv_vecOrigin.GetPrev();
}
const QAngle& C_BaseEntity::GetPrevLocalAngles() const
{
return m_iv_angRotation.GetPrev();
}
//-----------------------------------------------------------------------------
// Simply here for game shared
//-----------------------------------------------------------------------------
bool C_BaseEntity::IsFloating()
{
// NOTE: This is only here because it's called by game shared.
// The server uses it to lower falling impact damage
return false;
}
BEGIN_DATADESC_NO_BASE( C_BaseEntity )
DEFINE_FIELD( m_ModelName, FIELD_STRING ),
DEFINE_FIELD( m_vecAbsOrigin, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_angAbsRotation, FIELD_VECTOR ),
DEFINE_ARRAY( m_rgflCoordinateFrame, FIELD_FLOAT, 12 ), // NOTE: MUST BE IN LOCAL SPACE, NOT POSITION_VECTOR!!! (see CBaseEntity::Restore)
DEFINE_FIELD( m_fFlags, FIELD_INTEGER ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool C_BaseEntity::ShouldSavePhysics()
{
return false;
}
//-----------------------------------------------------------------------------
// handler to do stuff before you are saved
//-----------------------------------------------------------------------------
void C_BaseEntity::OnSave()
{
// Here, we must force recomputation of all abs data so it gets saved correctly
// We can't leave the dirty bits set because the loader can't cope with it.
CalcAbsolutePosition();
CalcAbsoluteVelocity();
}
//-----------------------------------------------------------------------------
// handler to do stuff after you are restored
//-----------------------------------------------------------------------------
void C_BaseEntity::OnRestore()
{
InvalidatePhysicsRecursive( POSITION_CHANGED | ANGLES_CHANGED | VELOCITY_CHANGED );
UpdatePartitionListEntry();
CollisionProp()->UpdatePartition();
UpdateVisibility();
}
//-----------------------------------------------------------------------------
// Purpose: Saves the current object out to disk, by iterating through the objects
// data description hierarchy
// Input : &save - save buffer which the class data is written to
// Output : int - 0 if the save failed, 1 on success
//-----------------------------------------------------------------------------
int C_BaseEntity::Save( ISave &save )
{
// loop through the data description list, saving each data desc block
int status = SaveDataDescBlock( save, GetDataDescMap() );
return status;
}
//-----------------------------------------------------------------------------
// Purpose: Recursively saves all the classes in an object, in reverse order (top down)
// Output : int 0 on failure, 1 on success
//-----------------------------------------------------------------------------
int C_BaseEntity::SaveDataDescBlock( ISave &save, datamap_t *dmap )
{
int nResult = save.WriteAll( this, dmap );
return nResult;
}
void C_BaseEntity::SetClassname( const char *className )
{
m_iClassname = MAKE_STRING( className );
}
//-----------------------------------------------------------------------------
// Purpose: Restores the current object from disk, by iterating through the objects
// data description hierarchy
// Input : &restore - restore buffer which the class data is read from
// Output : int - 0 if the restore failed, 1 on success
//-----------------------------------------------------------------------------
int C_BaseEntity::Restore( IRestore &restore )
{
// loops through the data description list, restoring each data desc block in order
int status = RestoreDataDescBlock( restore, GetDataDescMap() );
// NOTE: Do *not* use GetAbsOrigin() here because it will
// try to recompute m_rgflCoordinateFrame!
MatrixSetColumn( m_vecAbsOrigin, 3, m_rgflCoordinateFrame );
// Restablish ground entity
if ( m_hGroundEntity != NULL )
{
m_hGroundEntity->AddEntityToGroundList( this );
}
return status;
}
//-----------------------------------------------------------------------------
// Purpose: Recursively restores all the classes in an object, in reverse order (top down)
// Output : int 0 on failure, 1 on success
//-----------------------------------------------------------------------------
int C_BaseEntity::RestoreDataDescBlock( IRestore &restore, datamap_t *dmap )
{
return restore.ReadAll( this, dmap );
}
//-----------------------------------------------------------------------------
// capabilities
//-----------------------------------------------------------------------------
int C_BaseEntity::ObjectCaps( void )
{
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : C_AI_BaseNPC
//-----------------------------------------------------------------------------
C_AI_BaseNPC *C_BaseEntity::MyNPCPointer( void )
{
if ( IsNPC() )
{
return assert_cast<C_AI_BaseNPC *>(this);
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: For each client (only can be local client in client .dll ) checks the client has disabled CC and if so, removes them from
// the recipient list.
// Input : filter -
//-----------------------------------------------------------------------------
void C_BaseEntity::RemoveRecipientsIfNotCloseCaptioning( C_RecipientFilter& filter )
{
extern ConVar closecaption;
if ( !closecaption.GetBool() )
{
filter.Reset();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : recording -
// Output : inline void
//-----------------------------------------------------------------------------
void C_BaseEntity::EnableInToolView( bool bEnable )
{
#ifndef NO_TOOLFRAMEWORK
m_bEnabledInToolView = bEnable;
UpdateVisibility();
#endif
}
void C_BaseEntity::SetToolRecording( bool recording )
{
#ifndef NO_TOOLFRAMEWORK
m_bToolRecording = recording;
if ( m_bToolRecording )
{
recordinglist->AddToList( GetClientHandle() );
}
else
{
recordinglist->RemoveFromList( GetClientHandle() );
}
#endif
}
bool C_BaseEntity::HasRecordedThisFrame() const
{
#ifndef NO_TOOLFRAMEWORK
Assert( m_nLastRecordedFrame <= gpGlobals->framecount );
return m_nLastRecordedFrame == gpGlobals->framecount;
#else
return false;
#endif
}
void C_BaseEntity::GetToolRecordingState( KeyValues *msg )
{
Assert( ToolsEnabled() );
if ( !ToolsEnabled() )
return;
VPROF_BUDGET( "C_BaseEntity::GetToolRecordingState", VPROF_BUDGETGROUP_TOOLS );
C_BaseEntity *pOwner = m_hOwnerEntity;
static BaseEntityRecordingState_t state;
state.m_flTime = gpGlobals->curtime;
state.m_pModelName = modelinfo->GetModelName( GetModel() );
state.m_nOwner = pOwner ? pOwner->entindex() : -1;
state.m_nEffects = m_fEffects;
state.m_bVisible = ShouldDraw() && !IsDormant();
state.m_bRecordFinalVisibleSample = false;
state.m_vecRenderOrigin = GetRenderOrigin();
state.m_vecRenderAngles = GetRenderAngles();
// use EF_NOINTERP if the owner or a hierarchical parent has NO_INTERP
if ( pOwner && pOwner->IsNoInterpolationFrame() )
{
state.m_nEffects |= EF_NOINTERP;
}
C_BaseEntity *pParent = GetMoveParent();
while ( pParent )
{
if ( pParent->IsNoInterpolationFrame() )
{
state.m_nEffects |= EF_NOINTERP;
break;
}
pParent = pParent->GetMoveParent();
}
msg->SetPtr( "baseentity", &state );
}
void C_BaseEntity::CleanupToolRecordingState( KeyValues *msg )
{
}
void C_BaseEntity::RecordToolMessage()
{
Assert( IsToolRecording() );
if ( !IsToolRecording() )
return;
if ( HasRecordedThisFrame() )
return;
KeyValues *msg = new KeyValues( "entity_state" );
// Post a message back to all IToolSystems
GetToolRecordingState( msg );
Assert( (int)GetToolHandle() != 0 );
ToolFramework_PostToolMessage( GetToolHandle(), msg );
CleanupToolRecordingState( msg );
msg->deleteThis();
m_nLastRecordedFrame = gpGlobals->framecount;
}
// (static function)
void C_BaseEntity::ToolRecordEntities()
{
VPROF_BUDGET( "C_BaseEntity::ToolRecordEnties", VPROF_BUDGETGROUP_TOOLS );
if ( !ToolsEnabled() || !clienttools->IsInRecordingMode() )
return;
// Let non-dormant client created predictables get added, too
int c = recordinglist->Count();
for ( int i = 0 ; i < c ; i++ )
{
IClientRenderable *pRenderable = recordinglist->Get( i );
if ( !pRenderable )
continue;
pRenderable->RecordToolMessage();
}
}
void C_BaseEntity::AddToInterpolationList()
{
if ( m_InterpolationListEntry == 0xFFFF )
m_InterpolationListEntry = g_InterpolationList.AddToTail( this );
}
void C_BaseEntity::RemoveFromInterpolationList()
{
if ( m_InterpolationListEntry != 0xFFFF )
{
g_InterpolationList.Remove( m_InterpolationListEntry );
m_InterpolationListEntry = 0xFFFF;
}
}
void C_BaseEntity::AddToTeleportList()
{
if ( m_TeleportListEntry == 0xFFFF )
m_TeleportListEntry = g_TeleportList.AddToTail( this );
}
void C_BaseEntity::RemoveFromTeleportList()
{
if ( m_TeleportListEntry != 0xFFFF )
{
g_TeleportList.Remove( m_TeleportListEntry );
m_TeleportListEntry = 0xFFFF;
}
}
#ifdef TF_CLIENT_DLL
bool C_BaseEntity::ValidateEntityAttachedToPlayer( bool &bShouldRetry )
{
bShouldRetry = false;
C_BaseEntity *pParent = GetRootMoveParent();
if ( pParent == this )
return true;
// Some wearables parent to the view model
C_TFPlayer *pPlayer = ToTFPlayer( pParent );
if ( pPlayer )
{
if ( pPlayer->GetViewModel() == this )
return true;
if ( pPlayer->HasItem() && ( pPlayer->GetItem()->GetItemID() == TF_ITEM_CAPTURE_FLAG ) && ( pPlayer->GetItem() == this ) )
return true;
}
// always allow the briefcase model
const char *pszModel = modelinfo->GetModelName( GetModel() );
if ( pszModel && pszModel[0] )
{
if ( FStrEq( pszModel, "models/flag/briefcase.mdl" ) )
return true;
if ( FStrEq( pszModel, "models/props_doomsday/australium_container.mdl" ) )
return true;
// Temp for MVM testing
if ( FStrEq( pszModel, "models/buildables/sapper_placement.mdl" ) )
return true;
if ( FStrEq( pszModel, "models/props_td/atom_bomb.mdl" ) )
return true;
if ( FStrEq( pszModel, "models/props_lakeside_event/bomb_temp_hat.mdl" ) )
return true;
if ( FStrEq( pszModel, "models/props_moonbase/powersupply_flag.mdl" ) )
return true;
// The Halloween 2014 doomsday flag replacement
if ( FStrEq( pszModel, "models/flag/ticket_case.mdl" ) )
return true;
if ( FStrEq( pszModel, "models/weapons/c_models/c_grapple_proj/c_grapple_proj.mdl" ) )
return true;
}
// Any entity that's not an item parented to a player is invalid.
// This prevents them creating some other entity to pretend to be a cosmetic item.
return !pParent->IsPlayer();
}
#endif // TF_CLIENT_DLL
void C_BaseEntity::AddVar( void *data, IInterpolatedVar *watcher, int type, bool bSetup )
{
// Only add it if it hasn't been added yet.
bool bAddIt = true;
for ( int i=0; i < m_VarMap.m_Entries.Count(); i++ )
{
if ( m_VarMap.m_Entries[i].watcher == watcher )
{
if ( (type & EXCLUDE_AUTO_INTERPOLATE) != (watcher->GetType() & EXCLUDE_AUTO_INTERPOLATE) )
{
// Its interpolation mode changed, so get rid of it and re-add it.
RemoveVar( m_VarMap.m_Entries[i].data, true );
}
else
{
// They're adding something that's already there. No need to re-add it.
bAddIt = false;
}
break;
}
}
if ( bAddIt )
{
// watchers must have a debug name set
Assert( watcher->GetDebugName() != NULL );
VarMapEntry_t map;
map.data = data;
map.watcher = watcher;
map.type = type;
map.m_bNeedsToInterpolate = true;
if ( type & EXCLUDE_AUTO_INTERPOLATE )
{
m_VarMap.m_Entries.AddToTail( map );
}
else
{
m_VarMap.m_Entries.AddToHead( map );
++m_VarMap.m_nInterpolatedEntries;
}
}
if ( bSetup )
{
watcher->Setup( data, type );
watcher->SetInterpolationAmount( GetInterpolationAmount( watcher->GetType() ) );
}
}
void C_BaseEntity::RemoveVar( void *data, bool bAssert )
{
for ( int i=0; i < m_VarMap.m_Entries.Count(); i++ )
{
if ( m_VarMap.m_Entries[i].data == data )
{
if ( !( m_VarMap.m_Entries[i].type & EXCLUDE_AUTO_INTERPOLATE ) )
--m_VarMap.m_nInterpolatedEntries;
m_VarMap.m_Entries.Remove( i );
return;
}
}
if ( bAssert )
{
Assert( !"RemoveVar" );
}
}
void C_BaseEntity::CheckCLInterpChanged()
{
float flCurValue_Interp = GetClientInterpAmount();
static float flLastValue_Interp = flCurValue_Interp;
float flCurValue_InterpNPCs = cl_interp_npcs.GetFloat();
static float flLastValue_InterpNPCs = flCurValue_InterpNPCs;
if ( flLastValue_Interp != flCurValue_Interp ||
flLastValue_InterpNPCs != flCurValue_InterpNPCs )
{
flLastValue_Interp = flCurValue_Interp;
flLastValue_InterpNPCs = flCurValue_InterpNPCs;
// Tell all the existing entities to update their interpolation amounts to account for the change.
C_BaseEntityIterator iterator;
C_BaseEntity *pEnt;
while ( (pEnt = iterator.Next()) != NULL )
{
pEnt->Interp_UpdateInterpolationAmounts( pEnt->GetVarMapping() );
}
}
}
void C_BaseEntity::DontRecordInTools()
{
#ifndef NO_TOOLFRAMEWORK
m_bRecordInTools = false;
#endif
}
int C_BaseEntity::GetCreationTick() const
{
return m_nCreationTick;
}
//------------------------------------------------------------------------------
void CC_CL_Find_Ent( const CCommand& args )
{
if ( args.ArgC() < 2 )
{
Msg( "Format: cl_find_ent <substring>\n" );
return;
}
int iCount = 0;
const char *pszSubString = args[1];
Msg("Searching for client entities with classname containing substring: '%s'\n", pszSubString );
C_BaseEntity *ent = NULL;
while ( (ent = ClientEntityList().NextBaseEntity(ent)) != NULL )
{
const char *pszClassname = ent->GetClassname();
bool bMatches = false;
if ( pszClassname && pszClassname[0] )
{
if ( Q_stristr( pszClassname, pszSubString ) )
{
bMatches = true;
}
}
if ( bMatches )
{
iCount++;
Msg(" '%s' (entindex %d) %s \n", pszClassname ? pszClassname : "[NO NAME]", ent->entindex(), ent->IsDormant() ? "(DORMANT)" : "" );
}
}
Msg("Found %d matches.\n", iCount);
}
static ConCommand cl_find_ent("cl_find_ent", CC_CL_Find_Ent, "Find and list all client entities with classnames that contain the specified substring.\nFormat: cl_find_ent <substring>\n", FCVAR_CHEAT);
//------------------------------------------------------------------------------
void CC_CL_Find_Ent_Index( const CCommand& args )
{
if ( args.ArgC() < 2 )
{
Msg( "Format: cl_find_ent_index <index>\n" );
return;
}
int iIndex = atoi(args[1]);
C_BaseEntity *ent = ClientEntityList().GetBaseEntity( iIndex );
if ( ent )
{
const char *pszClassname = ent->GetClassname();
Msg(" '%s' (entindex %d) %s \n", pszClassname ? pszClassname : "[NO NAME]", iIndex, ent->IsDormant() ? "(DORMANT)" : "" );
}
else
{
Msg("Found no entity at %d.\n", iIndex);
}
}
static ConCommand cl_find_ent_index("cl_find_ent_index", CC_CL_Find_Ent_Index, "Display data for clientside entity matching specified index.\nFormat: cl_find_ent_index <index>\n", FCVAR_CHEAT);