You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
536 lines
20 KiB
536 lines
20 KiB
//========= 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 SelectWeightedSequenceFromModifiers( Activity activity, CUtlSymbol *pActivityModifiers, int iModifierCount ); |
|
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 |
|
if ( !HushAsserts() ) |
|
{ |
|
// 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
|
|
|