//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // //=============================================================================// #ifndef BASEANIMATING_H #define BASEANIMATING_H #ifdef _WIN32 #pragma once #endif #include "baseentity.h" #include "entityoutput.h" #include "studio.h" #include "datacache/idatacache.h" #include "tier0/threadtools.h" struct animevent_t; struct matrix3x4_t; class CIKContext; class KeyValues; FORWARD_DECLARE_HANDLE( memhandle_t ); #define BCF_NO_ANIMATION_SKIP ( 1 << 0 ) // Do not allow PVS animation skipping (mostly for attachments being critical to an entity) #define BCF_IS_IN_SPAWN ( 1 << 1 ) // Is currently inside of spawn, always evaluate animations class CBaseAnimating : public CBaseEntity { public: DECLARE_CLASS( CBaseAnimating, CBaseEntity ); CBaseAnimating(); ~CBaseAnimating(); DECLARE_PREDICTABLE(); enum { NUM_POSEPAREMETERS = 24, NUM_BONECTRLS = 4 }; DECLARE_DATADESC(); DECLARE_SERVERCLASS(); virtual void SetModel( const char *szModelName ); virtual void Activate(); virtual void Spawn(); virtual void Precache(); virtual void SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways ); virtual int Restore( IRestore &restore ); virtual void OnRestore(); CStudioHdr *GetModelPtr( void ); void InvalidateMdlCache(); virtual CStudioHdr *OnNewModel(); virtual CBaseAnimating* GetBaseAnimating() { return this; } // Cycle access void SetCycle( float flCycle ); float GetCycle() const; float GetAnimTimeInterval( void ) const; // Call this in your constructor to tell it that you will not use animtime. Then the // interpolation will be done correctly on the client. // This defaults to off. void UseClientSideAnimation(); // Tells whether or not we're using client-side animation. Used for controlling // the transmission of animtime. bool IsUsingClientSideAnimation() { return m_bClientSideAnimation; } // Basic NPC Animation functions virtual float GetIdealSpeed( ) const; virtual float GetIdealAccel( ) const; virtual void StudioFrameAdvance(); // advance animation frame to some time in the future void StudioFrameAdvanceManual( float flInterval ); bool IsValidSequence( int iSequence ); inline float GetPlaybackRate(); inline void SetPlaybackRate( float rate ); inline int GetSequence() { return m_nSequence; } virtual void SetSequence(int nSequence); /* inline */ void ResetSequence(int nSequence); // FIXME: push transitions support down into CBaseAnimating? virtual bool IsActivityFinished( void ) { return m_bSequenceFinished; } inline bool IsSequenceFinished( void ) { return m_bSequenceFinished; } inline bool SequenceLoops( void ) { return m_bSequenceLoops; } bool IsSequenceLooping( CStudioHdr *pStudioHdr, int iSequence ); inline bool IsSequenceLooping( int iSequence ) { return IsSequenceLooping(GetModelPtr(),iSequence); } inline float SequenceDuration( void ) { return SequenceDuration( m_nSequence ); } float SequenceDuration( CStudioHdr *pStudioHdr, int iSequence ); inline float SequenceDuration( int iSequence ) { return SequenceDuration(GetModelPtr(), iSequence); } float GetSequenceCycleRate( CStudioHdr *pStudioHdr, int iSequence ); inline float GetSequenceCycleRate( int iSequence ) { return GetSequenceCycleRate(GetModelPtr(),iSequence); } float GetLastVisibleCycle( CStudioHdr *pStudioHdr, int iSequence ); virtual float GetSequenceGroundSpeed( CStudioHdr *pStudioHdr, int iSequence ); inline float GetSequenceGroundSpeed( int iSequence ) { return GetSequenceGroundSpeed(GetModelPtr(), iSequence); } void ResetActivityIndexes ( void ); void ResetEventIndexes ( void ); int SelectWeightedSequence ( Activity activity ); int SelectWeightedSequence ( Activity activity, int curSequence ); int SelectHeaviestSequence ( Activity activity ); int LookupActivity( const char *label ); int LookupSequence ( const char *label ); KeyValues *GetSequenceKeyValues( int iSequence ); float GetSequenceMoveYaw( int iSequence ); float GetSequenceMoveDist( CStudioHdr *pStudioHdr, int iSequence ); inline float GetSequenceMoveDist( int iSequence ) { return GetSequenceMoveDist(GetModelPtr(),iSequence);} void GetSequenceLinearMotion( int iSequence, Vector *pVec ); const char *GetSequenceName( int iSequence ); const char *GetSequenceActivityName( int iSequence ); Activity GetSequenceActivity( int iSequence ); void ResetSequenceInfo ( ); // This will stop animation until you call ResetSequenceInfo() at some point in the future inline void StopAnimation( void ) { m_flPlaybackRate = 0; } virtual void ClampRagdollForce( const Vector &vecForceIn, Vector *vecForceOut ) { *vecForceOut = vecForceIn; } // Base class does nothing. virtual bool BecomeRagdollOnClient( const Vector &force ); virtual bool IsRagdoll(); virtual bool CanBecomeRagdoll( void ); //Check if this entity will ragdoll when dead. virtual void GetSkeleton( CStudioHdr *pStudioHdr, Vector pos[], Quaternion q[], int boneMask ); virtual void GetBoneTransform( int iBone, matrix3x4_t &pBoneToWorld ); virtual void SetupBones( matrix3x4_t *pBoneToWorld, int boneMask ); virtual void CalculateIKLocks( float currentTime ); virtual void Teleport( const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity ); bool HasAnimEvent( int nSequence, int nEvent ); virtual void DispatchAnimEvents ( CBaseAnimating *eventHandler ); // Handle events that have happend since last time called up until X seconds into the future virtual void HandleAnimEvent( animevent_t *pEvent ); int LookupPoseParameter( CStudioHdr *pStudioHdr, const char *szName ); inline int LookupPoseParameter( const char *szName ) { return LookupPoseParameter(GetModelPtr(), szName); } float SetPoseParameter( CStudioHdr *pStudioHdr, const char *szName, float flValue ); inline float SetPoseParameter( const char *szName, float flValue ) { return SetPoseParameter( GetModelPtr(), szName, flValue ); } float SetPoseParameter( CStudioHdr *pStudioHdr, int iParameter, float flValue ); inline float SetPoseParameter( int iParameter, float flValue ) { return SetPoseParameter( GetModelPtr(), iParameter, flValue ); } float GetPoseParameter( const char *szName ); float GetPoseParameter( int iParameter ); bool GetPoseParameterRange( int index, float &minValue, float &maxValue ); bool HasPoseParameter( int iSequence, const char *szName ); bool HasPoseParameter( int iSequence, int iParameter ); float EdgeLimitPoseParameter( int iParameter, float flValue, float flBase = 0.0f ); protected: // The modus operandi for pose parameters is that you should not use the const char * version of the functions // in general code -- it causes many many string comparisons, which is slower than you think. Better is to // save off your pose parameters in member variables in your derivation of this function: virtual void PopulatePoseParameters( void ); public: int LookupBone( const char *szName ); void GetBonePosition( const char *szName, Vector &origin, QAngle &angles ); void GetBonePosition( int iBone, Vector &origin, QAngle &angles ); int GetPhysicsBone( int boneIndex ); int GetNumBones ( void ); int FindTransitionSequence( int iCurrentSequence, int iGoalSequence, int *piDir ); bool GotoSequence( int iCurrentSequence, float flCurrentCycle, float flCurrentRate, int iGoalSequence, int &iNextSequence, float &flCycle, int &iDir ); int GetEntryNode( int iSequence ); int GetExitNode( int iSequence ); void GetEyeballs( Vector &origin, QAngle &angles ); // ?? remove ?? int LookupAttachment( const char *szName ); // These return the attachment in world space bool GetAttachment( const char *szName, Vector &absOrigin, QAngle &absAngles ); bool GetAttachment( int iAttachment, Vector &absOrigin, QAngle &absAngles ); int GetAttachmentBone( int iAttachment ); virtual bool GetAttachment( int iAttachment, matrix3x4_t &attachmentToWorld ); // These return the attachment in the space of the entity bool GetAttachmentLocal( const char *szName, Vector &origin, QAngle &angles ); bool GetAttachmentLocal( int iAttachment, Vector &origin, QAngle &angles ); bool GetAttachmentLocal( int iAttachment, matrix3x4_t &attachmentToLocal ); // Non-angle versions of the attachments in world space bool GetAttachment( const char *szName, Vector &absOrigin, Vector *forward = NULL, Vector *right = NULL, Vector *up = NULL ); bool GetAttachment( int iAttachment, Vector &absOrigin, Vector *forward = NULL, Vector *right = NULL, Vector *up = NULL ); void SetBodygroup( int iGroup, int iValue ); int GetBodygroup( int iGroup ); const char *GetBodygroupName( int iGroup ); int FindBodygroupByName( const char *name ); int GetBodygroupCount( int iGroup ); int GetNumBodyGroups( void ); void SetHitboxSet( int setnum ); void SetHitboxSetByName( const char *setname ); int GetHitboxSet( void ); char const *GetHitboxSetName( void ); int GetHitboxSetCount( void ); int GetHitboxBone( int hitboxIndex ); bool LookupHitbox( const char *szName, int& outSet, int& outBox ); // Computes a box that surrounds all hitboxes bool ComputeHitboxSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs ); bool ComputeEntitySpaceHitboxSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs ); // Clone a CBaseAnimating from another (copies model & sequence data) void CopyAnimationDataFrom( CBaseAnimating *pSource ); int ExtractBbox( int sequence, Vector& mins, Vector& maxs ); void SetSequenceBox( void ); int RegisterPrivateActivity( const char *pszActivityName ); void ResetClientsideFrame( void ); // Controllers. virtual void InitBoneControllers ( void ); // Return's the controller's angle/position in bone space. float GetBoneController ( int iController ); // Maps the angle/position value you specify into the bone's start/end and sets the specified controller to the value. float SetBoneController ( int iController, float flValue ); void GetVelocity(Vector *vVelocity, AngularImpulse *vAngVelocity); // these two need to move somewhere else LocalFlexController_t GetNumFlexControllers( void ); const char *GetFlexDescFacs( int iFlexDesc ); const char *GetFlexControllerName( LocalFlexController_t iFlexController ); const char *GetFlexControllerType( LocalFlexController_t iFlexController ); virtual Vector GetGroundSpeedVelocity( void ); bool GetIntervalMovement( float flIntervalUsed, bool &bMoveSeqFinished, Vector &newPosition, QAngle &newAngles ); bool GetSequenceMovement( int nSequence, float fromCycle, float toCycle, Vector &deltaPosition, QAngle &deltaAngles ); float GetInstantaneousVelocity( float flInterval = 0.0 ); float GetEntryVelocity( int iSequence ); float GetExitVelocity( int iSequence ); float GetMovementFrame( float flDist ); bool HasMovement( int iSequence ); void ReportMissingActivity( int iActivity ); 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 ); class CBoneCache *GetBoneCache( void ); void InvalidateBoneCache(); void InvalidateBoneCacheIfOlderThan( float deltaTime ); virtual int DrawDebugTextOverlays( void ); // See note in code re: bandwidth usage!!! void DrawServerHitboxes( float duration = 0.0f, bool monocolor = false ); void DrawRawSkeleton( matrix3x4_t boneToWorld[], int boneMask, bool noDepthTest = true, float duration = 0.0f, bool monocolor = false ); void SetModelScale( float scale, float change_duration = 0.0f ); float GetModelScale() const { return m_flModelScale; } void UpdateModelScale(); virtual void RefreshCollisionBounds( void ); // also calculate IK on server? (always done on client) void EnableServerIK(); void DisableServerIK(); // for ragdoll vs. car int GetHitboxesFrontside( int *boxList, int boxMax, const Vector &normal, float dist ); void GetInputDispatchEffectPosition( const char *sInputString, Vector &pOrigin, QAngle &pAngles ); virtual void ModifyOrAppendCriteria( AI_CriteriaSet& set ); // Send a muzzle flash event to the client for this entity. void DoMuzzleFlash(); // Fire virtual void Ignite( float flFlameLifetime, bool bNPCOnly = true, float flSize = 0.0f, bool bCalledByLevelDesigner = false ); virtual void IgniteLifetime( float flFlameLifetime ); virtual void IgniteNumHitboxFires( int iNumHitBoxFires ); virtual void IgniteHitboxFireScale( float flHitboxFireScale ); virtual void Extinguish() { RemoveFlag( FL_ONFIRE ); } bool IsOnFire() { return ( (GetFlags() & FL_ONFIRE) != 0 ); } void Scorch( int rate, int floor ); void InputIgnite( inputdata_t &inputdata ); void InputIgniteLifetime( inputdata_t &inputdata ); void InputIgniteNumHitboxFires( inputdata_t &inputdata ); void InputIgniteHitboxFireScale( inputdata_t &inputdata ); void InputBecomeRagdoll( inputdata_t &inputdata ); // Dissolve, returns true if the ragdoll has been created bool Dissolve( const char *pMaterialName, float flStartTime, bool bNPCOnly = true, int nDissolveType = 0, Vector vDissolverOrigin = vec3_origin, int iMagnitude = 0 ); bool IsDissolving() { return ( (GetFlags() & FL_DISSOLVING) != 0 ); } void TransferDissolveFrom( CBaseAnimating *pAnim ); // animation needs float m_flGroundSpeed; // computed linear movement rate for current sequence float m_flLastEventCheck; // cycle index of when events were last checked virtual void SetLightingOriginRelative( CBaseEntity *pLightingOriginRelative ); void SetLightingOriginRelative( string_t strLightingOriginRelative ); CBaseEntity *GetLightingOriginRelative(); virtual void SetLightingOrigin( CBaseEntity *pLightingOrigin ); void SetLightingOrigin( string_t strLightingOrigin ); CBaseEntity *GetLightingOrigin(); const float* GetPoseParameterArray() { return m_flPoseParameter.Base(); } const float* GetEncodedControllerArray() { return m_flEncodedController.Base(); } void BuildMatricesWithBoneMerge( const CStudioHdr *pStudioHdr, const QAngle& angles, const Vector& origin, const Vector pos[MAXSTUDIOBONES], const Quaternion q[MAXSTUDIOBONES], matrix3x4_t bonetoworld[MAXSTUDIOBONES], CBaseAnimating *pParent, CBoneCache *pParentCache ); void SetFadeDistance( float minFadeDist, float maxFadeDist ); int GetBoneCacheFlags( void ) { return m_fBoneCacheFlags; } inline void SetBoneCacheFlags( unsigned short fFlag ) { m_fBoneCacheFlags |= fFlag; } inline void ClearBoneCacheFlags( unsigned short fFlag ) { m_fBoneCacheFlags &= ~fFlag; } bool PrefetchSequence( int iSequence ); private: void LockStudioHdr(); void UnlockStudioHdr(); void StudioFrameAdvanceInternal( CStudioHdr *pStudioHdr, float flInterval ); void InputSetLightingOriginRelative( inputdata_t &inputdata ); void InputSetLightingOrigin( inputdata_t &inputdata ); void InputSetModelScale( inputdata_t &inputdata ); bool CanSkipAnimation( void ); public: CNetworkVar( int, m_nForceBone ); CNetworkVector( m_vecForce ); CNetworkVar( int, m_nSkin ); CNetworkVar( int, m_nBody ); CNetworkVar( int, m_nHitboxSet ); // For making things thin during barnacle swallowing, e.g. CNetworkVar( float, m_flModelScale ); // was pev->framerate CNetworkVar( float, m_flPlaybackRate ); public: void InitStepHeightAdjust( void ); void SetIKGroundContactInfo( float minHeight, float maxHeight ); void UpdateStepOrigin( void ); protected: float m_flIKGroundContactTime; float m_flIKGroundMinHeight; float m_flIKGroundMaxHeight; float m_flEstIkFloor; // debounced float m_flEstIkOffset; CIKContext *m_pIk; int m_iIKCounter; public: Vector GetStepOrigin( void ) const; QAngle GetStepAngles( void ) const; private: bool m_bSequenceFinished;// flag set when StudioAdvanceFrame moves across a frame boundry bool m_bSequenceLoops; // true if the sequence loops bool m_bResetSequenceInfoOnLoad; // true if a ResetSequenceInfo was queued up during dynamic load float m_flDissolveStartTime; // was pev->frame CNetworkVar( float, m_flCycle ); CNetworkVar( int, m_nSequence ); CNetworkArray( float, m_flPoseParameter, NUM_POSEPAREMETERS ); // must be private so manual mode works! CNetworkArray( float, m_flEncodedController, NUM_BONECTRLS ); // bone controller setting (0..1) // Client-side animation (useful for looping animation objects) CNetworkVar( bool, m_bClientSideAnimation ); CNetworkVar( bool, m_bClientSideFrameReset ); CNetworkVar( int, m_nNewSequenceParity ); CNetworkVar( int, m_nResetEventsParity ); // Incremented each time the entity is told to do a muzzle flash. // The client picks up the change and draws the flash. CNetworkVar( unsigned char, m_nMuzzleFlashParity ); CNetworkHandle( CBaseEntity, m_hLightingOrigin ); CNetworkHandle( CBaseEntity, m_hLightingOriginRelative ); string_t m_iszLightingOriginRelative; // for reading from the file only string_t m_iszLightingOrigin; // for reading from the file only memhandle_t m_boneCacheHandle; unsigned short m_fBoneCacheFlags; // Used for bone cache state on model protected: CNetworkVar( float, m_fadeMinDist ); // Point at which fading is absolute CNetworkVar( float, m_fadeMaxDist ); // Point at which fading is inactive CNetworkVar( float, m_flFadeScale ); // Scale applied to min / max public: COutputEvent m_OnIgnite; private: CStudioHdr *m_pStudioHdr; CThreadFastMutex m_StudioHdrInitLock; CThreadFastMutex m_BoneSetupMutex; // FIXME: necessary so that cyclers can hack m_bSequenceFinished friend class CFlexCycler; friend class CCycler; friend class CBlendingCycler; }; //----------------------------------------------------------------------------- // Purpose: return a pointer to an updated studiomdl cache cache //----------------------------------------------------------------------------- inline CStudioHdr *CBaseAnimating::GetModelPtr( void ) { if ( IsDynamicModelLoading() ) return NULL; #ifdef _DEBUG // GetModelPtr() is often called before OnNewModel() so go ahead and set it up first chance. static IDataCacheSection *pModelCache = datacache->FindSection( "ModelData" ); AssertOnce( pModelCache->IsFrameLocking() ); #endif if ( !m_pStudioHdr && GetModel() ) { LockStudioHdr(); } return ( m_pStudioHdr && m_pStudioHdr->IsValid() ) ? m_pStudioHdr : NULL; } inline void CBaseAnimating::InvalidateMdlCache() { UnlockStudioHdr(); if ( m_pStudioHdr != NULL ) { delete m_pStudioHdr; m_pStudioHdr = NULL; } } //----------------------------------------------------------------------------- // Purpose: Serves the 90% case of calling SetSequence / ResetSequenceInfo. //----------------------------------------------------------------------------- /* inline void CBaseAnimating::ResetSequence(int nSequence) { m_nSequence = nSequence; ResetSequenceInfo(); } */ inline float CBaseAnimating::GetPlaybackRate() { return m_flPlaybackRate; } inline void CBaseAnimating::SetPlaybackRate( float rate ) { m_flPlaybackRate = rate; } inline void CBaseAnimating::SetLightingOrigin( CBaseEntity *pLightingOrigin ) { m_hLightingOrigin = pLightingOrigin; } inline CBaseEntity *CBaseAnimating::GetLightingOrigin() { return m_hLightingOrigin; } inline void CBaseAnimating::SetLightingOriginRelative( CBaseEntity *pLightingOriginRelative ) { m_hLightingOriginRelative = pLightingOriginRelative; } inline CBaseEntity *CBaseAnimating::GetLightingOriginRelative() { return m_hLightingOriginRelative; } //----------------------------------------------------------------------------- // Cycle access //----------------------------------------------------------------------------- inline float CBaseAnimating::GetCycle() const { return m_flCycle; } inline void CBaseAnimating::SetCycle( float flCycle ) { m_flCycle = flCycle; } EXTERN_SEND_TABLE(DT_BaseAnimating); #define ANIMATION_SEQUENCE_BITS 12 // 4096 sequences #define ANIMATION_SKIN_BITS 10 // 1024 body skin selections FIXME: this seems way high #define ANIMATION_BODY_BITS 32 // body combinations #define ANIMATION_HITBOXSET_BITS 2 // hit box sets #if defined( TF_DLL ) #define ANIMATION_POSEPARAMETER_BITS 8 // pose parameter resolution #else #define ANIMATION_POSEPARAMETER_BITS 11 // pose parameter resolution #endif #define ANIMATION_PLAYBACKRATE_BITS 8 // default playback rate, only used on leading edge detect sequence changes #endif // BASEANIMATING_H