diff options
Diffstat (limited to 'game/client/c_baseentity.h')
| -rw-r--r-- | game/client/c_baseentity.h | 2219 |
1 files changed, 2219 insertions, 0 deletions
diff --git a/game/client/c_baseentity.h b/game/client/c_baseentity.h new file mode 100644 index 0000000..9c7982c --- /dev/null +++ b/game/client/c_baseentity.h @@ -0,0 +1,2219 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: A base class for the client-side representation of entities. +// +// This class encompasses both entities that are created on the server +// and networked to the client AND entities that are created on the +// client. +// +// $NoKeywords: $ +//===========================================================================// + +#ifndef C_BASEENTITY_H +#define C_BASEENTITY_H +#ifdef _WIN32 +#pragma once +#endif + +#include "mathlib/vector.h" +#include "icliententityinternal.h" +#include "engine/ivmodelinfo.h" +#include "engine/ivmodelrender.h" +#include "client_class.h" +#include "iclientshadowmgr.h" +#include "ehandle.h" +#include "iclientunknown.h" +#include "client_thinklist.h" +#if !defined( NO_ENTITY_PREDICTION ) +#include "predictableid.h" +#endif +#include "soundflags.h" +#include "shareddefs.h" +#include "networkvar.h" +#include "interpolatedvar.h" +#include "collisionproperty.h" +#include "particle_property.h" +#include "toolframework/itoolentity.h" +#include "tier0/threadtools.h" + +class C_Team; +class IPhysicsObject; +class IClientVehicle; +class CPredictionCopy; +class C_BasePlayer; +struct studiohdr_t; +class CStudioHdr; +class CDamageModifier; +class IRecipientFilter; +class CUserCmd; +struct solid_t; +class ISave; +class IRestore; +class C_BaseAnimating; +class C_AI_BaseNPC; +struct EmitSound_t; +class C_RecipientFilter; +class CTakeDamageInfo; +class C_BaseCombatCharacter; +class CEntityMapData; +class ConVar; +class CDmgAccumulator; +class IHasAttributes; + +struct CSoundParameters; + +typedef unsigned int AimEntsListHandle_t; + +#define INVALID_AIMENTS_LIST_HANDLE (AimEntsListHandle_t)~0 + +extern void RecvProxy_IntToColor32( const CRecvProxyData *pData, void *pStruct, void *pOut ); +extern void RecvProxy_LocalVelocity( const CRecvProxyData *pData, void *pStruct, void *pOut ); + +enum CollideType_t +{ + ENTITY_SHOULD_NOT_COLLIDE = 0, + ENTITY_SHOULD_COLLIDE, + ENTITY_SHOULD_RESPOND +}; + +class VarMapEntry_t +{ + + +public: + unsigned short type; + unsigned short m_bNeedsToInterpolate; // Set to false when this var doesn't + // need Interpolate() called on it anymore. + void *data; + IInterpolatedVar *watcher; +}; + +struct VarMapping_t +{ + VarMapping_t() + { + m_nInterpolatedEntries = 0; + } + + CUtlVector< VarMapEntry_t > m_Entries; + int m_nInterpolatedEntries; + float m_lastInterpolationTime; +}; + + + +#define DECLARE_INTERPOLATION() + + +// How many data slots to use when in multiplayer. +#define MULTIPLAYER_BACKUP 90 + + +struct serialentity_t; + +typedef CHandle<C_BaseEntity> EHANDLE; // The client's version of EHANDLE. + +typedef void (C_BaseEntity::*BASEPTR)(void); +typedef void (C_BaseEntity::*ENTITYFUNCPTR)(C_BaseEntity *pOther ); + +// For entity creation on the client +typedef C_BaseEntity* (*DISPATCHFUNCTION)( void ); + +#include "touchlink.h" +#include "groundlink.h" + +#if !defined( NO_ENTITY_PREDICTION ) +//----------------------------------------------------------------------------- +// Purpose: For fully client side entities we use this information to determine +// authoritatively if the server has acknowledged creating this entity, etc. +//----------------------------------------------------------------------------- +struct PredictionContext +{ + PredictionContext() + { + m_bActive = false; + m_nCreationCommandNumber = -1; + m_pszCreationModule = NULL; + m_nCreationLineNumber = 0; + m_hServerEntity = NULL; + } + + // The command_number of the usercmd which created this entity + bool m_bActive; + int m_nCreationCommandNumber; + char const *m_pszCreationModule; + int m_nCreationLineNumber; + // The entity to whom we are attached + CHandle< C_BaseEntity > m_hServerEntity; +}; +#endif + +//----------------------------------------------------------------------------- +// Purpose: think contexts +//----------------------------------------------------------------------------- +struct thinkfunc_t +{ + BASEPTR m_pfnThink; + string_t m_iszContext; + int m_nNextThinkTick; + int m_nLastThinkTick; +}; + +#define CREATE_PREDICTED_ENTITY( className ) \ + C_BaseEntity::CreatePredictedEntityByName( className, __FILE__, __LINE__ ); + + + +// Entity flags that only exist on the client. +#define ENTCLIENTFLAG_GETTINGSHADOWRENDERBOUNDS 0x0001 // Tells us if we're getting the real ent render bounds or the shadow render bounds. +#define ENTCLIENTFLAG_DONTUSEIK 0x0002 // Don't use IK on this entity even if its model has IK. +#define ENTCLIENTFLAG_ALWAYS_INTERPOLATE 0x0004 // Used by view models. + +//----------------------------------------------------------------------------- +// Purpose: Base client side entity object +//----------------------------------------------------------------------------- +class C_BaseEntity : public IClientEntity +{ +// Construction + DECLARE_CLASS_NOBASE( C_BaseEntity ); + + friend class CPrediction; + friend void cc_cl_interp_all_changed( IConVar *pConVar, const char *pOldString, float flOldValue ); + +public: + DECLARE_DATADESC(); + DECLARE_CLIENTCLASS(); + DECLARE_PREDICTABLE(); + + C_BaseEntity(); + virtual ~C_BaseEntity(); + + static C_BaseEntity *CreatePredictedEntityByName( const char *classname, const char *module, int line, bool persist = false ); + + // FireBullets uses shared code for prediction. + virtual void FireBullets( const FireBulletsInfo_t &info ); + virtual void ModifyFireBulletsDamage( CTakeDamageInfo* dmgInfo ) {} + virtual bool ShouldDrawUnderwaterBulletBubbles(); + virtual bool ShouldDrawWaterImpacts( void ) { return true; } + virtual bool HandleShotImpactingWater( const FireBulletsInfo_t &info, + const Vector &vecEnd, ITraceFilter *pTraceFilter, Vector *pVecTracerDest ); + virtual ITraceFilter* GetBeamTraceFilter( void ); + virtual void DispatchTraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator = NULL ); + virtual void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator = NULL ); + virtual void DoImpactEffect( trace_t &tr, int nDamageType ); + virtual void MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType ); + virtual int GetTracerAttachment( void ); + void ComputeTracerStartPosition( const Vector &vecShotSrc, Vector *pVecTracerStart ); + void TraceBleed( float flDamage, const Vector &vecDir, trace_t *ptr, int bitsDamageType ); + virtual int BloodColor(); + virtual const char* GetTracerType(); + + virtual void Spawn( void ); + virtual void SpawnClientEntity( void ); + virtual void Precache( void ); + virtual void Activate(); + + virtual void ParseMapData( CEntityMapData *mapData ); + virtual bool KeyValue( const char *szKeyName, const char *szValue ); + virtual bool KeyValue( const char *szKeyName, float flValue ); + virtual bool KeyValue( const char *szKeyName, const Vector &vecValue ); + virtual bool GetKeyValue( const char *szKeyName, char *szValue, int iMaxLen ); + + // Entities block Line-Of-Sight for NPCs by default. + // Set this to false if you want to change this behavior. + void SetBlocksLOS( bool bBlocksLOS ); + bool BlocksLOS( void ); + void SetAIWalkable( bool bBlocksLOS ); + bool IsAIWalkable( void ); + + + void Interp_SetupMappings( VarMapping_t *map ); + + // Returns 1 if there are no more changes (ie: we could call RemoveFromInterpolationList). + int Interp_Interpolate( VarMapping_t *map, float currentTime ); + + void Interp_RestoreToLastNetworked( VarMapping_t *map ); + void Interp_UpdateInterpolationAmounts( VarMapping_t *map ); + void Interp_HierarchyUpdateInterpolationAmounts(); + + // Called by the CLIENTCLASS macros. + virtual bool Init( int entnum, int iSerialNum ); + + // Called in the destructor to shutdown everything. + void Term(); + + // memory handling, uses calloc so members are zero'd out on instantiation + void *operator new( size_t stAllocateBlock ); + void *operator new[]( size_t stAllocateBlock ); + void *operator new( size_t stAllocateBlock, int nBlockUse, const char *pFileName, int nLine ); + void *operator new[]( size_t stAllocateBlock, int nBlockUse, const char *pFileName, int nLine ); + void operator delete( void *pMem ); + void operator delete( void *pMem, int nBlockUse, const char *pFileName, int nLine ) { operator delete( pMem ); } + + // This just picks one of the routes to IClientUnknown. + IClientUnknown* GetIClientUnknown() { return this; } + virtual C_BaseAnimating* GetBaseAnimating() { return NULL; } + virtual void SetClassname( const char *className ); + + string_t m_iClassname; + +// IClientUnknown overrides. +public: + + virtual void SetRefEHandle( const CBaseHandle &handle ); + virtual const CBaseHandle& GetRefEHandle() const; + + void SetToolHandle( HTOOLHANDLE handle ); + HTOOLHANDLE GetToolHandle() const; + + void EnableInToolView( bool bEnable ); + bool IsEnabledInToolView() const; + + void SetToolRecording( bool recording ); + bool IsToolRecording() const; + bool HasRecordedThisFrame() const; + virtual void RecordToolMessage(); + + // used to exclude entities from being recorded in the SFM tools + void DontRecordInTools(); + bool ShouldRecordInTools() const; + + virtual void Release(); + virtual ICollideable* GetCollideable() { return &m_Collision; } + virtual IClientNetworkable* GetClientNetworkable() { return this; } + virtual IClientRenderable* GetClientRenderable() { return this; } + virtual IClientEntity* GetIClientEntity() { return this; } + virtual C_BaseEntity* GetBaseEntity() { return this; } + virtual IClientThinkable* GetClientThinkable() { return this; } + + +// Methods of IClientRenderable +public: + + virtual const Vector& GetRenderOrigin( void ); + virtual const QAngle& GetRenderAngles( void ); + virtual Vector GetObserverCamOrigin( void ) { return GetRenderOrigin(); } // Return the origin for player observers tracking this target + virtual const matrix3x4_t & RenderableToWorldTransform(); + virtual bool IsTransparent( void ); + virtual bool IsTwoPass( void ); + virtual bool UsesPowerOfTwoFrameBufferTexture(); + virtual bool UsesFullFrameBufferTexture(); + virtual bool IgnoresZBuffer( void ) const; + virtual const model_t *GetModel( void ) const; + virtual int DrawModel( int flags ); + virtual void ComputeFxBlend( void ); + virtual int GetFxBlend( void ); + virtual bool LODTest() { return true; } // NOTE: UNUSED + virtual void GetRenderBounds( Vector& mins, Vector& maxs ); + virtual IPVSNotify* GetPVSNotifyInterface(); + virtual void GetRenderBoundsWorldspace( Vector& absMins, Vector& absMaxs ); + + virtual void GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType ); + + // Determine the color modulation amount + virtual void GetColorModulation( float* color ); + + virtual void OnThreadedDrawSetup() {} +public: + virtual bool TestCollision( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr ); + virtual bool TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr ); + + // To mimic server call convention + C_BaseEntity *GetOwnerEntity( void ) const; + void SetOwnerEntity( C_BaseEntity *pOwner ); + + C_BaseEntity *GetEffectEntity( void ) const; + void SetEffectEntity( C_BaseEntity *pEffectEnt ); + + // This function returns a value that scales all damage done by this entity. + // Use CDamageModifier to hook in damage modifiers on a guy. + virtual float GetAttackDamageScale( void ); + +// IClientNetworkable implementation. +public: + virtual void NotifyShouldTransmit( ShouldTransmitState_t state ); + + // save out interpolated values + virtual void PreDataUpdate( DataUpdateType_t updateType ); + virtual void PostDataUpdate( DataUpdateType_t updateType ); + virtual void OnDataUnchangedInPVS(); + + virtual void ValidateModelIndex( void ); + + // pvs info. NOTE: Do not override these!! + virtual void SetDormant( bool bDormant ); + virtual bool IsDormant( void ); + + // 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. + virtual void SetDestroyedOnRecreateEntities( void ); + + virtual int GetEFlags() const; + virtual void SetEFlags( int iEFlags ); + void AddEFlags( int nEFlagMask ); + void RemoveEFlags( int nEFlagMask ); + bool IsEFlagSet( int nEFlagMask ) const; + + // checks to see if the entity is marked for deletion + bool IsMarkedForDeletion( void ); + + virtual int entindex( void ) const; + + // This works for client-only entities and returns the GetEntryIndex() of the entity's handle, + // so the sound system can get an IClientEntity from it. + int GetSoundSourceIndex() const; + + // Server to client message received + virtual void ReceiveMessage( int classID, bf_read &msg ); + + virtual void* GetDataTableBasePtr(); + +// IClientThinkable. +public: + // Called whenever you registered for a think message (with SetNextClientThink). + virtual void ClientThink(); + + virtual ClientThinkHandle_t GetThinkHandle(); + virtual void SetThinkHandle( ClientThinkHandle_t hThink ); + + +public: + + void AddVar( void *data, IInterpolatedVar *watcher, int type, bool bSetup=false ); + void RemoveVar( void *data, bool bAssert=true ); + VarMapping_t* GetVarMapping(); + + VarMapping_t m_VarMap; + + +public: + // An inline version the game code can use + CCollisionProperty *CollisionProp(); + const CCollisionProperty*CollisionProp() const; + CParticleProperty *ParticleProp(); + const CParticleProperty *ParticleProp() const; + + // Simply here for game shared + bool IsFloating(); + + virtual bool ShouldSavePhysics(); + +// save/restore stuff + virtual void OnSave(); + virtual void OnRestore(); + // capabilities for save/restore + virtual int ObjectCaps( void ); + // only overload these if you have special data to serialize + virtual int Save( ISave &save ); + virtual int Restore( IRestore &restore ); + +private: + + int SaveDataDescBlock( ISave &save, datamap_t *dmap ); + int RestoreDataDescBlock( IRestore &restore, datamap_t *dmap ); + + // Called after restoring data into prediction slots. This function is used in place of proxies + // on the variables, so if some variable like m_nModelIndex needs to update other state (like + // the model pointer), it is done here. + void OnPostRestoreData(); + +public: + + // Called after spawn, and in the case of self-managing objects, after load + virtual bool CreateVPhysics(); + + // Convenience routines to init the vphysics simulation for this object. + // This creates a static object. Something that behaves like world geometry - solid, but never moves + IPhysicsObject *VPhysicsInitStatic( void ); + + // This creates a normal vphysics simulated object + IPhysicsObject *VPhysicsInitNormal( SolidType_t solidType, int nSolidFlags, bool createAsleep, solid_t *pSolid = NULL ); + + // This creates a vphysics object with a shadow controller that follows the AI + // Move the object to where it should be and call UpdatePhysicsShadowToCurrentPosition() + IPhysicsObject *VPhysicsInitShadow( bool allowPhysicsMovement, bool allowPhysicsRotation, solid_t *pSolid = NULL ); + +private: + // called by all vphysics inits + bool VPhysicsInitSetup(); +public: + + void VPhysicsSetObject( IPhysicsObject *pPhysics ); + // destroy and remove the physics object for this entity + virtual void VPhysicsDestroyObject( void ); + + // Purpose: My physics object has been updated, react or extract data + virtual void VPhysicsUpdate( IPhysicsObject *pPhysics ); + inline IPhysicsObject *VPhysicsGetObject( void ) const { return m_pPhysicsObject; } + virtual int VPhysicsGetObjectList( IPhysicsObject **pList, int listMax ); + virtual bool VPhysicsIsFlesh( void ); + +// IClientEntity implementation. +public: + virtual bool SetupBones( matrix3x4_t *pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime ); + virtual void SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights ); + virtual bool UsesFlexDelayedWeights() { return false; } + virtual void DoAnimationEvents( void ); + + // Add entity to visible entities list? + virtual void AddEntity( void ); + + virtual const Vector& GetAbsOrigin( void ) const; + virtual const QAngle& GetAbsAngles( void ) const; + + const Vector& GetNetworkOrigin() const; + const QAngle& GetNetworkAngles() const; + + void SetNetworkOrigin( const Vector& org ); + void SetNetworkAngles( const QAngle& ang ); + + const Vector& GetLocalOrigin( void ) const; + void SetLocalOrigin( const Vector& origin ); + vec_t GetLocalOriginDim( int iDim ) const; // You can use the X_INDEX, Y_INDEX, and Z_INDEX defines here. + void SetLocalOriginDim( int iDim, vec_t flValue ); + + const QAngle& GetLocalAngles( void ) const; + void SetLocalAngles( const QAngle& angles ); + vec_t GetLocalAnglesDim( int iDim ) const; // You can use the X_INDEX, Y_INDEX, and Z_INDEX defines here. + void SetLocalAnglesDim( int iDim, vec_t flValue ); + + virtual const Vector& GetPrevLocalOrigin() const; + virtual const QAngle& GetPrevLocalAngles() const; + + void SetLocalTransform( const matrix3x4_t &localTransform ); + + void SetModelName( string_t name ); + string_t GetModelName( void ) const; + + int GetModelIndex( void ) const; + void SetModelIndex( int index ); + virtual int CalcOverrideModelIndex() { return -1; } + + // These methods return a *world-aligned* box relative to the absorigin of the entity. + // This is used for collision purposes and is *not* guaranteed + // to surround the entire entity's visual representation + // NOTE: It is illegal to ask for the world-aligned bounds for + // SOLID_BSP objects + virtual const Vector& WorldAlignMins( ) const; + virtual const Vector& WorldAlignMaxs( ) const; + + // This defines collision bounds *in whatever space is currently defined by the solid type* + // SOLID_BBOX: World Align + // SOLID_OBB: Entity space + // SOLID_BSP: Entity space + // SOLID_VPHYSICS Not used + void SetCollisionBounds( const Vector& mins, const Vector &maxs ); + + // NOTE: These use the collision OBB to compute a reasonable center point for the entity + virtual const Vector& WorldSpaceCenter( ) const; + + // FIXME: Do we want this? + const Vector& WorldAlignSize( ) const; + bool IsPointSized() const; + + // Returns a radius of a sphere + // *centered at the world space center* bounding the collision representation + // of the entity. NOTE: The world space center *may* move when the entity rotates. + float BoundingRadius() const; + + // Used when the collision prop is told to ask game code for the world-space surrounding box + virtual void ComputeWorldSpaceSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs ); + virtual float GetHealthBarHeightOffset() const { return 0.f; } + + // Returns the entity-to-world transform + matrix3x4_t &EntityToWorldTransform(); + const matrix3x4_t &EntityToWorldTransform() const; + + // Some helper methods that transform a point from entity space to world space + back + void EntityToWorldSpace( const Vector &in, Vector *pOut ) const; + void WorldToEntitySpace( const Vector &in, Vector *pOut ) const; + + // This function gets your parent's transform. If you're parented to an attachment, + // this calculates the attachment's transform and gives you that. + // + // You must pass in tempMatrix for scratch space - it may need to fill that in and return it instead of + // pointing you right at a variable in your parent. + matrix3x4_t& GetParentToWorldTransform( matrix3x4_t &tempMatrix ); + + void GetVectors(Vector* forward, Vector* right, Vector* up) const; + + // Sets abs angles, but also sets local angles to be appropriate + void SetAbsOrigin( const Vector& origin ); + void SetAbsAngles( const QAngle& angles ); + + void AddFlag( int flags ); + void RemoveFlag( int flagsToRemove ); + void ToggleFlag( int flagToToggle ); + int GetFlags( void ) const; + void ClearFlags(); + + MoveType_t GetMoveType( void ) const; + MoveCollide_t GetMoveCollide( void ) const; + virtual SolidType_t GetSolid( void ) const; + + virtual int GetSolidFlags( void ) const; + bool IsSolidFlagSet( int flagMask ) const; + void SetSolidFlags( int nFlags ); + void AddSolidFlags( int nFlags ); + void RemoveSolidFlags( int nFlags ); + bool IsSolid() const; + + virtual class CMouthInfo *GetMouth( void ); + + // Retrieve sound spatialization info for the specified sound on this entity + // Return false to indicate sound is not audible + virtual bool GetSoundSpatialization( SpatializationInfo_t& info ); + + // Attachments + virtual int LookupAttachment( const char *pAttachmentName ) { return -1; } + virtual bool GetAttachment( int number, matrix3x4_t &matrix ); + virtual bool GetAttachment( int number, Vector &origin ); + virtual bool GetAttachment( int number, Vector &origin, QAngle &angles ); + virtual bool GetAttachmentVelocity( int number, Vector &originVel, Quaternion &angleVel ); + + // Team handling + virtual C_Team *GetTeam( void ) const; + virtual int GetTeamNumber( void ) const; + virtual void ChangeTeam( int iTeamNum ); // Assign this entity to a team. + virtual int GetRenderTeamNumber( void ); + virtual bool InSameTeam( const C_BaseEntity *pEntity ) const; // Returns true if the specified entity is on the same team as this one + virtual bool InLocalTeam( void ); + + // ID Target handling + virtual bool IsValidIDTarget( void ) { return false; } + virtual const char *GetIDString( void ) { return ""; }; + + // See CSoundEmitterSystem + virtual void ModifyEmitSoundParams( EmitSound_t ¶ms ); + + void EmitSound( const char *soundname, float soundtime = 0.0f, float *duration = NULL ); // Override for doing the general case of CPASAttenuationFilter( this ), and EmitSound( filter, entindex(), etc. ); + void EmitSound( const char *soundname, HSOUNDSCRIPTHANDLE& handle, float soundtime = 0.0f, float *duration = NULL ); // Override for doing the general case of CPASAttenuationFilter( this ), and EmitSound( filter, entindex(), etc. ); + void StopSound( const char *soundname ); + void StopSound( const char *soundname, HSOUNDSCRIPTHANDLE& handle ); + void GenderExpandString( char const *in, char *out, int maxlen ); + + static float GetSoundDuration( const char *soundname, char const *actormodel ); + + static bool GetParametersForSound( const char *soundname, CSoundParameters ¶ms, const char *actormodel ); + static bool GetParametersForSound( const char *soundname, HSOUNDSCRIPTHANDLE& handle, CSoundParameters ¶ms, const char *actormodel ); + + static void EmitSound( IRecipientFilter& filter, int iEntIndex, const char *soundname, const Vector *pOrigin = NULL, float soundtime = 0.0f, float *duration = NULL ); + static void EmitSound( IRecipientFilter& filter, int iEntIndex, const char *soundname, HSOUNDSCRIPTHANDLE& handle, const Vector *pOrigin = NULL, float soundtime = 0.0f, float *duration = NULL ); + static void StopSound( int iEntIndex, const char *soundname ); + static soundlevel_t LookupSoundLevel( const char *soundname ); + static soundlevel_t LookupSoundLevel( const char *soundname, HSOUNDSCRIPTHANDLE& handle ); + + static void EmitSound( IRecipientFilter& filter, int iEntIndex, const EmitSound_t & params ); + static void EmitSound( IRecipientFilter& filter, int iEntIndex, const EmitSound_t & params, HSOUNDSCRIPTHANDLE& handle ); + + static void StopSound( int iEntIndex, int iChannel, const char *pSample ); + + static void EmitAmbientSound( int entindex, const Vector& origin, const char *soundname, int flags = 0, float soundtime = 0.0f, float *duration = NULL ); + + // These files need to be listed in scripts/game_sounds_manifest.txt + static HSOUNDSCRIPTHANDLE PrecacheScriptSound( const char *soundname ); + static void PrefetchScriptSound( const char *soundname ); + + // For each client who appears to be a valid recipient, checks the client has disabled CC and if so, removes them from + // the recipient list. + static void RemoveRecipientsIfNotCloseCaptioning( C_RecipientFilter& filter ); + static void EmitCloseCaption( IRecipientFilter& filter, int entindex, char const *token, CUtlVector< Vector >& soundorigins, float duration, bool warnifmissing = false ); + + // Moves all aiments into their correct position for the frame + static void MarkAimEntsDirty(); + static void CalcAimEntPositions(); + + static bool IsPrecacheAllowed(); + static void SetAllowPrecache( bool allow ); + + static bool m_bAllowPrecache; + + static bool IsSimulatingOnAlternateTicks(); + +// C_BaseEntity local functions +public: + + void UpdatePartitionListEntry(); + + // This can be used to setup the entity as a client-only entity. + // Override this to perform per-entity clientside setup + virtual bool InitializeAsClientEntity( const char *pszModelName, RenderGroup_t renderGroup ); + + + + + + // This function gets called on all client entities once per simulation phase. + // It dispatches events like OnDataChanged(), and calls the legacy function AddEntity(). + virtual void Simulate(); + + + // This event is triggered during the simulation phase if an entity's data has changed. It is + // better to hook this instead of PostDataUpdate() because in PostDataUpdate(), server entity origins + // are incorrect and attachment points can't be used. + virtual void OnDataChanged( DataUpdateType_t type ); + + // This is called once per frame before any data is read in from the server. + virtual void OnPreDataChanged( DataUpdateType_t type ); + + bool IsStandable() const; + bool IsBSPModel() const; + + + // If this is a vehicle, returns the vehicle interface + virtual IClientVehicle* GetClientVehicle() { return NULL; } + + // Returns the aiment render origin + angles + virtual void GetAimEntOrigin( IClientEntity *pAttachedTo, Vector *pAbsOrigin, QAngle *pAbsAngles ); + + // get network origin from previous update + virtual const Vector& GetOldOrigin(); + + // Methods relating to traversing hierarchy + C_BaseEntity *GetMoveParent( void ) const; + C_BaseEntity *GetRootMoveParent(); + C_BaseEntity *FirstMoveChild( void ) const; + C_BaseEntity *NextMovePeer( void ) const; + + inline ClientEntityHandle_t GetClientHandle() const { return ClientEntityHandle_t( m_RefEHandle ); } + inline bool IsServerEntity( void ); + + virtual RenderGroup_t GetRenderGroup(); + + virtual void GetToolRecordingState( KeyValues *msg ); + virtual void CleanupToolRecordingState( KeyValues *msg ); + + // The value returned by here determines whether or not (and how) the entity + // is put into the spatial partition. + virtual CollideType_t GetCollideType( void ); + + virtual bool ShouldDraw(); + inline bool IsVisible() const { return m_hRender != INVALID_CLIENT_RENDER_HANDLE; } + virtual void UpdateVisibility(); + + // Returns true if the entity changes its position every frame on the server but it doesn't + // set animtime. In that case, the client returns true here so it copies the server time to + // animtime in OnDataChanged and the position history is correct for interpolation. + virtual bool IsSelfAnimating(); + + // Set appropriate flags and store off data when these fields are about to change + virtual void OnLatchInterpolatedVariables( int flags ); + // For predictable entities, stores last networked value + void OnStoreLastNetworkedValue(); + + // Initialize things given a new model. + virtual CStudioHdr *OnNewModel(); + virtual void OnNewParticleEffect( const char *pszParticleName, CNewParticleEffect *pNewParticleEffect ); + + bool IsSimulatedEveryTick() const; + bool IsAnimatedEveryTick() const; + void SetSimulatedEveryTick( bool sim ); + void SetAnimatedEveryTick( bool anim ); + + void Interp_Reset( VarMapping_t *map ); + virtual void ResetLatched(); + + float GetInterpolationAmount( int flags ); + float GetLastChangeTime( int flags ); + + // Interpolate the position for rendering + virtual bool Interpolate( float currentTime ); + + // Did the object move so far that it shouldn't interpolate? + bool Teleported( void ); + // Is this a submodel of the world ( *1 etc. in name ) ( brush models only ) + virtual bool IsSubModel( void ); + // Deal with EF_* flags + virtual void CreateLightEffects( void ); + + void AddToAimEntsList(); + void RemoveFromAimEntsList(); + + // Reset internal fields + virtual void Clear( void ); + // Helper to draw raw brush models + virtual int DrawBrushModel( bool bTranslucent, int nFlags, bool bTwoPass ); + + // returns the material animation start time + virtual float GetTextureAnimationStartTime(); + // Indicates that a texture animation has wrapped + virtual void TextureAnimationWrapped(); + + // Set the next think time. Pass in CLIENT_THINK_ALWAYS to have Think() called each frame. + virtual void SetNextClientThink( float nextThinkTime ); + + // anything that has health can override this... + virtual void SetHealth(int iHealth) {} + virtual int GetHealth() const { return 0; } + virtual int GetMaxHealth() const { return 1; } + virtual bool IsVisibleToTargetID( void ) const { return false; } + virtual bool IsHealthBarVisible( void ) const { return false; } + + // Returns the health fraction + float HealthFraction() const; + + // Should this object cast shadows? + virtual ShadowType_t ShadowCastType(); + + // Should this object receive shadows? + virtual bool ShouldReceiveProjectedTextures( int flags ); + + // Shadow-related methods + virtual bool IsShadowDirty( ); + virtual void MarkShadowDirty( bool bDirty ); + virtual IClientRenderable *GetShadowParent(); + virtual IClientRenderable *FirstShadowChild(); + virtual IClientRenderable *NextShadowPeer(); + + // Sets up a render handle so the leaf system will draw this entity. + void AddToLeafSystem(); + void AddToLeafSystem( RenderGroup_t group ); + // remove entity form leaf system again + void RemoveFromLeafSystem(); + + // A method to apply a decal to an entity + virtual void AddDecal( const Vector& rayStart, const Vector& rayEnd, + const Vector& decalCenter, int hitbox, int decalIndex, bool doTrace, trace_t& tr, int maxLODToDecal = ADDDECAL_TO_ALL_LODS ); + + virtual void AddColoredDecal( const Vector& rayStart, const Vector& rayEnd, + const Vector& decalCenter, int hitbox, int decalIndex, bool doTrace, trace_t& tr, Color cColor, int maxLODToDecal = ADDDECAL_TO_ALL_LODS ); + + // A method to remove all decals from an entity + void RemoveAllDecals( void ); + + // Is this a brush model? + bool IsBrushModel() const; + + // A random value 0-1 used by proxies to make sure they're not all in sync + float ProxyRandomValue() const { return m_flProxyRandomValue; } + + // The spawn time of this entity + float SpawnTime() const { return m_flSpawnTime; } + + virtual bool IsClientCreated( void ) const; + + virtual void UpdateOnRemove( void ); + + virtual void SUB_Remove( void ); + + // Prediction stuff + ///////////////// + void CheckInitPredictable( const char *context ); + + void AllocateIntermediateData( void ); + void DestroyIntermediateData( void ); + void ShiftIntermediateDataForward( int slots_to_remove, int previous_last_slot ); + + void *GetPredictedFrame( int framenumber ); + void *GetOriginalNetworkDataObject( void ); + bool IsIntermediateDataAllocated( void ) const; + + void InitPredictable( void ); + void ShutdownPredictable( void ); + + virtual void SetPredictable( bool state ); + bool GetPredictable( void ) const; + void PreEntityPacketReceived( int commands_acknowledged ); + void PostEntityPacketReceived( void ); + bool PostNetworkDataReceived( int commands_acknowledged ); + bool GetPredictionEligible( void ) const; + void SetPredictionEligible( bool canpredict ); + + enum + { + SLOT_ORIGINALDATA = -1, + }; + + int SaveData( const char *context, int slot, int type ); + virtual int RestoreData( const char *context, int slot, int type ); + + virtual char const * DamageDecal( int bitsDamageType, int gameMaterial ); + virtual void DecalTrace( trace_t *pTrace, char const *decalName ); + virtual void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName ); + + virtual bool ShouldPredict( void ) { return false; }; + // interface function pointers + void (C_BaseEntity::*m_pfnThink)(void); + virtual void Think( void ) + { + AssertMsg( m_pfnThink != &C_BaseEntity::Think, "Infinite recursion is infinitely bad." ); + + if ( m_pfnThink ) + { + ( this->*m_pfnThink )(); + } + } + + void PhysicsDispatchThink( BASEPTR thinkFunc ); + + // Toggle the visualization of the entity's abs/bbox + enum + { + VISUALIZE_COLLISION_BOUNDS = 0x1, + VISUALIZE_SURROUNDING_BOUNDS = 0x2, + VISUALIZE_RENDER_BOUNDS = 0x4, + }; + + void ToggleBBoxVisualization( int fVisFlags ); + void DrawBBoxVisualizations( void ); + +// Methods implemented on both client and server +public: + void SetSize( const Vector &vecMin, const Vector &vecMax ); // UTIL_SetSize( pev, mins, maxs ); + char const *GetClassname( void ); + char const *GetDebugName( void ); + static int PrecacheModel( const char *name ); + static bool PrecacheSound( const char *name ); + static void PrefetchSound( const char *name ); + void Remove( ); // UTIL_Remove( this ); + +public: + + // Returns the attachment point index on our parent that our transform is relative to. + // 0 if we're relative to the parent's absorigin and absangles. + unsigned char GetParentAttachment() const; + + // Externalized data objects ( see sharreddefs.h for DataObjectType_t ) + bool HasDataObjectType( int type ) const; + void AddDataObjectType( int type ); + void RemoveDataObjectType( int type ); + + void *GetDataObject( int type ); + void *CreateDataObject( int type ); + void DestroyDataObject( int type ); + void DestroyAllDataObjects( void ); + + // Determine approximate velocity based on updates from server + void EstimateAbsVelocity( Vector& vel ); + +#if !defined( NO_ENTITY_PREDICTION ) + // The player drives simulation of this entity + void SetPlayerSimulated( C_BasePlayer *pOwner ); + bool IsPlayerSimulated( void ) const; + CBasePlayer *GetSimulatingPlayer( void ); + void UnsetPlayerSimulated( void ); +#endif + + // Sorry folks, here lies TF2-specific stuff that really has no other place to go + virtual bool CanBePoweredUp( void ) { return false; } + virtual bool AttemptToPowerup( int iPowerup, float flTime, float flAmount = 0, C_BaseEntity *pAttacker = NULL, CDamageModifier *pDamageModifier = NULL ) { return false; } + + void SetCheckUntouch( bool check ); + bool GetCheckUntouch() const; + + virtual bool IsCurrentlyTouching( void ) const; + + virtual void StartTouch( C_BaseEntity *pOther ); + virtual void Touch( C_BaseEntity *pOther ); + virtual void EndTouch( C_BaseEntity *pOther ); + + void (C_BaseEntity ::*m_pfnTouch)( C_BaseEntity *pOther ); + + void PhysicsStep( void ); + +protected: + static bool sm_bDisableTouchFuncs; // Disables PhysicsTouch and PhysicsStartTouch function calls + +public: + touchlink_t *PhysicsMarkEntityAsTouched( C_BaseEntity *other ); + void PhysicsTouch( C_BaseEntity *pentOther ); + void PhysicsStartTouch( C_BaseEntity *pentOther ); + + // HACKHACK:Get the trace_t from the last physics touch call (replaces the even-hackier global trace vars) + static const trace_t &GetTouchTrace( void ); + + // FIXME: Should be private, but I can't make em private just yet + void PhysicsImpact( C_BaseEntity *other, trace_t &trace ); + void PhysicsMarkEntitiesAsTouching( C_BaseEntity *other, trace_t &trace ); + void PhysicsMarkEntitiesAsTouchingEventDriven( C_BaseEntity *other, trace_t &trace ); + + // Physics helper + static void PhysicsRemoveTouchedList( C_BaseEntity *ent ); + static void PhysicsNotifyOtherOfUntouch( C_BaseEntity *ent, C_BaseEntity *other ); + static void PhysicsRemoveToucher( C_BaseEntity *other, touchlink_t *link ); + + groundlink_t *AddEntityToGroundList( CBaseEntity *other ); + void PhysicsStartGroundContact( CBaseEntity *pentOther ); + + static void PhysicsNotifyOtherOfGroundRemoval( CBaseEntity *ent, CBaseEntity *other ); + static void PhysicsRemoveGround( CBaseEntity *other, groundlink_t *link ); + static void PhysicsRemoveGroundList( CBaseEntity *ent ); + + void StartGroundContact( CBaseEntity *ground ); + void EndGroundContact( CBaseEntity *ground ); + + void SetGroundChangeTime( float flTime ); + float GetGroundChangeTime( void ); + + // Remove this as ground entity for all object resting on this object + void WakeRestingObjects(); + bool HasNPCsOnIt(); + + bool PhysicsCheckWater( void ); + void PhysicsCheckVelocity( void ); + void PhysicsAddHalfGravity( float timestep ); + void PhysicsAddGravityMove( Vector &move ); + + virtual unsigned int PhysicsSolidMaskForEntity( void ) const; + + void SetGroundEntity( C_BaseEntity *ground ); + C_BaseEntity *GetGroundEntity( void ); + + void PhysicsPushEntity( const Vector& push, trace_t *pTrace ); + void PhysicsCheckWaterTransition( void ); + + // Performs the collision resolution for fliers. + void PerformFlyCollisionResolution( trace_t &trace, Vector &move ); + void ResolveFlyCollisionBounce( trace_t &trace, Vector &vecVelocity, float flMinTotalElasticity = 0.0f ); + void ResolveFlyCollisionSlide( trace_t &trace, Vector &vecVelocity ); + void ResolveFlyCollisionCustom( trace_t &trace, Vector &vecVelocity ); + + void PhysicsCheckForEntityUntouch( void ); + + // Creates the shadow (if it doesn't already exist) based on shadow cast type + void CreateShadow(); + + // Destroys the shadow; causes its type to be recomputed if the entity doesn't go away immediately. + void DestroyShadow(); + +protected: + // think function handling + enum thinkmethods_t + { + THINK_FIRE_ALL_FUNCTIONS, + THINK_FIRE_BASE_ONLY, + THINK_FIRE_ALL_BUT_BASE, + }; +public: + + // Unlinks from hierarchy + // Set the movement parent. Your local origin and angles will become relative to this parent. + // If iAttachment is a valid attachment on the parent, then your local origin and angles + // are relative to the attachment on this entity. + void SetParent( C_BaseEntity *pParentEntity, int iParentAttachment=0 ); + + bool PhysicsRunThink( thinkmethods_t thinkMethod = THINK_FIRE_ALL_FUNCTIONS ); + bool PhysicsRunSpecificThink( int nContextIndex, BASEPTR thinkFunc ); + + virtual void PhysicsSimulate( void ); + virtual bool IsAlive( void ); + + bool IsInWorld( void ) { return true; } + + bool IsWorld() { return entindex() == 0; } + ///////////////// + + virtual bool IsPlayer( void ) const { return false; }; + virtual bool IsBaseCombatCharacter( void ) { return false; }; + virtual C_BaseCombatCharacter *MyCombatCharacterPointer( void ) { return NULL; } + virtual bool IsNPC( void ) { return false; } + C_AI_BaseNPC *MyNPCPointer( void ); + virtual bool IsNextBot() { return false; } + // TF2 specific + virtual bool IsBaseObject( void ) const { return false; } + virtual bool IsBaseCombatWeapon( void ) const { return false; } + virtual class C_BaseCombatWeapon *MyCombatWeaponPointer() { return NULL; } + virtual bool IsCombatItem( void ) const { return false; } + + virtual bool IsBaseTrain( void ) const { return false; } + + // Returns the eye point + angles (used for viewing + shooting) + virtual Vector EyePosition( void ); + virtual const QAngle& EyeAngles( void ); // Direction of eyes + virtual const QAngle& LocalEyeAngles( void ); // Direction of eyes in local space (pl.v_angle) + + // position of ears + virtual Vector EarPosition( void ); + + Vector EyePosition( void ) const; // position of eyes + const QAngle &EyeAngles( void ) const; // Direction of eyes in world space + const QAngle &LocalEyeAngles( void ) const; // Direction of eyes + Vector EarPosition( void ) const; // position of ears + + // Called by physics to see if we should avoid a collision test.... + virtual bool ShouldCollide( int collisionGroup, int contentsMask ) const; + + // Sets physics parameters + void SetFriction( float flFriction ); + + void SetGravity( float flGravity ); + float GetGravity( void ) const; + + // Sets the model from a model index + void SetModelByIndex( int nModelIndex ); + + // Set model... (NOTE: Should only be used by client-only entities + // Returns false if the model name is bogus or otherwise can't be loaded + bool SetModel( const char *pModelName ); + + void SetModelPointer( const model_t *pModel ); + + + // Access movetype and solid. + void SetMoveType( MoveType_t val, MoveCollide_t moveCollide = MOVECOLLIDE_DEFAULT ); // Set to one of the MOVETYPE_ defines. + void SetMoveCollide( MoveCollide_t val ); // Set to one of the MOVECOLLIDE_ defines. + void SetSolid( SolidType_t val ); // Set to one of the SOLID_ defines. + + // NOTE: Setting the abs velocity in either space will cause a recomputation + // in the other space, so setting the abs velocity will also set the local vel + void SetLocalVelocity( const Vector &vecVelocity ); + void SetAbsVelocity( const Vector &vecVelocity ); + const Vector& GetLocalVelocity() const; + const Vector& GetAbsVelocity( ) const; + + void ApplyLocalVelocityImpulse( const Vector &vecImpulse ); + void ApplyAbsVelocityImpulse( const Vector &vecImpulse ); + void ApplyLocalAngularVelocityImpulse( const AngularImpulse &angImpulse ); + + // NOTE: Setting the abs velocity in either space will cause a recomputation + // in the other space, so setting the abs velocity will also set the local vel + void SetLocalAngularVelocity( const QAngle &vecAngVelocity ); + const QAngle& GetLocalAngularVelocity( ) const; + +// void SetAbsAngularVelocity( const QAngle &vecAngAbsVelocity ); +// const QAngle& GetAbsAngularVelocity( ) const; + + const Vector& GetBaseVelocity() const; + void SetBaseVelocity( const Vector& v ); + + virtual const Vector &GetViewOffset() const; + virtual void SetViewOffset( const Vector& v ); + +#ifdef SIXENSE + const Vector& GetEyeOffset() const; + void SetEyeOffset( const Vector& v ); + + const QAngle & GetEyeAngleOffset() const; + void SetEyeAngleOffset( const QAngle & qa ); +#endif + + // Invalidates the abs state of all children + void InvalidatePhysicsRecursive( int nChangeFlags ); + + ClientRenderHandle_t GetRenderHandle() const; + + void SetRemovalFlag( bool bRemove ); + + // Effects... + bool IsEffectActive( int nEffectMask ) const; + void AddEffects( int nEffects ); + void RemoveEffects( int nEffects ); + int GetEffects( void ) const; + void ClearEffects( void ); + void SetEffects( int nEffects ); + + // Computes the abs position of a point specified in local space + void ComputeAbsPosition( const Vector &vecLocalPosition, Vector *pAbsPosition ); + + // Computes the abs position of a direction specified in local space + void ComputeAbsDirection( const Vector &vecLocalDirection, Vector *pAbsDirection ); + + // These methods encapsulate MOVETYPE_FOLLOW, which became obsolete + void FollowEntity( CBaseEntity *pBaseEntity, bool bBoneMerge = true ); + void StopFollowingEntity( ); // will also change to MOVETYPE_NONE + bool IsFollowingEntity(); + CBaseEntity *GetFollowedEntity(); + + // For shadows rendering the correct body + sequence... + virtual int GetBody() { return 0; } + virtual int GetSkin() { return 0; } + + // Stubs on client + void NetworkStateManualMode( bool activate ) { } + void NetworkStateChanged() { } + void NetworkStateChanged( void *pVar ) { } + void NetworkStateSetUpdateInterval( float N ) { } + void NetworkStateForceUpdate() { } + + // Think functions with contexts + int RegisterThinkContext( const char *szContext ); + BASEPTR ThinkSet( BASEPTR func, float flNextThinkTime = 0, const char *szContext = NULL ); + void SetNextThink( float nextThinkTime, const char *szContext = NULL ); + float GetNextThink( const char *szContext = NULL ); + float GetLastThink( const char *szContext = NULL ); + int GetNextThinkTick( const char *szContext = NULL ); + int GetLastThinkTick( const char *szContext = NULL ); + + // These set entity flags (EFL_*) to help optimize queries + void CheckHasThinkFunction( bool isThinkingHint = false ); + void CheckHasGamePhysicsSimulation(); + bool WillThink(); + bool WillSimulateGamePhysics(); + int GetFirstThinkTick(); // get first tick thinking on any context + + float GetAnimTime() const; + void SetAnimTime( float at ); + + float GetSimulationTime() const; + void SetSimulationTime( float st ); + + float GetCreateTime() { return m_flCreateTime; } + void SetCreateTime( float flCreateTime ) { m_flCreateTime = flCreateTime; } + + int GetCreationTick() const; + +#ifdef _DEBUG + void FunctionCheck( void *pFunction, const char *name ); + + ENTITYFUNCPTR TouchSet( ENTITYFUNCPTR func, char *name ) + { + //COMPILE_TIME_ASSERT( sizeof(func) == 4 ); + m_pfnTouch = func; + //FunctionCheck( *(reinterpret_cast<void **>(&m_pfnTouch)), name ); + return func; + } +#endif + + // Gets the model instance + shadow handle + virtual ModelInstanceHandle_t GetModelInstance() { return m_ModelInstance; } + void SetModelInstance( ModelInstanceHandle_t hInstance) { m_ModelInstance = hInstance; } + bool SnatchModelInstance( C_BaseEntity * pToEntity ); + virtual ClientShadowHandle_t GetShadowHandle() const { return m_ShadowHandle; } + virtual ClientRenderHandle_t& RenderHandle(); + + void CreateModelInstance(); + + // Sets the origin + angles to match the last position received + void MoveToLastReceivedPosition( bool force = false ); + + // Return the IHasAttributes interface for this base entity. Removes the need for: + // dynamic_cast< IHasAttributes * >( pEntity ); + // Which is remarkably slow. + // GetAttribInterface( CBaseEntity *pEntity ) in attribute_manager.h uses + // this function, tests for NULL, and Asserts m_pAttributes == dynamic_cast. + inline IHasAttributes *GetHasAttributesInterfacePtr() const { return m_pAttributes; } + +protected: + // NOTE: m_pAttributes needs to be set in the leaf class constructor. + IHasAttributes *m_pAttributes; + + // Only meant to be called from subclasses + void DestroyModelInstance(); + + // Interpolate entity + static void ProcessTeleportList(); + static void ProcessInterpolatedList(); + static void CheckInterpolatedVarParanoidMeasurement(); + + // overrideable rules if an entity should interpolate + virtual bool ShouldInterpolate(); + + // Call this in OnDataChanged if you don't chain it down! + void MarkMessageReceived(); + + // Gets the last message time + float GetLastMessageTime() const { return m_flLastMessageTime; } + + // For non-players + int PhysicsClipVelocity (const Vector& in, const Vector& normal, Vector& out, float overbounce ); + + // Allow entities to perform client-side fades + virtual unsigned char GetClientSideFade() { return 255; } + +protected: + // Two part guts of Interpolate(). Shared with C_BaseAnimating. + enum + { + INTERPOLATE_STOP=0, + INTERPOLATE_CONTINUE + }; + + // Returns INTERPOLATE_STOP or INTERPOLATE_CONTINUE. + // bNoMoreChanges is set to 1 if you can call RemoveFromInterpolationList on the entity. + int BaseInterpolatePart1( float ¤tTime, Vector &oldOrigin, QAngle &oldAngles, Vector &oldVel, int &bNoMoreChanges ); + void BaseInterpolatePart2( Vector &oldOrigin, QAngle &oldAngles, Vector &oldVel, int nChangeFlags ); + + +public: + // Accessors for above + static int GetPredictionRandomSeed( bool bUseUnSyncedServerPlatTime = false ); + static void SetPredictionRandomSeed( const CUserCmd *cmd ); + static C_BasePlayer *GetPredictionPlayer( void ); + static void SetPredictionPlayer( C_BasePlayer *player ); + static void CheckCLInterpChanged(); + + // Collision group accessors + int GetCollisionGroup() const; + void SetCollisionGroup( int collisionGroup ); + void CollisionRulesChanged(); + + static C_BaseEntity *Instance( int iEnt ); + // Doesn't do much, but helps with trace results + static C_BaseEntity *Instance( IClientEntity *ent ); + static C_BaseEntity *Instance( CBaseHandle hEnt ); + // For debugging shared code + static bool IsServer( void ); + static bool IsClient( void ); + static char const *GetDLLType( void ); + static void SetAbsQueriesValid( bool bValid ); + static bool IsAbsQueriesValid( void ); + + // Enable/disable abs recomputations on a stack. + static void PushEnableAbsRecomputations( bool bEnable ); + static void PopEnableAbsRecomputations(); + + // This requires the abs recomputation stack to be empty and just sets the global state. + // It should only be used at the scope of the frame loop. + static void EnableAbsRecomputations( bool bEnable ); + + static bool IsAbsRecomputationsEnabled( void ); + + + // Bloat the culling bbox past the parent ent's bbox in local space if EF_BONEMERGE_FASTCULL is set. + virtual void BoneMergeFastCullBloat( Vector &localMins, Vector &localMaxs, const Vector &thisEntityMins, const Vector &thisEntityMaxs ) const; + + + // Accessors for color. + const color32 GetRenderColor() const; + void SetRenderColor( byte r, byte g, byte b ); + void SetRenderColor( byte r, byte g, byte b, byte a ); + void SetRenderColorR( byte r ); + void SetRenderColorG( byte g ); + void SetRenderColorB( byte b ); + void SetRenderColorA( byte a ); + + void SetRenderMode( RenderMode_t nRenderMode, bool bForceUpdate = false ); + RenderMode_t GetRenderMode() const; + +public: + + // Determine what entity this corresponds to + int index; + + // Render information + unsigned char m_nRenderFX; + unsigned char m_nRenderFXBlend; + + // Entity flags that are only for the client (ENTCLIENTFLAG_ defines). + unsigned short m_EntClientFlags; + + CNetworkColor32( m_clrRender ); + +private: + + // Model for rendering + const model_t *model; + +public: + // Time animation sequence or frame was last changed + float m_flAnimTime; + float m_flOldAnimTime; + + float m_flSimulationTime; + float m_flOldSimulationTime; + + float m_flCreateTime; + + byte m_ubInterpolationFrame; + byte m_ubOldInterpolationFrame; + +private: + // Effects to apply + int m_fEffects; + unsigned char m_nRenderMode; + unsigned char m_nOldRenderMode; + +public: + // Used to store the state we were added to the BSP as, so it can + // reinsert the entity if the state changes. + ClientRenderHandle_t m_hRender; // link into spatial partition + + // Interpolation says don't draw yet + bool m_bReadyToDraw; + + // Should we be interpolating? + static bool IsInterpolationEnabled(); + + // Should we interpolate this tick? (Used to be EF_NOINTERP) + bool IsNoInterpolationFrame(); + + // + int m_nNextThinkTick; + int m_nLastThinkTick; + + // Object model index + short m_nModelIndex; + +#ifdef TF_CLIENT_DLL + int m_nModelIndexOverrides[MAX_VISION_MODES]; +#endif + + char m_takedamage; + char m_lifeState; + + int m_iHealth; + + // was pev->speed + float m_flSpeed; + + // Team Handling + int m_iTeamNum; + +#if !defined( NO_ENTITY_PREDICTION ) + // Certain entities (projectiles) can be created on the client + CPredictableId m_PredictableID; + PredictionContext *m_pPredictionContext; +#endif + + // used so we know when things are no longer touching + int touchStamp; + + // Called after predicted entity has been acknowledged so that no longer needed entity can + // be deleted + // Return true to force deletion right now, regardless of isbeingremoved + virtual bool OnPredictedEntityRemove( bool isbeingremoved, C_BaseEntity *predicted ); + + bool IsDormantPredictable( void ) const; + bool BecameDormantThisPacket( void ) const; + void SetDormantPredictable( bool dormant ); + + int GetWaterLevel() const; + void SetWaterLevel( int nLevel ); + int GetWaterType() const; + void SetWaterType( int nType ); + + float GetElasticity( void ) const; + + int GetTextureFrameIndex( void ); + void SetTextureFrameIndex( int iIndex ); + + virtual bool GetShadowCastDistance( float *pDist, ShadowType_t shadowType ) const; + virtual bool GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const; + virtual C_BaseEntity *GetShadowUseOtherEntity( void ) const; + virtual void SetShadowUseOtherEntity( C_BaseEntity *pEntity ); + + CInterpolatedVar< QAngle >& GetRotationInterpolator(); + CInterpolatedVar< Vector >& GetOriginInterpolator(); + virtual bool AddRagdollToFadeQueue( void ) { return true; } + + // Dirty bits + void MarkRenderHandleDirty(); + + // used by SourceTV since move-parents may be missing when child spawns. + void HierarchyUpdateMoveParent(); + + virtual bool IsDeflectable() { return false; } + + bool IsCombatCharacter() { return MyCombatCharacterPointer() == NULL ? false : true; } +protected: + int m_nFXComputeFrame; + + // FIXME: Should I move the functions handling these out of C_ClientEntity + // and into C_BaseEntity? Then we could make these private. + // Client handle + CBaseHandle m_RefEHandle; // Reference ehandle. Used to generate ehandles off this entity. + +private: + // Set by tools if this entity should route "info" to various tools listening to HTOOLENTITIES +#ifndef NO_TOOLFRAMEWORK + bool m_bEnabledInToolView; + bool m_bToolRecording; + HTOOLHANDLE m_ToolHandle; + int m_nLastRecordedFrame; + bool m_bRecordInTools; // should this entity be recorded in the tools (we exclude some things like models for menus) +#endif + +protected: + // pointer to the entity's physics object (vphysics.dll) + IPhysicsObject *m_pPhysicsObject; + +#if !defined( NO_ENTITY_PREDICTION ) + bool m_bPredictionEligible; +#endif + + int m_nSimulationTick; + + // Think contexts + int GetIndexForThinkContext( const char *pszContext ); + CUtlVector< thinkfunc_t > m_aThinkFunctions; + int m_iCurrentThinkContext; + + // Object eye position + Vector m_vecViewOffset; + +#if defined(SIXENSE) + Vector m_vecEyeOffset; + QAngle m_EyeAngleOffset; +#endif + // Allow studio models to tell us what their m_nBody value is + virtual int GetStudioBody( void ) { return 0; } + +public: + // This can be used to setup the entity as a client-only entity. It gets an entity handle, + // a render handle, and is put into the spatial partition. + bool InitializeAsClientEntityByIndex( int iIndex, RenderGroup_t renderGroup ); + + void TrackAngRotation( bool bTrack ); + +private: + friend void OnRenderStart(); + + // Figure out the smoothly interpolated origin for all server entities. Happens right before + // letting all entities simulate. + static void InterpolateServerEntities(); + + // Check which entities want to be drawn and add them to the leaf system. + static void AddVisibleEntities(); + + // For entities marked for recording, post bone messages to IToolSystems + static void ToolRecordEntities(); + + // Computes the base velocity + void UpdateBaseVelocity( void ); + + // Physics-related private methods + void PhysicsPusher( void ); + void PhysicsNone( void ); + void PhysicsNoclip( void ); + void PhysicsParent( void ); + void PhysicsStepRunTimestep( float timestep ); + void PhysicsToss( void ); + void PhysicsCustom( void ); + + // Simulation in local space of rigid children + void PhysicsRigidChild( void ); + + // Computes absolute position based on hierarchy + void CalcAbsolutePosition( ); + void CalcAbsoluteVelocity(); + + // Computes new angles based on the angular velocity + void SimulateAngles( float flFrameTime ); + + // Implement this if you use MOVETYPE_CUSTOM + virtual void PerformCustomPhysics( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity ); + + // methods related to decal adding + void AddStudioDecal( const Ray_t& ray, int hitbox, int decalIndex, bool doTrace, trace_t& tr, int maxLODToDecal = ADDDECAL_TO_ALL_LODS ); + void AddColoredStudioDecal( const Ray_t& ray, int hitbox, int decalIndex, bool doTrace, trace_t& tr, Color cColor, int maxLODToDecal ); + void AddBrushModelDecal( const Ray_t& ray, const Vector& decalCenter, int decalIndex, bool doTrace, trace_t& tr ); + + void ComputePackedOffsets( void ); + int ComputePackedSize_R( datamap_t *map ); + int GetIntermediateDataSize( void ); + + void UnlinkChild( C_BaseEntity *pParent, C_BaseEntity *pChild ); + void LinkChild( C_BaseEntity *pParent, C_BaseEntity *pChild ); + void HierarchySetParent( C_BaseEntity *pNewParent ); + void UnlinkFromHierarchy(); + + // Computes the water level + type + void UpdateWaterState(); + + // Checks a sweep without actually performing the move + void PhysicsCheckSweep( const Vector& vecAbsStart, const Vector &vecAbsDelta, trace_t *pTrace ); + + // FIXME: REMOVE!!! + void MoveToAimEnt( ); + + // Sets/Gets the next think based on context index + void SetNextThink( int nContextIndex, float thinkTime ); + void SetLastThink( int nContextIndex, float thinkTime ); + float GetNextThink( int nContextIndex ) const; + int GetNextThinkTick( int nContextIndex ) const; + + // Object velocity + Vector m_vecVelocity; + CInterpolatedVar< Vector > m_iv_vecVelocity; + + Vector m_vecAbsVelocity; + + // was pev->avelocity + QAngle m_vecAngVelocity; + +// QAngle m_vecAbsAngVelocity; + +#if !defined( NO_ENTITY_PREDICTION ) + // It's still in the list for "fixup purposes" and simulation, but don't try to render it any more... + bool m_bDormantPredictable; + + // So we can clean it up + int m_nIncomingPacketEntityBecameDormant; +#endif + + // The spawn time of the entity + float m_flSpawnTime; + + // Timestamp of message arrival + float m_flLastMessageTime; + + // Base velocity + Vector m_vecBaseVelocity; + + // Gravity multiplier + float m_flGravity; + + // Model instance data.. + ModelInstanceHandle_t m_ModelInstance; + + // Shadow data + ClientShadowHandle_t m_ShadowHandle; + + // A random value used by material proxies for each model instance. + float m_flProxyRandomValue; + + ClientThinkHandle_t m_hThink; + + int m_iEFlags; // entity flags EFL_* + + // Object movetype + unsigned char m_MoveType; + unsigned char m_MoveCollide; + unsigned char m_iParentAttachment; // 0 if we're relative to the parent's absorigin and absangles. + unsigned char m_iOldParentAttachment; + + unsigned char m_nWaterLevel; + unsigned char m_nWaterType; + // For client/server entities, true if the entity goes outside the PVS. + // Unused for client only entities. + bool m_bDormant; + // Prediction system + bool m_bPredictable; + + + // Hierarchy + CHandle<C_BaseEntity> m_pMoveParent; + CHandle<C_BaseEntity> m_pMoveChild; + CHandle<C_BaseEntity> m_pMovePeer; + CHandle<C_BaseEntity> m_pMovePrevPeer; + + // The moveparent received from networking data + CHandle<C_BaseEntity> m_hNetworkMoveParent; + CHandle<C_BaseEntity> m_hOldMoveParent; + + string_t m_ModelName; + + CNetworkVarEmbedded( CCollisionProperty, m_Collision ); + CNetworkVarEmbedded( CParticleProperty, m_Particles ); + + // Physics state + float m_flElasticity; + + float m_flShadowCastDistance; + EHANDLE m_ShadowDirUseOtherEntity; + + EHANDLE m_hGroundEntity; + float m_flGroundChangeTime; + + + // Friction. + float m_flFriction; + + Vector m_vecAbsOrigin; + + // Object orientation + QAngle m_angAbsRotation; + + Vector m_vecOldOrigin; + QAngle m_vecOldAngRotation; + + Vector m_vecOrigin; + CInterpolatedVar< Vector > m_iv_vecOrigin; + QAngle m_angRotation; + CInterpolatedVar< QAngle > m_iv_angRotation; + + // Specifies the entity-to-world transform + matrix3x4_t m_rgflCoordinateFrame; + + // Last values to come over the wire. Used for interpolation. + Vector m_vecNetworkOrigin; + QAngle m_angNetworkAngles; + + // Behavior flags + int m_fFlags; + + // used to cull collision tests + int m_CollisionGroup; + +#if !defined( NO_ENTITY_PREDICTION ) + // For storing prediction results and pristine network state + byte *m_pIntermediateData[ MULTIPLAYER_BACKUP ]; + byte *m_pOriginalData; + int m_nIntermediateDataCount; + + bool m_bIsPlayerSimulated; +#endif + + CNetworkVar( bool, m_bSimulatedEveryTick ); + CNetworkVar( bool, m_bAnimatedEveryTick ); + CNetworkVar( bool, m_bAlternateSorting ); + + //Adrian + unsigned char m_iTextureFrameIndex; + + // Bbox visualization + unsigned char m_fBBoxVisFlags; + + // The list that holds OnDataChanged events uses this to make sure we don't get multiple + // OnDataChanged calls in the same frame if the client receives multiple packets. + int m_DataChangeEventRef; + +#if !defined( NO_ENTITY_PREDICTION ) + // Player who is driving my simulation + CHandle< CBasePlayer > m_hPlayerSimulationOwner; +#endif + + // The owner! + EHANDLE m_hOwnerEntity; + EHANDLE m_hEffectEntity; + + // This is a random seed used by the networking code to allow client - side prediction code + // randon number generators to spit out the same random numbers on both sides for a particular + // usercmd input. + static int m_nPredictionRandomSeed; + static C_BasePlayer *m_pPredictionPlayer; + static bool s_bAbsQueriesValid; + static bool s_bAbsRecomputationEnabled; + + static bool s_bInterpolate; + + int m_fDataObjectTypes; + + AimEntsListHandle_t m_AimEntsListHandle; + int m_nCreationTick; + + +public: + float m_fRenderingClipPlane[4]; //world space clip plane when drawing + bool m_bEnableRenderingClipPlane; //true to use the custom clip plane when drawing + float * GetRenderClipPlane( void ); // Rendering clip plane, should be 4 floats, return value of NULL indicates a disabled render clip plane + +protected: + + void AddToInterpolationList(); + void RemoveFromInterpolationList(); + unsigned short m_InterpolationListEntry; // Entry into g_InterpolationList (or g_InterpolationList.InvalidIndex if not in the list). + + void AddToTeleportList(); + void RemoveFromTeleportList(); + unsigned short m_TeleportListEntry; + + CThreadFastMutex m_CalcAbsolutePositionMutex; + CThreadFastMutex m_CalcAbsoluteVelocityMutex; + +#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. +public: + virtual bool ValidateEntityAttachedToPlayer( bool &bShouldRetry ); + bool EntityDeemedInvalid( void ) { return (m_bValidatedOwner && m_bDeemedInvalid); } +protected: + bool m_bValidatedOwner; + bool m_bDeemedInvalid; + bool m_bWasDeemedInvalid; + RenderMode_t m_PreviousRenderMode; + color32 m_PreviousRenderColor; +#endif + +private: + bool m_bOldShouldDraw; +}; + +EXTERN_RECV_TABLE(DT_BaseEntity); + +inline bool FClassnameIs( C_BaseEntity *pEntity, const char *szClassname ) +{ + Assert( pEntity ); + if ( pEntity == NULL ) + return false; + + return !strcmp( pEntity->GetClassname(), szClassname ) ? true : false; +} + +#define SetThink( a ) ThinkSet( static_cast <void (CBaseEntity::*)(void)> (a), 0, NULL ) +#define SetContextThink( a, b, context ) ThinkSet( static_cast <void (CBaseEntity::*)(void)> (a), (b), context ) + +#ifdef _DEBUG +#define SetTouch( a ) TouchSet( static_cast <void (C_BaseEntity::*)(C_BaseEntity *)> (a), #a ) + +#else +#define SetTouch( a ) m_pfnTouch = static_cast <void (C_BaseEntity::*)(C_BaseEntity *)> (a) + +#endif + + +//----------------------------------------------------------------------------- +// An inline version the game code can use +//----------------------------------------------------------------------------- +inline CCollisionProperty *C_BaseEntity::CollisionProp() +{ + return &m_Collision; +} + +inline const CCollisionProperty *C_BaseEntity::CollisionProp() const +{ + return &m_Collision; +} + +//----------------------------------------------------------------------------- +// An inline version the game code can use +//----------------------------------------------------------------------------- +inline CParticleProperty *C_BaseEntity::ParticleProp() +{ + return &m_Particles; +} + +inline const CParticleProperty *C_BaseEntity::ParticleProp() const +{ + return &m_Particles; +} + +//----------------------------------------------------------------------------- +// Purpose: Returns whether this entity was created on the client. +//----------------------------------------------------------------------------- +inline bool C_BaseEntity::IsServerEntity( void ) +{ + return index != -1; +} + +//----------------------------------------------------------------------------- +// Inline methods +//----------------------------------------------------------------------------- +inline matrix3x4_t &C_BaseEntity::EntityToWorldTransform() +{ + Assert( s_bAbsQueriesValid ); + CalcAbsolutePosition(); + return m_rgflCoordinateFrame; +} + +inline const matrix3x4_t &C_BaseEntity::EntityToWorldTransform() const +{ + Assert( s_bAbsQueriesValid ); + const_cast<C_BaseEntity*>(this)->CalcAbsolutePosition(); + return m_rgflCoordinateFrame; +} + +inline const Vector& C_BaseEntity::GetNetworkOrigin() const +{ + return m_vecNetworkOrigin; +} + +inline const QAngle& C_BaseEntity::GetNetworkAngles() const +{ + return m_angNetworkAngles; +} + +inline const model_t *C_BaseEntity::GetModel( void ) const +{ + return model; +} + +inline int C_BaseEntity::GetModelIndex( void ) const +{ + return m_nModelIndex; +} + +//----------------------------------------------------------------------------- +// Some helper methods that transform a point from entity space to world space + back +//----------------------------------------------------------------------------- +inline void C_BaseEntity::EntityToWorldSpace( const Vector &in, Vector *pOut ) const +{ + if ( GetAbsAngles() == vec3_angle ) + { + VectorAdd( in, GetAbsOrigin(), *pOut ); + } + else + { + VectorTransform( in, EntityToWorldTransform(), *pOut ); + } +} + +inline void C_BaseEntity::WorldToEntitySpace( const Vector &in, Vector *pOut ) const +{ + if ( GetAbsAngles() == vec3_angle ) + { + VectorSubtract( in, GetAbsOrigin(), *pOut ); + } + else + { + VectorITransform( in, EntityToWorldTransform(), *pOut ); + } +} + +inline const Vector &C_BaseEntity::GetAbsVelocity( ) const +{ + Assert( s_bAbsQueriesValid ); + const_cast<C_BaseEntity*>(this)->CalcAbsoluteVelocity(); + return m_vecAbsVelocity; +} + +inline C_BaseEntity *C_BaseEntity::Instance( IClientEntity *ent ) +{ + return ent ? ent->GetBaseEntity() : NULL; +} + +// For debugging shared code +inline bool C_BaseEntity::IsServer( void ) +{ + return false; +} + +inline bool C_BaseEntity::IsClient( void ) +{ + return true; +} + +inline const char *C_BaseEntity::GetDLLType( void ) +{ + return "client"; +} + + +//----------------------------------------------------------------------------- +// Methods relating to solid type + flags +//----------------------------------------------------------------------------- +inline void C_BaseEntity::SetSolidFlags( int nFlags ) +{ + CollisionProp()->SetSolidFlags( nFlags ); +} + +inline bool C_BaseEntity::IsSolidFlagSet( int flagMask ) const +{ + return CollisionProp()->IsSolidFlagSet( flagMask ); +} + +inline int C_BaseEntity::GetSolidFlags( void ) const +{ + return CollisionProp()->GetSolidFlags( ); +} + +inline void C_BaseEntity::AddSolidFlags( int nFlags ) +{ + CollisionProp()->AddSolidFlags( nFlags ); +} + +inline void C_BaseEntity::RemoveSolidFlags( int nFlags ) +{ + CollisionProp()->RemoveSolidFlags( nFlags ); +} + +inline bool C_BaseEntity::IsSolid() const +{ + return CollisionProp()->IsSolid( ); +} + +inline void C_BaseEntity::SetSolid( SolidType_t val ) +{ + CollisionProp()->SetSolid( val ); +} + +inline SolidType_t C_BaseEntity::GetSolid( ) const +{ + return CollisionProp()->GetSolid( ); +} + +inline void C_BaseEntity::SetCollisionBounds( const Vector& mins, const Vector &maxs ) +{ + CollisionProp()->SetCollisionBounds( mins, maxs ); +} + + +//----------------------------------------------------------------------------- +// Methods relating to bounds +//----------------------------------------------------------------------------- +inline const Vector& C_BaseEntity::WorldAlignMins( ) const +{ + Assert( !CollisionProp()->IsBoundsDefinedInEntitySpace() ); + Assert( CollisionProp()->GetCollisionAngles() == vec3_angle ); + return CollisionProp()->OBBMins(); +} + +inline const Vector& C_BaseEntity::WorldAlignMaxs( ) const +{ + Assert( !CollisionProp()->IsBoundsDefinedInEntitySpace() ); + Assert( CollisionProp()->GetCollisionAngles() == vec3_angle ); + return CollisionProp()->OBBMaxs(); +} + +inline const Vector& C_BaseEntity::WorldAlignSize( ) const +{ + Assert( !CollisionProp()->IsBoundsDefinedInEntitySpace() ); + Assert( CollisionProp()->GetCollisionAngles() == vec3_angle ); + return CollisionProp()->OBBSize(); +} + +inline float CBaseEntity::BoundingRadius() const +{ + return CollisionProp()->BoundingRadius(); +} + +inline bool CBaseEntity::IsPointSized() const +{ + return CollisionProp()->BoundingRadius() == 0.0f; +} + + +//----------------------------------------------------------------------------- +// Methods relating to traversing hierarchy +//----------------------------------------------------------------------------- +inline C_BaseEntity *C_BaseEntity::GetMoveParent( void ) const +{ + return m_pMoveParent; +} + +inline C_BaseEntity *C_BaseEntity::FirstMoveChild( void ) const +{ + return m_pMoveChild; +} + +inline C_BaseEntity *C_BaseEntity::NextMovePeer( void ) const +{ + return m_pMovePeer; +} + +//----------------------------------------------------------------------------- +// Velocity +//----------------------------------------------------------------------------- +inline const Vector& C_BaseEntity::GetLocalVelocity() const +{ + return m_vecVelocity; +} + +inline const QAngle& C_BaseEntity::GetLocalAngularVelocity( ) const +{ + return m_vecAngVelocity; +} + +inline const Vector& C_BaseEntity::GetBaseVelocity() const +{ + return m_vecBaseVelocity; +} + +inline void C_BaseEntity::SetBaseVelocity( const Vector& v ) +{ + m_vecBaseVelocity = v; +} + +inline void C_BaseEntity::SetFriction( float flFriction ) +{ + m_flFriction = flFriction; +} + +inline void C_BaseEntity::SetGravity( float flGravity ) +{ + m_flGravity = flGravity; +} + +inline float C_BaseEntity::GetGravity( void ) const +{ + return m_flGravity; +} + +inline int C_BaseEntity::GetWaterLevel() const +{ + return m_nWaterLevel; +} + +inline void C_BaseEntity::SetWaterLevel( int nLevel ) +{ + m_nWaterLevel = nLevel; +} + +inline float C_BaseEntity::GetElasticity( void ) const +{ + return m_flElasticity; +} + +inline const color32 CBaseEntity::GetRenderColor() const +{ + return m_clrRender.Get(); +} + +inline void C_BaseEntity::SetRenderColor( byte r, byte g, byte b ) +{ + color32 clr = { r, g, b, m_clrRender->a }; + m_clrRender = clr; +} + +inline void C_BaseEntity::SetRenderColor( byte r, byte g, byte b, byte a ) +{ + color32 clr = { r, g, b, a }; + m_clrRender = clr; +} + +inline void C_BaseEntity::SetRenderColorR( byte r ) +{ + SetRenderColor( r, GetRenderColor().g, GetRenderColor().b ); +} + +inline void C_BaseEntity::SetRenderColorG( byte g ) +{ + SetRenderColor( GetRenderColor().r, g, GetRenderColor().b ); +} + +inline void C_BaseEntity::SetRenderColorB( byte b ) +{ + SetRenderColor( GetRenderColor().r, GetRenderColor().g, b ); +} + +inline void C_BaseEntity::SetRenderColorA( byte a ) +{ + SetRenderColor( GetRenderColor().r, GetRenderColor().g, GetRenderColor().b, a ); +} + +inline RenderMode_t CBaseEntity::GetRenderMode() const +{ + return (RenderMode_t)m_nRenderMode; +} + +//----------------------------------------------------------------------------- +// checks to see if the entity is marked for deletion +//----------------------------------------------------------------------------- +inline bool C_BaseEntity::IsMarkedForDeletion( void ) +{ + return (m_iEFlags & EFL_KILLME); +} + +inline void C_BaseEntity::AddEFlags( int nEFlagMask ) +{ + m_iEFlags |= nEFlagMask; +} + +inline void C_BaseEntity::RemoveEFlags( int nEFlagMask ) +{ + m_iEFlags &= ~nEFlagMask; +} + +inline bool CBaseEntity::IsEFlagSet( int nEFlagMask ) const +{ + return (m_iEFlags & nEFlagMask) != 0; +} + +inline unsigned char CBaseEntity::GetParentAttachment() const +{ + return m_iParentAttachment; +} + +inline ClientRenderHandle_t CBaseEntity::GetRenderHandle() const +{ + return m_hRender; +} + +inline ClientRenderHandle_t& CBaseEntity::RenderHandle() +{ + return m_hRender; +} + +#ifdef SIXENSE + +inline const Vector& CBaseEntity::GetEyeOffset() const +{ + return m_vecEyeOffset; +} + +inline void CBaseEntity::SetEyeOffset( const Vector& v ) +{ + m_vecEyeOffset = v; +} + +inline const QAngle & CBaseEntity::GetEyeAngleOffset() const +{ + return m_EyeAngleOffset; +} + +inline void CBaseEntity::SetEyeAngleOffset( const QAngle & qa ) +{ + m_EyeAngleOffset = qa; +} + +#endif + +//----------------------------------------------------------------------------- +// Methods to cast away const +//----------------------------------------------------------------------------- +inline Vector C_BaseEntity::EyePosition( void ) const +{ + return const_cast<C_BaseEntity*>(this)->EyePosition(); +} + +inline const QAngle &C_BaseEntity::EyeAngles( void ) const // Direction of eyes in world space +{ + return const_cast<C_BaseEntity*>(this)->EyeAngles(); +} + +inline const QAngle &C_BaseEntity::LocalEyeAngles( void ) const // Direction of eyes +{ + return const_cast<C_BaseEntity*>(this)->LocalEyeAngles(); +} + +inline Vector C_BaseEntity::EarPosition( void ) const // position of ears +{ + return const_cast<C_BaseEntity*>(this)->EarPosition(); +} + +inline VarMapping_t* C_BaseEntity::GetVarMapping() +{ + return &m_VarMap; +} + +//----------------------------------------------------------------------------- +// Should we be interpolating? +//----------------------------------------------------------------------------- +inline bool C_BaseEntity::IsInterpolationEnabled() +{ + return s_bInterpolate; +} + +//----------------------------------------------------------------------------- +// Should we be interpolating during this frame? (was EF_NOINTERP) +//----------------------------------------------------------------------------- +inline bool C_BaseEntity::IsNoInterpolationFrame() +{ + return m_ubOldInterpolationFrame != m_ubInterpolationFrame; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : handle - +// Output : inline void +//----------------------------------------------------------------------------- +inline void C_BaseEntity::SetToolHandle( HTOOLHANDLE handle ) +{ +#ifndef NO_TOOLFRAMEWORK + m_ToolHandle = handle; +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : - +// Output : inline HTOOLHANDLE +//----------------------------------------------------------------------------- +inline HTOOLHANDLE C_BaseEntity::GetToolHandle() const +{ +#ifndef NO_TOOLFRAMEWORK + return m_ToolHandle; +#else + return (HTOOLHANDLE)0; +#endif +} + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +inline bool C_BaseEntity::IsEnabledInToolView() const +{ +#ifndef NO_TOOLFRAMEWORK + return m_bEnabledInToolView; +#else + return false; +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : - +// Output : inline bool +//----------------------------------------------------------------------------- +inline bool C_BaseEntity::ShouldRecordInTools() const +{ +#ifndef NO_TOOLFRAMEWORK + return m_bRecordInTools; +#else + return true; +#endif +} + +C_BaseEntity *CreateEntityByName( const char *className ); + +#endif // C_BASEENTITY_H |