initial
This commit is contained in:
nephacks
601
game/server/baseanimating.h
Normal file
601
game/server/baseanimating.h
Normal file
@@ -0,0 +1,601 @@
|
||||
//===== Copyright <20> 1996-2005, Valve Corporation, All rights reserved. ======//
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
//===========================================================================//
|
||||
|
||||
#ifndef BASEANIMATING_H
|
||||
#define BASEANIMATING_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include "entityoutput.h"
|
||||
#include "studio.h"
|
||||
#include "bone_merge_cache.h"
|
||||
#include "datacache/idatacache.h"
|
||||
#include "tier0/threadtools.h"
|
||||
|
||||
struct animevent_t;
|
||||
struct matrix3x4_t;
|
||||
class CIKContext;
|
||||
class KeyValues;
|
||||
class CAnimationLayer;
|
||||
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
|
||||
|
||||
extern IDataCache *datacache;
|
||||
|
||||
class CBaseAnimating : public CBaseEntity
|
||||
{
|
||||
public:
|
||||
DECLARE_CLASS( CBaseAnimating, CBaseEntity );
|
||||
|
||||
CBaseAnimating();
|
||||
~CBaseAnimating();
|
||||
|
||||
DECLARE_PREDICTABLE();
|
||||
|
||||
enum
|
||||
{
|
||||
NUM_POSEPAREMETERS = 24,
|
||||
NUM_BONECTRLS = 4
|
||||
};
|
||||
|
||||
DECLARE_DATADESC();
|
||||
DECLARE_SERVERCLASS();
|
||||
DECLARE_ENT_SCRIPTDESC();
|
||||
|
||||
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 );
|
||||
virtual void InvalidateMdlCache() { UnlockStudioHdr(); delete m_pStudioHdr; m_pStudioHdr = NULL; }
|
||||
|
||||
virtual CBaseAnimating* GetBaseAnimating() { return this; }
|
||||
|
||||
// Cycle access
|
||||
void ForceCycle( float flCycle );
|
||||
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 );
|
||||
virtual void ReachedEndOfSequence() { return; }
|
||||
|
||||
inline float GetPlaybackRate() const;
|
||||
inline void SetPlaybackRate( float rate );
|
||||
|
||||
inline int GetSequence() { return m_nSequence; }
|
||||
// inline void SetSequence(int nSequence) { Assert( GetModelPtr( ) && nSequence >= 0 && nSequence < GetModelPtr( )->GetNumSeq() ); m_nSequence = nSequence; }
|
||||
void SetSequence(int nSequence);
|
||||
virtual void OnSequenceSet( int nOldSequence ) {}
|
||||
/* 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); }
|
||||
virtual float GetLayerSequenceCycleRate( CAnimationLayer *pLayer, int iSequence ) { return GetSequenceCycleRate(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 );
|
||||
int LookupSequence ( CStudioHdr* pHdr, const char *label );
|
||||
float GetFirstSequenceAnimTag( int sequence, int nDesiredTag, float flStart = 0, float flEnd = 1 );
|
||||
float GetAnySequenceAnimTag( int sequence, int nDesiredTag, float flDefault );
|
||||
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, BoneVector pos[], BoneQuaternionAligned q[], int boneMask );
|
||||
|
||||
virtual void GetBoneTransform( int iBone, matrix3x4_t &pBoneToWorld );
|
||||
virtual void SetupBones( matrix3x4a_t *pBoneToWorld, int boneMask );
|
||||
virtual void CalculateIKLocks( float currentTime );
|
||||
virtual void Teleport( const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity, bool bUseSlowHighAccuracyContacts = true );
|
||||
|
||||
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 );
|
||||
virtual bool HandleScriptedAnimEvent( animevent_t *pEvent ) { return false; }
|
||||
virtual bool HandleBehaviorAnimEvent( animevent_t *pEvent ) { return false; }
|
||||
|
||||
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 );
|
||||
|
||||
private:
|
||||
CBoneMergeCache *m_pBoneMergeCache;
|
||||
|
||||
public:
|
||||
|
||||
CBaseAnimating* FindFollowedEntity();
|
||||
|
||||
int LookupBone( const char *szName );
|
||||
void GetBonePosition( const char *szName, Vector &origin, QAngle &angles );
|
||||
void GetBonePosition( int iBone, Vector &origin, QAngle &angles );
|
||||
|
||||
void GetHitboxBonePosition( int iBone, Vector &origin, QAngle &angles, QAngle hitboxOrientation );
|
||||
void GetHitboxBoneTransform( int iBone, QAngle hitboxOrientation, matrix3x4_t &pOut );
|
||||
|
||||
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 );
|
||||
const Vector& ScriptGetAttachmentOrigin( int iAttachment );
|
||||
const Vector& ScriptGetAttachmentAngles( int iAttachment );
|
||||
|
||||
// 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 );
|
||||
void SetBodygroupPreset( char const *szName );
|
||||
int GetSkin() { return m_nSkin; }
|
||||
|
||||
const char *GetBodygroupName( int iGroup );
|
||||
int FindBodygroupByName( const char *name );
|
||||
const char *GetBodygroupPartName( int iGroup, int iPart );
|
||||
int GetBodygroupCount( int iGroup );
|
||||
int GetNumBodyGroups( void );
|
||||
int CountBodyGroupVariants( int group );
|
||||
int FindBodyGroupVariant( int group, int variant ); ///< Find undamaged bodygroup part index
|
||||
int FindDamagedBodyGroupVariant( int group ); ///< Find a damaged version of the current part for the given bodygroup
|
||||
void RandomizeBodygroups( CUtlVector< const char * >& groups );
|
||||
|
||||
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 );
|
||||
|
||||
// Computes a box that surrounds a single hitboxes
|
||||
bool ComputeHitboxSurroundingBox( int iHitbox, 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 );
|
||||
virtual void InvalidateBoneCache( void );
|
||||
virtual int DrawDebugTextOverlays( void );
|
||||
virtual bool IsViewModel() const { return false; }
|
||||
|
||||
// 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, ModelScaleType_t scaleType = HIERARCHICAL_MODEL_SCALE );
|
||||
float GetModelScale() const;
|
||||
float GetModelHierarchyScale(); // Get the overall scale of the entire hierarchy (model scale can be local, per-bone)
|
||||
|
||||
ModelScaleType_t GetModelScaleType() const;
|
||||
void SetModelScaleType( ModelScaleType_t scaleType );
|
||||
|
||||
void UpdateModelScale();
|
||||
|
||||
// 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 );
|
||||
|
||||
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 IgniteUseCheapEffect( bool bUseCheapEffect );
|
||||
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 );
|
||||
|
||||
// Ice
|
||||
virtual bool IsFrozen( void ) { return m_flFrozen >= 1.0f; }
|
||||
float GetFrozenAmount( void ) const { return m_flFrozen; }
|
||||
float GetFrozenThawRate( void ) { return m_flFrozenThawRate; }
|
||||
void Thaw( float flThawAmount );
|
||||
void ToggleFreeze(void);
|
||||
virtual void Freeze( float flFreezeAmount = -1.0f, CBaseEntity *pFreezer = NULL, Ray_t *pFreezeRay = NULL );
|
||||
virtual void Unfreeze();
|
||||
|
||||
// Dissolve, returns true if the ragdoll has been created
|
||||
virtual 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 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 );
|
||||
|
||||
#ifdef PORTAL2
|
||||
virtual void OnFizzled( void );
|
||||
#endif // PORTAL2
|
||||
|
||||
|
||||
private:
|
||||
void LockStudioHdr();
|
||||
void UnlockStudioHdr();
|
||||
|
||||
void StudioFrameAdvanceInternal( CStudioHdr *pStudioHdr, float flInterval );
|
||||
void InputSetLightingOriginRelative( inputdata_t &inputdata );
|
||||
void InputSetLightingOrigin( inputdata_t &inputdata );
|
||||
|
||||
public:
|
||||
bool CanSkipAnimation( void );
|
||||
|
||||
#ifdef PORTAL2
|
||||
public:
|
||||
void SetObjectScaleLevel( int nScaleLevel ) { m_nObjectScaleLevel = nScaleLevel; }
|
||||
int GetObjectScaleLevel( void ) { return m_nObjectScaleLevel; }
|
||||
protected:
|
||||
int m_nObjectScaleLevel;
|
||||
bool m_bCanBeCaptured; // Set true this prop allows capture by weapon_camera
|
||||
#endif // PORTAL2
|
||||
|
||||
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 );
|
||||
|
||||
private:
|
||||
CNetworkVar( ModelScaleType_t, m_ScaleType );
|
||||
|
||||
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;
|
||||
|
||||
protected:
|
||||
bool m_bSequenceFinished;// flag set when StudioAdvanceFrame moves across a frame boundry
|
||||
bool m_bSequenceLoops; // true if the sequence loops
|
||||
float m_flDissolveStartTime;
|
||||
|
||||
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_bClientSideRagdoll );
|
||||
|
||||
// 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 );
|
||||
|
||||
CNetworkVar( bool, m_bSuppressAnimSounds );
|
||||
|
||||
// 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
|
||||
|
||||
CNetworkVar( float, m_flFrozen ); // 0 - 1 amount that the model is frozen
|
||||
float m_flMovementFrozen; // How frozen are the movement parts
|
||||
float m_flAttackFrozen; // How frozen are the attacking parts
|
||||
float m_flFrozenThawRate; // amount it unfreezes per second
|
||||
float m_flFrozenMax; // maximum amount this entitiy is allowed to freeze
|
||||
|
||||
public:
|
||||
COutputEvent m_OnIgnite;
|
||||
|
||||
#if defined ( PORTAL2 )
|
||||
COutputEvent m_OnFizzled; // Fizzled by a fizzler
|
||||
#endif // PORTAL2
|
||||
|
||||
private:
|
||||
CStudioHdr *m_pStudioHdr;
|
||||
CThreadFastMutex m_StudioHdrInitLock;
|
||||
CThreadFastMutex m_BoneSetupMutex;
|
||||
|
||||
// FIXME: necessary so that cyclers can hack m_bSequenceFinished
|
||||
friend class CBaseAnimatingOverlay;
|
||||
friend class CFlexCycler;
|
||||
friend class CCycler;
|
||||
friend class CBlendingCycler;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: return a pointer to an updated studiomdl cache cache
|
||||
//-----------------------------------------------------------------------------
|
||||
inline CStudioHdr *CBaseAnimating::GetModelPtr( void )
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#ifndef _GAMECONSOLE
|
||||
// Consoles don't need to lock the modeldata cache since it never flushes
|
||||
// GetModelPtr() is often called before OnNewModel() so go ahead and set it up first chance.
|
||||
static IDataCacheSection *pModelCache = g_pDataCache->FindSection( "ModelData" );
|
||||
AssertOnce( pModelCache->IsFrameLocking() );
|
||||
#endif
|
||||
#endif
|
||||
if ( !m_pStudioHdr && GetModel() )
|
||||
{
|
||||
LockStudioHdr();
|
||||
}
|
||||
return ( m_pStudioHdr && m_pStudioHdr->IsValid() ) ? m_pStudioHdr : NULL;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Serves the 90% case of calling SetSequence / ResetSequenceInfo.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
inline void CBaseAnimating::ResetSequence(int nSequence)
|
||||
{
|
||||
if ( nSequence != m_nSequence )
|
||||
{
|
||||
m_nSequence = nSequence;
|
||||
InvalidatePhysicsRecursive( SEQUENCE_CHANGED );
|
||||
}
|
||||
ResetSequenceInfo();
|
||||
}
|
||||
*/
|
||||
|
||||
inline float CBaseAnimating::GetPlaybackRate() const
|
||||
{
|
||||
#if defined( PORTAL2 )
|
||||
return m_flPlaybackRate * ( 1.0f / sqrt( GetModelScaleType() == HIERARCHICAL_MODEL_SCALE ? GetModelScale() : 1.0f ) );
|
||||
#endif // PORTAL2or INFESTED
|
||||
|
||||
// Slow the animation while partially frozen
|
||||
return m_flPlaybackRate * clamp( 1.0f - m_flFrozen, 0.0f, 1.0f );
|
||||
}
|
||||
|
||||
inline void CBaseAnimating::SetPlaybackRate( float rate )
|
||||
{
|
||||
// if we start going in a new direction, the current animation isn't finished anymore
|
||||
m_bSequenceFinished = false;
|
||||
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;
|
||||
}
|
||||
|
||||
inline void CBaseAnimating::ForceCycle( float flCycle )
|
||||
{
|
||||
SetCycle( flCycle );
|
||||
m_flLastEventCheck = 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
|
||||
Reference in New Issue
Block a user