2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Base class for all animating characters and objects.
//
//=============================================================================//
# include "cbase.h"
# include "baseanimating.h"
# include "animation.h"
# include "activitylist.h"
# include "studio.h"
# include "bone_setup.h"
# include "mathlib/mathlib.h"
# include "model_types.h"
# include "datacache/imdlcache.h"
# include "physics.h"
# include "ndebugoverlay.h"
# include "tier1/strtools.h"
# include "npcevent.h"
# include "isaverestore.h"
# include "KeyValues.h"
# include "tier0/vprof.h"
# include "EntityFlame.h"
# include "EntityDissolve.h"
# include "ai_basenpc.h"
# include "physics_prop_ragdoll.h"
# include "datacache/idatacache.h"
# include "smoke_trail.h"
# include "props.h"
// memdbgon must be the last include file in a .cpp file!!!
# include "tier0/memdbgon.h"
ConVar ai_sequence_debug ( " ai_sequence_debug " , " 0 " ) ;
class CIKSaveRestoreOps : public CClassPtrSaveRestoreOps
{
// save data type interface
void Save ( const SaveRestoreFieldInfo_t & fieldInfo , ISave * pSave )
{
Assert ( fieldInfo . pTypeDesc - > fieldSize = = 1 ) ;
CIKContext * * pIK = ( CIKContext * * ) fieldInfo . pField ;
bool bHasIK = ( * pIK ) ! = 0 ;
pSave - > WriteBool ( & bHasIK ) ;
}
void Restore ( const SaveRestoreFieldInfo_t & fieldInfo , IRestore * pRestore )
{
Assert ( fieldInfo . pTypeDesc - > fieldSize = = 1 ) ;
CIKContext * * pIK = ( CIKContext * * ) fieldInfo . pField ;
bool bHasIK ;
pRestore - > ReadBool ( & bHasIK ) ;
* pIK = ( bHasIK ) ? new CIKContext : NULL ;
}
} ;
//-----------------------------------------------------------------------------
// Relative lighting entity
//-----------------------------------------------------------------------------
class CInfoLightingRelative : public CBaseEntity
{
public :
DECLARE_CLASS ( CInfoLightingRelative , CBaseEntity ) ;
DECLARE_DATADESC ( ) ;
DECLARE_SERVERCLASS ( ) ;
virtual void Activate ( ) ;
virtual void SetTransmit ( CCheckTransmitInfo * pInfo , bool bAlways ) ;
virtual int UpdateTransmitState ( void ) ;
private :
CNetworkHandle ( CBaseEntity , m_hLightingLandmark ) ;
string_t m_strLightingLandmark ;
} ;
LINK_ENTITY_TO_CLASS ( info_lighting_relative , CInfoLightingRelative ) ;
BEGIN_DATADESC ( CInfoLightingRelative )
DEFINE_KEYFIELD ( m_strLightingLandmark , FIELD_STRING , " LightingLandmark " ) ,
DEFINE_FIELD ( m_hLightingLandmark , FIELD_EHANDLE ) ,
END_DATADESC ( )
IMPLEMENT_SERVERCLASS_ST ( CInfoLightingRelative , DT_InfoLightingRelative )
SendPropEHandle ( SENDINFO ( m_hLightingLandmark ) ) ,
END_SEND_TABLE ( )
//-----------------------------------------------------------------------------
// Activate!
//-----------------------------------------------------------------------------
void CInfoLightingRelative : : Activate ( )
{
BaseClass : : Activate ( ) ;
if ( m_strLightingLandmark = = NULL_STRING )
{
m_hLightingLandmark = NULL ;
}
else
{
m_hLightingLandmark = gEntList . FindEntityByName ( NULL , m_strLightingLandmark ) ;
if ( ! m_hLightingLandmark )
{
DevWarning ( " %s: Could not find lighting landmark '%s'! \n " , GetClassname ( ) , STRING ( m_strLightingLandmark ) ) ;
}
else
{
// Set a force transmit because we do not have a model.
m_hLightingLandmark - > AddEFlags ( EFL_FORCE_CHECK_TRANSMIT ) ;
}
}
}
//-----------------------------------------------------------------------------
// Force our lighting landmark to be transmitted
//-----------------------------------------------------------------------------
void CInfoLightingRelative : : SetTransmit ( CCheckTransmitInfo * pInfo , bool bAlways )
{
// Are we already marked for transmission?
if ( pInfo - > m_pTransmitEdict - > Get ( entindex ( ) ) )
return ;
BaseClass : : SetTransmit ( pInfo , bAlways ) ;
// Force our constraint entity to be sent too.
if ( m_hLightingLandmark )
{
if ( m_hLightingLandmark - > GetMoveParent ( ) )
{
// Set a full check because we have a move parent.
m_hLightingLandmark - > SetTransmitState ( FL_EDICT_FULLCHECK ) ;
}
else
{
m_hLightingLandmark - > SetTransmitState ( FL_EDICT_ALWAYS ) ;
}
m_hLightingLandmark - > SetTransmit ( pInfo , bAlways ) ;
}
}
//-----------------------------------------------------------------------------
// Purpose Force our lighting landmark to be transmitted
//-----------------------------------------------------------------------------
int CInfoLightingRelative : : UpdateTransmitState ( void )
{
return SetTransmitState ( FL_EDICT_ALWAYS ) ;
}
static CIKSaveRestoreOps s_IKSaveRestoreOp ;
BEGIN_DATADESC ( CBaseAnimating )
DEFINE_FIELD ( m_flGroundSpeed , FIELD_FLOAT ) ,
DEFINE_FIELD ( m_flLastEventCheck , FIELD_TIME ) ,
DEFINE_FIELD ( m_bSequenceFinished , FIELD_BOOLEAN ) ,
DEFINE_FIELD ( m_bSequenceLoops , FIELD_BOOLEAN ) ,
// DEFINE_FIELD( m_nForceBone, FIELD_INTEGER ),
// DEFINE_FIELD( m_vecForce, FIELD_VECTOR ),
DEFINE_INPUT ( m_nSkin , FIELD_INTEGER , " skin " ) ,
DEFINE_KEYFIELD ( m_nBody , FIELD_INTEGER , " body " ) ,
DEFINE_INPUT ( m_nBody , FIELD_INTEGER , " SetBodyGroup " ) ,
DEFINE_KEYFIELD ( m_nHitboxSet , FIELD_INTEGER , " hitboxset " ) ,
DEFINE_KEYFIELD ( m_nSequence , FIELD_INTEGER , " sequence " ) ,
DEFINE_ARRAY ( m_flPoseParameter , FIELD_FLOAT , CBaseAnimating : : NUM_POSEPAREMETERS ) ,
DEFINE_ARRAY ( m_flEncodedController , FIELD_FLOAT , CBaseAnimating : : NUM_BONECTRLS ) ,
DEFINE_KEYFIELD ( m_flPlaybackRate , FIELD_FLOAT , " playbackrate " ) ,
DEFINE_KEYFIELD ( m_flCycle , FIELD_FLOAT , " cycle " ) ,
// DEFINE_FIELD( m_flIKGroundContactTime, FIELD_TIME ),
// DEFINE_FIELD( m_flIKGroundMinHeight, FIELD_FLOAT ),
// DEFINE_FIELD( m_flIKGroundMaxHeight, FIELD_FLOAT ),
// DEFINE_FIELD( m_flEstIkFloor, FIELD_FLOAT ),
// DEFINE_FIELD( m_flEstIkOffset, FIELD_FLOAT ),
// DEFINE_FIELD( m_pStudioHdr, CStudioHdr ),
// DEFINE_FIELD( m_StudioHdrInitLock, CThreadFastMutex ),
// DEFINE_FIELD( m_BoneSetupMutex, CThreadFastMutex ),
DEFINE_CUSTOM_FIELD ( m_pIk , & s_IKSaveRestoreOp ) ,
DEFINE_FIELD ( m_iIKCounter , FIELD_INTEGER ) ,
DEFINE_FIELD ( m_bClientSideAnimation , FIELD_BOOLEAN ) ,
DEFINE_FIELD ( m_bClientSideFrameReset , FIELD_BOOLEAN ) ,
DEFINE_FIELD ( m_nNewSequenceParity , FIELD_INTEGER ) ,
DEFINE_FIELD ( m_nResetEventsParity , FIELD_INTEGER ) ,
DEFINE_FIELD ( m_nMuzzleFlashParity , FIELD_CHARACTER ) ,
DEFINE_KEYFIELD ( m_iszLightingOriginRelative , FIELD_STRING , " LightingOriginHack " ) ,
DEFINE_KEYFIELD ( m_iszLightingOrigin , FIELD_STRING , " LightingOrigin " ) ,
DEFINE_FIELD ( m_hLightingOrigin , FIELD_EHANDLE ) ,
DEFINE_FIELD ( m_hLightingOriginRelative , FIELD_EHANDLE ) ,
DEFINE_FIELD ( m_flModelScale , FIELD_FLOAT ) ,
DEFINE_FIELD ( m_flDissolveStartTime , FIELD_TIME ) ,
// DEFINE_FIELD( m_boneCacheHandle, memhandle_t ),
DEFINE_INPUTFUNC ( FIELD_VOID , " Ignite " , InputIgnite ) ,
DEFINE_INPUTFUNC ( FIELD_FLOAT , " IgniteLifetime " , InputIgniteLifetime ) ,
DEFINE_INPUTFUNC ( FIELD_INTEGER , " IgniteNumHitboxFires " , InputIgniteNumHitboxFires ) ,
DEFINE_INPUTFUNC ( FIELD_FLOAT , " IgniteHitboxFireScale " , InputIgniteHitboxFireScale ) ,
DEFINE_INPUTFUNC ( FIELD_VOID , " BecomeRagdoll " , InputBecomeRagdoll ) ,
DEFINE_INPUTFUNC ( FIELD_STRING , " SetLightingOriginHack " , InputSetLightingOriginRelative ) ,
DEFINE_INPUTFUNC ( FIELD_STRING , " SetLightingOrigin " , InputSetLightingOrigin ) ,
DEFINE_OUTPUT ( m_OnIgnite , " OnIgnite " ) ,
DEFINE_INPUT ( m_fadeMinDist , FIELD_FLOAT , " fademindist " ) ,
DEFINE_INPUT ( m_fadeMaxDist , FIELD_FLOAT , " fademaxdist " ) ,
DEFINE_KEYFIELD ( m_flFadeScale , FIELD_FLOAT , " fadescale " ) ,
DEFINE_KEYFIELD ( m_flModelScale , FIELD_FLOAT , " modelscale " ) ,
DEFINE_INPUTFUNC ( FIELD_VECTOR , " SetModelScale " , InputSetModelScale ) ,
DEFINE_FIELD ( m_fBoneCacheFlags , FIELD_SHORT ) ,
END_DATADESC ( )
// Sendtable for fields we don't want to send to clientside animating entities
BEGIN_SEND_TABLE_NOBASE ( CBaseAnimating , DT_ServerAnimationData )
// ANIMATION_CYCLE_BITS is defined in shareddefs.h
SendPropFloat ( SENDINFO ( m_flCycle ) , ANIMATION_CYCLE_BITS , SPROP_CHANGES_OFTEN | SPROP_ROUNDDOWN , 0.0f , 1.0f )
END_SEND_TABLE ( )
void * SendProxy_ClientSideAnimation ( const SendProp * pProp , const void * pStruct , const void * pVarData , CSendProxyRecipients * pRecipients , int objectID ) ;
// SendTable stuff.
IMPLEMENT_SERVERCLASS_ST ( CBaseAnimating , DT_BaseAnimating )
SendPropInt ( SENDINFO ( m_nForceBone ) , 8 , 0 ) ,
SendPropVector ( SENDINFO ( m_vecForce ) , - 1 , SPROP_NOSCALE ) ,
SendPropInt ( SENDINFO ( m_nSkin ) , ANIMATION_SKIN_BITS ) ,
SendPropInt ( SENDINFO ( m_nBody ) , ANIMATION_BODY_BITS ) ,
SendPropInt ( SENDINFO ( m_nHitboxSet ) , ANIMATION_HITBOXSET_BITS , SPROP_UNSIGNED ) ,
SendPropFloat ( SENDINFO ( m_flModelScale ) ) ,
SendPropArray3 ( SENDINFO_ARRAY3 ( m_flPoseParameter ) , SendPropFloat ( SENDINFO_ARRAY ( m_flPoseParameter ) , ANIMATION_POSEPARAMETER_BITS , 0 , 0.0f , 1.0f ) ) ,
SendPropInt ( SENDINFO ( m_nSequence ) , ANIMATION_SEQUENCE_BITS , SPROP_UNSIGNED ) ,
SendPropFloat ( SENDINFO ( m_flPlaybackRate ) , ANIMATION_PLAYBACKRATE_BITS , SPROP_ROUNDUP , - 4.0 , 12.0f ) , // NOTE: if this isn't a power of 2 than "1.0" can't be encoded correctly
SendPropArray3 ( SENDINFO_ARRAY3 ( m_flEncodedController ) , SendPropFloat ( SENDINFO_ARRAY ( m_flEncodedController ) , 11 , SPROP_ROUNDDOWN , 0.0f , 1.0f ) ) ,
SendPropInt ( SENDINFO ( m_bClientSideAnimation ) , 1 , SPROP_UNSIGNED ) ,
SendPropInt ( SENDINFO ( m_bClientSideFrameReset ) , 1 , SPROP_UNSIGNED ) ,
SendPropInt ( SENDINFO ( m_nNewSequenceParity ) , EF_PARITY_BITS , SPROP_UNSIGNED ) ,
SendPropInt ( SENDINFO ( m_nResetEventsParity ) , EF_PARITY_BITS , SPROP_UNSIGNED ) ,
SendPropInt ( SENDINFO ( m_nMuzzleFlashParity ) , EF_MUZZLEFLASH_BITS , SPROP_UNSIGNED ) ,
SendPropEHandle ( SENDINFO ( m_hLightingOrigin ) ) ,
SendPropEHandle ( SENDINFO ( m_hLightingOriginRelative ) ) ,
SendPropDataTable ( " serveranimdata " , 0 , & REFERENCE_SEND_TABLE ( DT_ServerAnimationData ) , SendProxy_ClientSideAnimation ) ,
// Fading
SendPropFloat ( SENDINFO ( m_fadeMinDist ) , 0 , SPROP_NOSCALE ) ,
SendPropFloat ( SENDINFO ( m_fadeMaxDist ) , 0 , SPROP_NOSCALE ) ,
SendPropFloat ( SENDINFO ( m_flFadeScale ) , 0 , SPROP_NOSCALE ) ,
END_SEND_TABLE ( )
CBaseAnimating : : CBaseAnimating ( )
{
m_vecForce . GetForModify ( ) . Init ( ) ;
m_nForceBone = 0 ;
m_bResetSequenceInfoOnLoad = false ;
m_bClientSideAnimation = false ;
m_pIk = NULL ;
m_iIKCounter = 0 ;
InitStepHeightAdjust ( ) ;
m_flModelScale = 1.0f ;
// initialize anim clock
m_flAnimTime = gpGlobals - > curtime ;
m_flPrevAnimTime = gpGlobals - > curtime ;
m_nNewSequenceParity = 0 ;
m_nResetEventsParity = 0 ;
m_boneCacheHandle = 0 ;
m_pStudioHdr = NULL ;
m_fadeMinDist = 0 ;
m_fadeMaxDist = 0 ;
m_flFadeScale = 0.0f ;
m_fBoneCacheFlags = 0 ;
}
CBaseAnimating : : ~ CBaseAnimating ( )
{
Studio_DestroyBoneCache ( m_boneCacheHandle ) ;
delete m_pIk ;
UnlockStudioHdr ( ) ;
delete m_pStudioHdr ;
}
void CBaseAnimating : : Precache ( )
{
# if !defined( TF_DLL )
// Anything derived from this class can potentially burn - true, but do we want it to!
PrecacheParticleSystem ( " burning_character " ) ;
# endif
BaseClass : : Precache ( ) ;
}
//-----------------------------------------------------------------------------
// Activate!
//-----------------------------------------------------------------------------
void CBaseAnimating : : Activate ( )
{
BaseClass : : Activate ( ) ;
SetLightingOrigin ( m_iszLightingOrigin ) ;
SetLightingOriginRelative ( m_iszLightingOriginRelative ) ;
// Scaled physics objects (re)create their physics here
if ( m_flModelScale ! = 1.0f & & VPhysicsGetObject ( ) )
{
// sanity check to make sure 'm_flModelScale' is in sync with the
Assert ( m_flModelScale > 0.0f ) ;
UTIL_CreateScaledPhysObject ( this , m_flModelScale ) ;
}
}
//-----------------------------------------------------------------------------
// Force our lighting origin to be trasmitted
//-----------------------------------------------------------------------------
void CBaseAnimating : : SetTransmit ( CCheckTransmitInfo * pInfo , bool bAlways )
{
// Are we already marked for transmission?
if ( pInfo - > m_pTransmitEdict - > Get ( entindex ( ) ) )
return ;
BaseClass : : SetTransmit ( pInfo , bAlways ) ;
// Force our lighting entities to be sent too.
if ( m_hLightingOrigin )
{
m_hLightingOrigin - > SetTransmit ( pInfo , bAlways ) ;
}
if ( m_hLightingOriginRelative )
{
m_hLightingOriginRelative - > SetTransmit ( pInfo , bAlways ) ;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CBaseAnimating : : Restore ( IRestore & restore )
{
int result = BaseClass : : Restore ( restore ) ;
if ( m_flModelScale < = 0.0f )
m_flModelScale = 1.0f ;
LockStudioHdr ( ) ;
return result ;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CBaseAnimating : : OnRestore ( )
{
BaseClass : : OnRestore ( ) ;
if ( m_nSequence ! = - 1 & & GetModelPtr ( ) & & ! IsValidSequence ( m_nSequence ) )
m_nSequence = 0 ;
m_flEstIkFloor = GetLocalOrigin ( ) . z ;
PopulatePoseParameters ( ) ;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CBaseAnimating : : Spawn ( )
{
BaseClass : : Spawn ( ) ;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CBaseAnimating : : UseClientSideAnimation ( )
{
m_bClientSideAnimation = true ;
}
# define MAX_ANIMTIME_INTERVAL 0.2f
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CBaseAnimating : : GetAnimTimeInterval ( void ) const
{
float flInterval ;
if ( m_flAnimTime < gpGlobals - > curtime )
{
// estimate what it'll be this frame
flInterval = clamp ( gpGlobals - > curtime - m_flAnimTime , 0.f , MAX_ANIMTIME_INTERVAL ) ;
}
else
{
// report actual
flInterval = clamp ( m_flAnimTime - m_flPrevAnimTime , 0.f , MAX_ANIMTIME_INTERVAL ) ;
}
return flInterval ;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimating : : StudioFrameAdvanceInternal ( CStudioHdr * pStudioHdr , float flCycleDelta )
{
float flNewCycle = GetCycle ( ) + flCycleDelta ;
if ( flNewCycle < 0.0 | | flNewCycle > = 1.0 )
{
if ( m_bSequenceLoops )
{
flNewCycle - = ( int ) ( flNewCycle ) ;
}
else
{
flNewCycle = ( flNewCycle < 0.0f ) ? 0.0f : 1.0f ;
}
m_bSequenceFinished = true ; // just in case it wasn't caught in GetEvents
}
else if ( flNewCycle > GetLastVisibleCycle ( pStudioHdr , GetSequence ( ) ) )
{
m_bSequenceFinished = true ;
}
SetCycle ( flNewCycle ) ;
/*
if ( ! IsPlayer ( ) )
Msg ( " %s %6.3f : %6.3f %6.3f (%.3f) %.3f \n " ,
GetClassname ( ) , gpGlobals - > curtime ,
m_flAnimTime . Get ( ) , m_flPrevAnimTime , flInterval , GetCycle ( ) ) ;
*/
m_flGroundSpeed = GetSequenceGroundSpeed ( pStudioHdr , GetSequence ( ) ) * GetModelScale ( ) ;
// Msg("%s : %s : %5.1f\n", GetClassname(), GetSequenceName( GetSequence() ), GetCycle() );
InvalidatePhysicsRecursive ( ANIMATION_CHANGED ) ;
InvalidateBoneCacheIfOlderThan ( 0 ) ;
}
void CBaseAnimating : : InvalidateBoneCacheIfOlderThan ( float deltaTime )
{
CBoneCache * pcache = Studio_GetBoneCache ( m_boneCacheHandle ) ;
if ( ! pcache | | ! pcache - > IsValid ( gpGlobals - > curtime , deltaTime ) )
{
InvalidateBoneCache ( ) ;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimating : : StudioFrameAdvanceManual ( float flInterval )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
return ;
2022-03-01 20:00:42 +00:00
UpdateModelScale ( ) ;
2020-04-22 16:56:21 +00:00
m_flAnimTime = gpGlobals - > curtime ;
m_flPrevAnimTime = m_flAnimTime - flInterval ;
float flCycleRate = GetSequenceCycleRate ( pStudioHdr , GetSequence ( ) ) * m_flPlaybackRate ;
StudioFrameAdvanceInternal ( GetModelPtr ( ) , flInterval * flCycleRate ) ;
}
//=========================================================
// StudioFrameAdvance - advance the animation frame up some interval (default 0.1) into the future
//=========================================================
void CBaseAnimating : : StudioFrameAdvance ( )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr | | ! pStudioHdr - > SequencesAvailable ( ) )
{
return ;
}
2022-03-01 20:00:42 +00:00
UpdateModelScale ( ) ;
2020-04-22 16:56:21 +00:00
if ( ! m_flPrevAnimTime )
{
m_flPrevAnimTime = m_flAnimTime ;
}
// Time since last animation
float flInterval = gpGlobals - > curtime - m_flAnimTime ;
flInterval = clamp ( flInterval , 0.f , MAX_ANIMTIME_INTERVAL ) ;
//Msg( "%i %s interval %f\n", entindex(), GetClassname(), flInterval );
if ( flInterval < = 0.001f )
{
// Msg("%s : %s : %5.3f (skip)\n", GetClassname(), GetSequenceName( GetSequence() ), GetCycle() );
return ;
}
// Latch prev
m_flPrevAnimTime = m_flAnimTime ;
// Set current
m_flAnimTime = gpGlobals - > curtime ;
// Drive cycle
float flCycleRate = GetSequenceCycleRate ( pStudioHdr , GetSequence ( ) ) * m_flPlaybackRate ;
StudioFrameAdvanceInternal ( pStudioHdr , flInterval * flCycleRate ) ;
if ( ai_sequence_debug . GetBool ( ) = = true & & m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
{
Msg ( " %5.2f : %s : %s : %5.3f \n " , gpGlobals - > curtime , GetClassname ( ) , GetSequenceName ( GetSequence ( ) ) , GetCycle ( ) ) ;
}
}
//-----------------------------------------------------------------------------
// Set the relative lighting origin
//-----------------------------------------------------------------------------
void CBaseAnimating : : SetLightingOriginRelative ( string_t strLightingOriginRelative )
{
if ( strLightingOriginRelative = = NULL_STRING )
{
SetLightingOriginRelative ( NULL ) ;
}
else
{
CBaseEntity * pLightingOrigin = gEntList . FindEntityByName ( NULL , strLightingOriginRelative ) ;
if ( ! pLightingOrigin )
{
DevWarning ( " %s: Could not find info_lighting_relative '%s'! \n " , GetClassname ( ) , STRING ( strLightingOriginRelative ) ) ;
return ;
}
else if ( ! dynamic_cast < CInfoLightingRelative * > ( pLightingOrigin ) )
{
if ( ! pLightingOrigin )
{
DevWarning ( " %s: Cannot find Lighting Origin named: %s \n " , GetEntityName ( ) . ToCStr ( ) , STRING ( strLightingOriginRelative ) ) ;
}
else
{
DevWarning ( " %s: Specified entity '%s' must be a info_lighting_relative! \n " ,
pLightingOrigin - > GetClassname ( ) , pLightingOrigin - > GetEntityName ( ) . ToCStr ( ) ) ;
}
return ;
}
SetLightingOriginRelative ( pLightingOrigin ) ;
}
// Save the name so that save/load will correctly restore it in Activate()
m_iszLightingOriginRelative = strLightingOriginRelative ;
}
//-----------------------------------------------------------------------------
// Set the lighting origin
//-----------------------------------------------------------------------------
void CBaseAnimating : : SetLightingOrigin ( string_t strLightingOrigin )
{
if ( strLightingOrigin = = NULL_STRING )
{
SetLightingOrigin ( NULL ) ;
}
else
{
CBaseEntity * pLightingOrigin = gEntList . FindEntityByName ( NULL , strLightingOrigin ) ;
if ( ! pLightingOrigin )
{
DevWarning ( " %s: Could not find lighting origin entity named '%s'! \n " , GetClassname ( ) , STRING ( strLightingOrigin ) ) ;
return ;
}
else
{
SetLightingOrigin ( pLightingOrigin ) ;
}
}
// Save the name so that save/load will correctly restore it in Activate()
m_iszLightingOrigin = strLightingOrigin ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CBaseAnimating : : InputSetLightingOriginRelative ( inputdata_t & inputdata )
{
// Find our specified target
string_t strLightingOriginRelative = MAKE_STRING ( inputdata . value . String ( ) ) ;
SetLightingOriginRelative ( strLightingOriginRelative ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CBaseAnimating : : InputSetLightingOrigin ( inputdata_t & inputdata )
{
// Find our specified target
string_t strLightingOrigin = MAKE_STRING ( inputdata . value . String ( ) ) ;
SetLightingOrigin ( strLightingOrigin ) ;
}
//-----------------------------------------------------------------------------
// Purpose: SetModelScale input handler
//-----------------------------------------------------------------------------
void CBaseAnimating : : InputSetModelScale ( inputdata_t & inputdata )
{
Vector vecScale ;
inputdata . value . Vector3D ( vecScale ) ;
SetModelScale ( vecScale . x , vecScale . y ) ;
}
//=========================================================
// SelectWeightedSequence
//=========================================================
int CBaseAnimating : : SelectWeightedSequence ( Activity activity )
{
Assert ( activity ! = ACT_INVALID ) ;
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
return : : SelectWeightedSequence ( GetModelPtr ( ) , activity , GetSequence ( ) ) ;
}
int CBaseAnimating : : SelectWeightedSequence ( Activity activity , int curSequence )
{
Assert ( activity ! = ACT_INVALID ) ;
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
return : : SelectWeightedSequence ( GetModelPtr ( ) , activity , curSequence ) ;
}
//=========================================================
// ResetActivityIndexes
//=========================================================
void CBaseAnimating : : ResetActivityIndexes ( void )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
: : ResetActivityIndexes ( GetModelPtr ( ) ) ;
}
//=========================================================
// ResetEventIndexes
//=========================================================
void CBaseAnimating : : ResetEventIndexes ( void )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
: : ResetEventIndexes ( GetModelPtr ( ) ) ;
}
//=========================================================
// LookupHeaviestSequence
//
// Get sequence with highest 'weight' for this activity
//
//=========================================================
int CBaseAnimating : : SelectHeaviestSequence ( Activity activity )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
return : : SelectHeaviestSequence ( GetModelPtr ( ) , activity ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Looks up an activity by name.
// Input : label - Name of the activity, ie "ACT_IDLE".
// Output : Returns the activity ID or ACT_INVALID.
//-----------------------------------------------------------------------------
int CBaseAnimating : : LookupActivity ( const char * label )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
return : : LookupActivity ( GetModelPtr ( ) , label ) ;
}
//=========================================================
//=========================================================
int CBaseAnimating : : LookupSequence ( const char * label )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
return : : LookupSequence ( GetModelPtr ( ) , label ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
KeyValues * CBaseAnimating : : GetSequenceKeyValues ( int iSequence )
{
const char * szText = Studio_GetKeyValueText ( GetModelPtr ( ) , iSequence ) ;
if ( szText )
{
KeyValues * seqKeyValues = new KeyValues ( " " ) ;
if ( seqKeyValues - > LoadFromBuffer ( modelinfo - > GetModelName ( GetModel ( ) ) , szText ) )
{
return seqKeyValues ;
}
seqKeyValues - > deleteThis ( ) ;
}
return NULL ;
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : iSequence -
//
// Output : float -
//-----------------------------------------------------------------------------
float CBaseAnimating : : GetSequenceMoveYaw ( int iSequence )
{
Vector vecReturn ;
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
: : GetSequenceLinearMotion ( GetModelPtr ( ) , iSequence , GetPoseParameterArray ( ) , & vecReturn ) ;
if ( vecReturn . Length ( ) > 0 )
{
return UTIL_VecToYaw ( vecReturn ) ;
}
return NOMOTION ;
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : iSequence -
//
// Output : float
//-----------------------------------------------------------------------------
float CBaseAnimating : : GetSequenceMoveDist ( CStudioHdr * pStudioHdr , int iSequence )
{
Vector vecReturn ;
: : GetSequenceLinearMotion ( pStudioHdr , iSequence , GetPoseParameterArray ( ) , & vecReturn ) ;
return vecReturn . Length ( ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : iSequence -
// *pVec -
//
//-----------------------------------------------------------------------------
void CBaseAnimating : : GetSequenceLinearMotion ( int iSequence , Vector * pVec )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
: : GetSequenceLinearMotion ( GetModelPtr ( ) , iSequence , GetPoseParameterArray ( ) , pVec ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : iSequence -
//
// Output : char
//-----------------------------------------------------------------------------
const char * CBaseAnimating : : GetSequenceName ( int iSequence )
{
if ( iSequence = = - 1 )
{
return " Not Found! " ;
}
if ( ! GetModelPtr ( ) )
return " No model! " ;
return : : GetSequenceName ( GetModelPtr ( ) , iSequence ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
//
// Input : iSequence -
//
// Output : char
//-----------------------------------------------------------------------------
const char * CBaseAnimating : : GetSequenceActivityName ( int iSequence )
{
if ( iSequence = = - 1 )
{
return " Not Found! " ;
}
if ( ! GetModelPtr ( ) )
return " No model! " ;
return : : GetSequenceActivityName ( GetModelPtr ( ) , iSequence ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Make this a client-side simulated entity
// Input : force - vector of force to be exerted in the physics simulation
// forceBone - bone to exert force upon
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseAnimating : : BecomeRagdollOnClient ( const Vector & force )
{
// If this character has a ragdoll animation, turn it over to the physics system
if ( CanBecomeRagdoll ( ) )
{
VPhysicsDestroyObject ( ) ;
AddSolidFlags ( FSOLID_NOT_SOLID ) ;
m_nRenderFX = kRenderFxRagdoll ;
// Have to do this dance because m_vecForce is a network vector
// and can't be sent to ClampRagdollForce as a Vector *
Vector vecClampedForce ;
ClampRagdollForce ( force , & vecClampedForce ) ;
m_vecForce = vecClampedForce ;
SetParent ( NULL ) ;
AddFlag ( FL_TRANSRAGDOLL ) ;
SetMoveType ( MOVETYPE_NONE ) ;
//UTIL_SetSize( this, vec3_origin, vec3_origin );
SetThink ( NULL ) ;
SetNextThink ( gpGlobals - > curtime + 2.0f ) ;
//If we're here, then we can vanish safely
SetThink ( & CBaseEntity : : SUB_Remove ) ;
// Remove our flame entity if it's attached to us
CEntityFlame * pFireChild = dynamic_cast < CEntityFlame * > ( GetEffectEntity ( ) ) ;
if ( pFireChild )
{
pFireChild - > SetThink ( & CBaseEntity : : SUB_Remove ) ;
pFireChild - > SetNextThink ( gpGlobals - > curtime + 0.1f ) ;
}
return true ;
}
return false ;
}
bool CBaseAnimating : : IsRagdoll ( )
{
return ( m_nRenderFX = = kRenderFxRagdoll ) ? true : false ;
}
bool CBaseAnimating : : CanBecomeRagdoll ( void )
{
MDLCACHE_CRITICAL_SECTION ( ) ;
int ragdollSequence = SelectWeightedSequence ( ACT_DIERAGDOLL ) ;
//Can't cause we don't have a ragdoll sequence.
if ( ragdollSequence = = ACTIVITY_NOT_AVAILABLE )
return false ;
if ( GetFlags ( ) & FL_TRANSRAGDOLL )
return false ;
return true ;
}
//=========================================================
//=========================================================
void CBaseAnimating : : ResetSequenceInfo ( )
{
if ( GetSequence ( ) = = - 1 )
{
// This shouldn't happen. Setting m_nSequence blindly is a horrible coding practice.
SetSequence ( 0 ) ;
}
if ( IsDynamicModelLoading ( ) )
{
m_bResetSequenceInfoOnLoad = true ;
return ;
}
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
m_flGroundSpeed = GetSequenceGroundSpeed ( pStudioHdr , GetSequence ( ) ) * GetModelScale ( ) ;
m_bSequenceLoops = ( ( GetSequenceFlags ( pStudioHdr , GetSequence ( ) ) & STUDIO_LOOPING ) ! = 0 ) ;
// m_flAnimTime = gpGlobals->time;
m_flPlaybackRate = 1.0 ;
m_bSequenceFinished = false ;
m_flLastEventCheck = 0 ;
m_nNewSequenceParity = ( m_nNewSequenceParity + 1 ) & EF_PARITY_MASK ;
m_nResetEventsParity = ( m_nResetEventsParity + 1 ) & EF_PARITY_MASK ;
// FIXME: why is this called here? Nothing should have changed to make this nessesary
if ( pStudioHdr )
{
SetEventIndexForSequence ( pStudioHdr - > pSeqdesc ( GetSequence ( ) ) ) ;
}
}
//=========================================================
//=========================================================
bool CBaseAnimating : : IsValidSequence ( int iSequence )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( iSequence < 0 | | iSequence > = pstudiohdr - > GetNumSeq ( ) )
{
return false ;
}
return true ;
}
//=========================================================
//=========================================================
void CBaseAnimating : : SetSequence ( int nSequence )
{
Assert ( nSequence = = 0 | | IsDynamicModelLoading ( ) | | ( GetModelPtr ( ) & & ( nSequence < GetModelPtr ( ) - > GetNumSeq ( ) ) & & ( GetModelPtr ( ) - > GetNumSeq ( ) < ( 1 < < ANIMATION_SEQUENCE_BITS ) ) ) ) ;
m_nSequence = nSequence ;
}
//=========================================================
//=========================================================
float CBaseAnimating : : SequenceDuration ( CStudioHdr * pStudioHdr , int iSequence )
{
if ( ! pStudioHdr )
{
DevWarning ( 2 , " CBaseAnimating::SequenceDuration( %d ) NULL pstudiohdr on %s! \n " , iSequence , GetClassname ( ) ) ;
return 0.1 ;
}
if ( ! pStudioHdr - > SequencesAvailable ( ) )
{
return 0.1 ;
}
if ( iSequence > = pStudioHdr - > GetNumSeq ( ) | | iSequence < 0 )
{
DevWarning ( 2 , " CBaseAnimating::SequenceDuration( %d ) out of range \n " , iSequence ) ;
return 0.1 ;
}
return Studio_Duration ( pStudioHdr , iSequence , GetPoseParameterArray ( ) ) ;
}
float CBaseAnimating : : GetSequenceCycleRate ( CStudioHdr * pStudioHdr , int iSequence )
{
float t = SequenceDuration ( pStudioHdr , iSequence ) ;
2022-03-01 20:00:42 +00:00
if ( t > 0.0f )
2020-04-22 16:56:21 +00:00
{
return 1.0f / t ;
}
2022-03-01 20:00:42 +00:00
else
{
return 1.0f / 0.1f ;
}
2020-04-22 16:56:21 +00:00
}
float CBaseAnimating : : GetLastVisibleCycle ( CStudioHdr * pStudioHdr , int iSequence )
{
if ( ! pStudioHdr )
{
DevWarning ( 2 , " CBaseAnimating::LastVisibleCycle( %d ) NULL pstudiohdr on %s! \n " , iSequence , GetClassname ( ) ) ;
return 1.0 ;
}
if ( ! ( GetSequenceFlags ( pStudioHdr , iSequence ) & STUDIO_LOOPING ) )
{
return 1.0f - ( pStudioHdr - > pSeqdesc ( iSequence ) . fadeouttime ) * GetSequenceCycleRate ( iSequence ) * m_flPlaybackRate ;
}
else
{
return 1.0 ;
}
}
float CBaseAnimating : : GetSequenceGroundSpeed ( CStudioHdr * pStudioHdr , int iSequence )
{
float t = SequenceDuration ( pStudioHdr , iSequence ) ;
if ( t > 0 )
{
return ( GetSequenceMoveDist ( pStudioHdr , iSequence ) / t ) ;
}
else
{
return 0 ;
}
}
float CBaseAnimating : : GetIdealSpeed ( ) const
{
return m_flGroundSpeed ;
}
float CBaseAnimating : : GetIdealAccel ( ) const
{
// return ideal max velocity change over 1 second.
// tuned for run-walk range of humans
return GetIdealSpeed ( ) + 50 ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if the given sequence has the anim event, false if not.
// Input : nSequence - sequence number to check
// nEvent - anim event number to look for
//-----------------------------------------------------------------------------
bool CBaseAnimating : : HasAnimEvent ( int nSequence , int nEvent )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
{
return false ;
}
animevent_t event ;
int index = 0 ;
while ( ( index = GetAnimationEvent ( pstudiohdr , nSequence , & event , 0.0f , 1.0f , index ) ) ! = 0 )
{
if ( event . event = = nEvent )
{
return true ;
}
}
return false ;
}
//=========================================================
// DispatchAnimEvents
//=========================================================
void CBaseAnimating : : DispatchAnimEvents ( CBaseAnimating * eventHandler )
{
// don't fire events if the framerate is 0
if ( m_flPlaybackRate = = 0.0 )
return ;
animevent_t event ;
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
{
Assert ( ! " CBaseAnimating::DispatchAnimEvents: model missing " ) ;
return ;
}
if ( ! pstudiohdr - > SequencesAvailable ( ) )
{
return ;
}
// skip this altogether if there are no events
if ( pstudiohdr - > pSeqdesc ( GetSequence ( ) ) . numevents = = 0 )
{
return ;
}
// look from when it last checked to some short time in the future
float flCycleRate = GetSequenceCycleRate ( GetSequence ( ) ) * m_flPlaybackRate ;
float flStart = m_flLastEventCheck ;
float flEnd = GetCycle ( ) ;
if ( ! m_bSequenceLoops & & m_bSequenceFinished )
{
flEnd = 1.01f ;
}
m_flLastEventCheck = flEnd ;
/*
if ( m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
{
Msg ( " %s:%s : checking %.2f %.2f (%d) \n " , STRING ( GetModelName ( ) ) , pstudiohdr - > pSeqdesc ( GetSequence ( ) ) . pszLabel ( ) , flStart , flEnd , m_bSequenceFinished ) ;
}
*/
// FIXME: does not handle negative framerates!
int index = 0 ;
while ( ( index = GetAnimationEvent ( pstudiohdr , GetSequence ( ) , & event , flStart , flEnd , index ) ) ! = 0 )
{
event . pSource = this ;
// calc when this event should happen
if ( flCycleRate > 0.0 )
{
float flCycle = event . cycle ;
if ( flCycle > GetCycle ( ) )
{
flCycle = flCycle - 1.0 ;
}
event . eventtime = m_flAnimTime + ( flCycle - GetCycle ( ) ) / flCycleRate + GetAnimTimeInterval ( ) ;
}
/*
if ( m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
{
Msg ( " dispatch %i (%i) cycle %f event cycle %f cyclerate %f \n " ,
( int ) ( index - 1 ) ,
( int ) event . event ,
( float ) GetCycle ( ) ,
( float ) event . cycle ,
( float ) flCycleRate ) ;
}
*/
eventHandler - > HandleAnimEvent ( & event ) ;
// FAILSAFE:
// If HandleAnimEvent has somehow reset my internal pointer
// to CStudioHdr to something other than it was when we entered
// this function, we will crash on the next call to GetAnimationEvent
// because pstudiohdr no longer points at something valid.
// So, catch this case, complain vigorously, and bail out of
// the loop.
CStudioHdr * pNowStudioHdr = GetModelPtr ( ) ;
if ( pNowStudioHdr ! = pstudiohdr )
{
AssertMsg2 ( false , " %s has changed its model while processing AnimEvents on sequence %d. Aborting dispatch. \n " , GetDebugName ( ) , GetSequence ( ) ) ;
Warning ( " %s has changed its model while processing AnimEvents on sequence %d. Aborting dispatch. \n " , GetDebugName ( ) , GetSequence ( ) ) ;
break ;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimating : : HandleAnimEvent ( animevent_t * pEvent )
{
if ( ( pEvent - > type & AE_TYPE_NEWEVENTSYSTEM ) & & ( pEvent - > type & AE_TYPE_SERVER ) )
{
if ( pEvent - > event = = AE_SV_PLAYSOUND )
{
EmitSound ( pEvent - > options ) ;
return ;
}
else if ( pEvent - > event = = AE_RAGDOLL )
{
// Convert to ragdoll immediately
BecomeRagdollOnClient ( vec3_origin ) ;
return ;
}
# ifdef HL2_EPISODIC
else if ( pEvent - > event = = AE_SV_DUSTTRAIL )
{
char szAttachment [ 128 ] ;
float flDuration ;
float flSize ;
if ( sscanf ( pEvent - > options , " %s %f %f " , szAttachment , & flDuration , & flSize ) = = 3 )
{
CHandle < DustTrail > hDustTrail ;
hDustTrail = DustTrail : : CreateDustTrail ( ) ;
if ( hDustTrail )
{
hDustTrail - > m_SpawnRate = 4 ; // Particles per second
hDustTrail - > m_ParticleLifetime = 1.5 ; // Lifetime of each particle, In seconds
hDustTrail - > m_Color . Init ( 0.5f , 0.46f , 0.44f ) ;
hDustTrail - > m_StartSize = flSize ;
hDustTrail - > m_EndSize = hDustTrail - > m_StartSize * 8 ;
hDustTrail - > m_SpawnRadius = 3 ; // Each particle randomly offset from the center up to this many units
hDustTrail - > m_MinSpeed = 4 ; // u/sec
hDustTrail - > m_MaxSpeed = 10 ; // u/sec
hDustTrail - > m_Opacity = 0.5f ;
hDustTrail - > SetLifetime ( flDuration ) ; // Lifetime of the spawner, in seconds
hDustTrail - > m_StopEmitTime = gpGlobals - > curtime + flDuration ;
hDustTrail - > SetParent ( this , LookupAttachment ( szAttachment ) ) ;
hDustTrail - > SetLocalOrigin ( vec3_origin ) ;
}
}
else
{
DevWarning ( 1 , " %s unable to parse AE_SV_DUSTTRAIL event \" %s \" \n " , STRING ( GetModelName ( ) ) , pEvent - > options ) ;
}
return ;
}
# endif
}
// Failed to find a handler
const char * pName = EventList_NameForIndex ( pEvent - > event ) ;
if ( pName )
{
DevWarning ( 1 , " Unhandled animation event %s for %s \n " , pName , GetClassname ( ) ) ;
}
else
{
DevWarning ( 1 , " Unhandled animation event %d for %s \n " , pEvent - > event , GetClassname ( ) ) ;
}
}
// SetPoseParamater()
//=========================================================
//=========================================================
float CBaseAnimating : : SetPoseParameter ( CStudioHdr * pStudioHdr , const char * szName , float flValue )
{
int poseParam = LookupPoseParameter ( pStudioHdr , szName ) ;
AssertMsg2 ( poseParam > = 0 , " SetPoseParameter called with invalid argument %s by %s " , szName , GetDebugName ( ) ) ;
return SetPoseParameter ( pStudioHdr , poseParam , flValue ) ;
}
float CBaseAnimating : : SetPoseParameter ( CStudioHdr * pStudioHdr , int iParameter , float flValue )
{
if ( ! pStudioHdr )
{
return flValue ;
}
if ( iParameter > = 0 )
{
float flNewValue ;
flValue = Studio_SetPoseParameter ( pStudioHdr , iParameter , flValue , flNewValue ) ;
m_flPoseParameter . Set ( iParameter , flNewValue ) ;
}
return flValue ;
}
//=========================================================
//=========================================================
float CBaseAnimating : : GetPoseParameter ( const char * szName )
{
return GetPoseParameter ( LookupPoseParameter ( szName ) ) ;
}
float CBaseAnimating : : GetPoseParameter ( int iParameter )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
{
Assert ( ! " CBaseAnimating::GetPoseParameter: model missing " ) ;
return 0.0 ;
}
if ( ! pstudiohdr - > SequencesAvailable ( ) )
{
return 0 ;
}
if ( iParameter > = 0 )
{
return Studio_GetPoseParameter ( pstudiohdr , iParameter , m_flPoseParameter [ iParameter ] ) ;
}
return 0.0 ;
}
bool CBaseAnimating : : GetPoseParameterRange ( int index , float & minValue , float & maxValue )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( pStudioHdr )
{
if ( index > = 0 & & index < pStudioHdr - > GetNumPoseParameters ( ) )
{
const mstudioposeparamdesc_t & pose = pStudioHdr - > pPoseParameter ( index ) ;
minValue = pose . start ;
maxValue = pose . end ;
return true ;
}
}
minValue = 0.0f ;
maxValue = 1.0f ;
return false ;
}
//=========================================================
//=========================================================
int CBaseAnimating : : LookupPoseParameter ( CStudioHdr * pStudioHdr , const char * szName )
{
if ( ! pStudioHdr )
return 0 ;
if ( ! pStudioHdr - > SequencesAvailable ( ) )
{
return 0 ;
}
for ( int i = 0 ; i < pStudioHdr - > GetNumPoseParameters ( ) ; i + + )
{
if ( Q_stricmp ( pStudioHdr - > pPoseParameter ( i ) . pszName ( ) , szName ) = = 0 )
{
return i ;
}
}
// AssertMsg( 0, UTIL_VarArgs( "poseparameter %s couldn't be mapped!!!\n", szName ) );
return - 1 ; // Error
}
//=========================================================
//=========================================================
bool CBaseAnimating : : HasPoseParameter ( int iSequence , const char * szName )
{
int iParameter = LookupPoseParameter ( szName ) ;
if ( iParameter = = - 1 )
{
return false ;
}
return HasPoseParameter ( iSequence , iParameter ) ;
}
//=========================================================
//=========================================================
bool CBaseAnimating : : HasPoseParameter ( int iSequence , int iParameter )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
{
return false ;
}
if ( ! pstudiohdr - > SequencesAvailable ( ) )
{
return false ;
}
if ( iSequence < 0 | | iSequence > = pstudiohdr - > GetNumSeq ( ) )
{
return false ;
}
mstudioseqdesc_t & seqdesc = pstudiohdr - > pSeqdesc ( iSequence ) ;
if ( pstudiohdr - > GetSharedPoseParameter ( iSequence , seqdesc . paramindex [ 0 ] ) = = iParameter | |
pstudiohdr - > GetSharedPoseParameter ( iSequence , seqdesc . paramindex [ 1 ] ) = = iParameter )
{
return true ;
}
return false ;
}
//=========================================================
// Each class that wants to use pose parameters should populate
// static variables in this entry point, rather than calling
// GetPoseParameter(const char*) every time you want to adjust
// an animation.
//
// Make sure to call BaseClass::PopulatePoseParameters() at
// the *bottom* of your function.
//=========================================================
void CBaseAnimating : : PopulatePoseParameters ( void )
{
}
//=========================================================
// Purpose: from input of 75% to 200% of maximum range, rescale smoothly from 75% to 100%
//=========================================================
float CBaseAnimating : : EdgeLimitPoseParameter ( int iParameter , float flValue , float flBase )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
{
return flValue ;
}
if ( iParameter < 0 | | iParameter > = pstudiohdr - > GetNumPoseParameters ( ) )
{
return flValue ;
}
const mstudioposeparamdesc_t & Pose = pstudiohdr - > pPoseParameter ( iParameter ) ;
if ( Pose . loop | | Pose . start = = Pose . end )
{
return flValue ;
}
return RangeCompressor ( flValue , Pose . start , Pose . end , flBase ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns index number of a given named bone
// Input : name of a bone
// Output : Bone index number or -1 if bone not found
//-----------------------------------------------------------------------------
int CBaseAnimating : : LookupBone ( const char * szName )
{
const CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
Assert ( pStudioHdr ) ;
if ( ! pStudioHdr )
return - 1 ;
return Studio_BoneIndexByName ( pStudioHdr , szName ) ;
}
//=========================================================
//=========================================================
void CBaseAnimating : : GetBonePosition ( int iBone , Vector & origin , QAngle & angles )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
{
Assert ( ! " CBaseAnimating::GetBonePosition: model missing " ) ;
return ;
}
if ( iBone < 0 | | iBone > = pStudioHdr - > numbones ( ) )
{
Assert ( ! " CBaseAnimating::GetBonePosition: invalid bone index " ) ;
return ;
}
matrix3x4_t bonetoworld ;
GetBoneTransform ( iBone , bonetoworld ) ;
MatrixAngles ( bonetoworld , angles , origin ) ;
}
//=========================================================
//=========================================================
void CBaseAnimating : : GetBoneTransform ( int iBone , matrix3x4_t & pBoneToWorld )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
{
Assert ( ! " CBaseAnimating::GetBoneTransform: model missing " ) ;
return ;
}
if ( iBone < 0 | | iBone > = pStudioHdr - > numbones ( ) )
{
Assert ( ! " CBaseAnimating::GetBoneTransform: invalid bone index " ) ;
return ;
}
CBoneCache * pcache = GetBoneCache ( ) ;
matrix3x4_t * pmatrix = pcache - > GetCachedBone ( iBone ) ;
if ( ! pmatrix )
{
MatrixCopy ( EntityToWorldTransform ( ) , pBoneToWorld ) ;
return ;
}
Assert ( pmatrix ) ;
// FIXME
MatrixCopy ( * pmatrix , pBoneToWorld ) ;
}
class CTraceFilterSkipNPCs : public CTraceFilterSimple
{
public :
CTraceFilterSkipNPCs ( const IHandleEntity * passentity , int collisionGroup )
: CTraceFilterSimple ( passentity , collisionGroup )
{
}
virtual bool ShouldHitEntity ( IHandleEntity * pServerEntity , int contentsMask )
{
if ( CTraceFilterSimple : : ShouldHitEntity ( pServerEntity , contentsMask ) )
{
CBaseEntity * pEntity = EntityFromEntityHandle ( pServerEntity ) ;
if ( pEntity - > IsNPC ( ) )
return false ;
return true ;
}
return false ;
}
} ;
//-----------------------------------------------------------------------------
// Purpose: Receives the clients IK floor position
//-----------------------------------------------------------------------------
void CBaseAnimating : : SetIKGroundContactInfo ( float minHeight , float maxHeight )
{
m_flIKGroundContactTime = gpGlobals - > curtime ;
m_flIKGroundMinHeight = minHeight ;
m_flIKGroundMaxHeight = maxHeight ;
}
//-----------------------------------------------------------------------------
// Purpose: Initializes IK floor position
//-----------------------------------------------------------------------------
void CBaseAnimating : : InitStepHeightAdjust ( void )
{
m_flIKGroundContactTime = 0 ;
m_flIKGroundMinHeight = 0 ;
m_flIKGroundMaxHeight = 0 ;
// FIXME: not safe to call GetAbsOrigin here. Hierarchy might not be set up!
m_flEstIkFloor = GetAbsOrigin ( ) . z ;
m_flEstIkOffset = 0 ;
}
//-----------------------------------------------------------------------------
// Purpose: Interpolates client IK floor position and drops entity down so that the feet will reach
//-----------------------------------------------------------------------------
ConVar npc_height_adjust ( " npc_height_adjust " , " 1 " , FCVAR_ARCHIVE , " Enable test mode for ik height adjustment " ) ;
void CBaseAnimating : : UpdateStepOrigin ( )
{
if ( ! npc_height_adjust . GetBool ( ) )
{
m_flEstIkOffset = 0 ;
m_flEstIkFloor = GetLocalOrigin ( ) . z ;
return ;
}
/*
if ( m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
{
Msg ( " %x : %x \n " , GetMoveParent ( ) , GetGroundEntity ( ) ) ;
}
*/
if ( m_flIKGroundContactTime > 0.2 & & m_flIKGroundContactTime > gpGlobals - > curtime - 0.2 )
{
if ( ( GetFlags ( ) & ( FL_FLY | FL_SWIM ) ) = = 0 & & GetMoveParent ( ) = = NULL & & GetGroundEntity ( ) ! = NULL & & ! GetGroundEntity ( ) - > IsMoving ( ) )
{
Vector toAbs = GetAbsOrigin ( ) - GetLocalOrigin ( ) ;
if ( toAbs . z = = 0.0 )
{
CAI_BaseNPC * pNPC = MyNPCPointer ( ) ;
// FIXME: There needs to be a default step height somewhere
float height = 18.0f ;
if ( pNPC )
{
height = pNPC - > StepHeight ( ) ;
}
// debounce floor location
m_flEstIkFloor = m_flEstIkFloor * 0.2 + m_flIKGroundMinHeight * 0.8 ;
// don't let heigth difference between min and max exceed step height
float bias = clamp ( ( m_flIKGroundMaxHeight - m_flIKGroundMinHeight ) - height , 0.f , height ) ;
// save off reasonable offset
m_flEstIkOffset = clamp ( m_flEstIkFloor - GetAbsOrigin ( ) . z , - height + bias , 0.0f ) ;
return ;
}
}
}
// don't use floor offset, decay the value
m_flEstIkOffset * = 0.5 ;
m_flEstIkFloor = GetLocalOrigin ( ) . z ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the origin to use for model rendering
//-----------------------------------------------------------------------------
Vector CBaseAnimating : : GetStepOrigin ( void ) const
{
Vector tmp = GetLocalOrigin ( ) ;
tmp . z + = m_flEstIkOffset ;
return tmp ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the origin to use for model rendering
//-----------------------------------------------------------------------------
QAngle CBaseAnimating : : GetStepAngles ( void ) const
{
// TODO: Add in body lean
return GetLocalAngles ( ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Find IK collisions with world
// Input :
// Output : fills out m_pIk targets, calcs floor offset for rendering
//-----------------------------------------------------------------------------
void CBaseAnimating : : CalculateIKLocks ( float currentTime )
{
if ( m_pIk )
{
Ray_t ray ;
CTraceFilterSkipNPCs traceFilter ( this , GetCollisionGroup ( ) ) ;
Vector up ;
GetVectors ( NULL , NULL , & up ) ;
// FIXME: check number of slots?
for ( int i = 0 ; i < m_pIk - > m_target . Count ( ) ; i + + )
{
trace_t trace ;
CIKTarget * pTarget = & m_pIk - > m_target [ i ] ;
if ( ! pTarget - > IsActive ( ) )
continue ;
switch ( pTarget - > type )
{
case IK_GROUND :
{
Vector estGround ;
estGround = ( pTarget - > est . pos - GetAbsOrigin ( ) ) ;
estGround = estGround - ( estGround * up ) * up ;
estGround = GetAbsOrigin ( ) + estGround + pTarget - > est . floor * up ;
Vector p1 , p2 ;
VectorMA ( estGround , pTarget - > est . height , up , p1 ) ;
VectorMA ( estGround , - pTarget - > est . height , up , p2 ) ;
float r = MAX ( pTarget - > est . radius , 1 ) ;
// don't IK to other characters
ray . Init ( p1 , p2 , Vector ( - r , - r , 0 ) , Vector ( r , r , 1 ) ) ;
enginetrace - > TraceRay ( ray , MASK_SOLID , & traceFilter , & trace ) ;
/*
2022-03-01 20:00:42 +00:00
debugoverlay - > AddBoxOverlay ( p1 , Vector ( - r , - r , 0 ) , Vector ( r , r , 1 ) , QAngle ( 0 , 0 , 0 ) , 255 , 0 , 0 , 0 , 1.0f ) ;
debugoverlay - > AddBoxOverlay ( trace . endpos , Vector ( - r , - r , 0 ) , Vector ( r , r , 1 ) , QAngle ( 0 , 0 , 0 ) , 255 , 0 , 0 , 0 , 1.0f ) ;
debugoverlay - > AddLineOverlay ( p1 , trace . endpos , 255 , 0 , 0 , 0 , 1.0f ) ;
2020-04-22 16:56:21 +00:00
*/
if ( trace . startsolid )
{
ray . Init ( pTarget - > trace . hip , pTarget - > est . pos , Vector ( - r , - r , 0 ) , Vector ( r , r , 1 ) ) ;
enginetrace - > TraceRay ( ray , MASK_SOLID , & traceFilter , & trace ) ;
p1 = trace . endpos ;
VectorMA ( p1 , - pTarget - > est . height , up , p2 ) ;
ray . Init ( p1 , p2 , Vector ( - r , - r , 0 ) , Vector ( r , r , 1 ) ) ;
enginetrace - > TraceRay ( ray , MASK_SOLID , & traceFilter , & trace ) ;
}
if ( ! trace . startsolid )
{
if ( trace . DidHitWorld ( ) )
{
pTarget - > SetPosWithNormalOffset ( trace . endpos , trace . plane . normal ) ;
pTarget - > SetNormal ( trace . plane . normal ) ;
}
else
{
pTarget - > SetPos ( trace . endpos ) ;
pTarget - > SetAngles ( GetAbsAngles ( ) ) ;
}
}
}
break ;
case IK_ATTACHMENT :
{
// anything on the server?
}
break ;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Clear out animation states that are invalidated with Teleport
//-----------------------------------------------------------------------------
void CBaseAnimating : : Teleport ( const Vector * newPosition , const QAngle * newAngles , const Vector * newVelocity )
{
BaseClass : : Teleport ( newPosition , newAngles , newVelocity ) ;
if ( m_pIk )
{
m_pIk - > ClearTargets ( ) ;
}
InitStepHeightAdjust ( ) ;
}
//-----------------------------------------------------------------------------
// Purpose: build matrices first from the parent, then from the passed in arrays if the bone doesn't exist on the parent
//-----------------------------------------------------------------------------
void CBaseAnimating : : 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
)
{
CStudioHdr * fhdr = pParent - > GetModelPtr ( ) ;
mstudiobone_t * pbones = pStudioHdr - > pBone ( 0 ) ;
matrix3x4_t rotationmatrix ; // model to world transformation
AngleMatrix ( angles , origin , rotationmatrix ) ;
for ( int i = 0 ; i < pStudioHdr - > numbones ( ) ; i + + )
{
// Now find the bone in the parent entity.
bool merged = false ;
int parentBoneIndex = Studio_BoneIndexByName ( fhdr , pbones [ i ] . pszName ( ) ) ;
if ( parentBoneIndex > = 0 )
{
matrix3x4_t * pMat = pParentCache - > GetCachedBone ( parentBoneIndex ) ;
if ( pMat )
{
MatrixCopy ( * pMat , bonetoworld [ i ] ) ;
merged = true ;
}
}
if ( ! merged )
{
// If we get down here, then the bone wasn't merged.
matrix3x4_t bonematrix ;
QuaternionMatrix ( q [ i ] , pos [ i ] , bonematrix ) ;
if ( pbones [ i ] . parent = = - 1 )
{
ConcatTransforms ( rotationmatrix , bonematrix , bonetoworld [ i ] ) ;
}
else
{
ConcatTransforms ( bonetoworld [ pbones [ i ] . parent ] , bonematrix , bonetoworld [ i ] ) ;
}
}
}
}
ConVar sv_pvsskipanimation ( " sv_pvsskipanimation " , " 1 " , FCVAR_ARCHIVE , " Skips SetupBones when npc's are outside the PVS " ) ;
ConVar ai_setupbones_debug ( " ai_setupbones_debug " , " 0 " , 0 , " Shows that bones that are setup every think " ) ;
inline bool CBaseAnimating : : CanSkipAnimation ( void )
{
if ( ! sv_pvsskipanimation . GetBool ( ) )
return false ;
CAI_BaseNPC * pNPC = MyNPCPointer ( ) ;
if ( pNPC & & ! pNPC - > HasCondition ( COND_IN_PVS ) & & ( m_fBoneCacheFlags & ( BCF_NO_ANIMATION_SKIP | BCF_IS_IN_SPAWN ) ) = = false )
{
// If we have a player as a child, then we better setup our bones. If we don't,
// the PVS will be screwy.
return ! DoesHavePlayerChild ( ) ;
}
else
{
return false ;
}
}
void CBaseAnimating : : SetupBones ( matrix3x4_t * pBoneToWorld , int boneMask )
{
AUTO_LOCK ( m_BoneSetupMutex ) ;
VPROF_BUDGET ( " CBaseAnimating::SetupBones " , VPROF_BUDGETGROUP_SERVER_ANIM ) ;
MDLCACHE_CRITICAL_SECTION ( ) ;
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
{
Assert ( ! " CBaseAnimating::GetSkeleton() without a model " ) ;
return ;
}
Assert ( ! IsEFlagSet ( EFL_SETTING_UP_BONES ) ) ;
AddEFlags ( EFL_SETTING_UP_BONES ) ;
Vector pos [ MAXSTUDIOBONES ] ;
Quaternion q [ MAXSTUDIOBONES ] ;
// adjust hit boxes based on IK driven offset
Vector adjOrigin = GetAbsOrigin ( ) + Vector ( 0 , 0 , m_flEstIkOffset ) ;
if ( CanSkipAnimation ( ) )
{
IBoneSetup boneSetup ( pStudioHdr , boneMask , GetPoseParameterArray ( ) ) ;
boneSetup . InitPose ( pos , q ) ;
// Msg( "%.03f : %s:%s not in pvs\n", gpGlobals->curtime, GetClassname(), GetEntityName().ToCStr() );
}
else
{
if ( m_pIk )
{
// FIXME: pass this into Studio_BuildMatrices to skip transforms
CBoneBitList boneComputed ;
m_iIKCounter + + ;
m_pIk - > Init ( pStudioHdr , GetAbsAngles ( ) , adjOrigin , gpGlobals - > curtime , m_iIKCounter , boneMask ) ;
GetSkeleton ( pStudioHdr , pos , q , boneMask ) ;
m_pIk - > UpdateTargets ( pos , q , pBoneToWorld , boneComputed ) ;
CalculateIKLocks ( gpGlobals - > curtime ) ;
m_pIk - > SolveDependencies ( pos , q , pBoneToWorld , boneComputed ) ;
}
else
{
// Msg( "%.03f : %s:%s\n", gpGlobals->curtime, GetClassname(), GetEntityName().ToCStr() );
GetSkeleton ( pStudioHdr , pos , q , boneMask ) ;
}
}
CBaseAnimating * pParent = dynamic_cast < CBaseAnimating * > ( GetMoveParent ( ) ) ;
if ( pParent )
{
// We're doing bone merging, so do special stuff here.
CBoneCache * pParentCache = pParent - > GetBoneCache ( ) ;
if ( pParentCache )
{
BuildMatricesWithBoneMerge (
pStudioHdr ,
GetAbsAngles ( ) ,
adjOrigin ,
pos ,
q ,
pBoneToWorld ,
pParent ,
pParentCache ) ;
RemoveEFlags ( EFL_SETTING_UP_BONES ) ;
if ( ai_setupbones_debug . GetBool ( ) )
{
DrawRawSkeleton ( pBoneToWorld , boneMask , true , 0.11 ) ;
}
return ;
}
}
Studio_BuildMatrices (
pStudioHdr ,
GetAbsAngles ( ) ,
adjOrigin ,
pos ,
q ,
- 1 ,
GetModelScale ( ) , // Scaling
pBoneToWorld ,
boneMask ) ;
if ( ai_setupbones_debug . GetBool ( ) )
{
// Msg("%s:%s:%s (%x)\n", GetClassname(), GetDebugName(), STRING(GetModelName()), boneMask );
DrawRawSkeleton ( pBoneToWorld , boneMask , true , 0.11 ) ;
}
RemoveEFlags ( EFL_SETTING_UP_BONES ) ;
}
//=========================================================
//=========================================================
int CBaseAnimating : : GetNumBones ( void )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( pStudioHdr )
{
return pStudioHdr - > numbones ( ) ;
}
else
{
Assert ( ! " CBaseAnimating::GetNumBones: model missing " ) ;
return 0 ;
}
}
//=========================================================
//=========================================================
//-----------------------------------------------------------------------------
// Purpose: Returns index number of a given named attachment
// Input : name of attachment
// Output : attachment index number or -1 if attachment not found
//-----------------------------------------------------------------------------
int CBaseAnimating : : LookupAttachment ( const char * szName )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
{
Assert ( ! " CBaseAnimating::LookupAttachment: model missing " ) ;
return 0 ;
}
// The +1 is to make attachment indices be 1-based (namely 0 == invalid or unused attachment)
return Studio_FindAttachment ( pStudioHdr , szName ) + 1 ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the world location and world angles of an attachment
// Input : attachment name
// Output : location and angles
//-----------------------------------------------------------------------------
bool CBaseAnimating : : GetAttachment ( const char * szName , Vector & absOrigin , QAngle & absAngles )
{
return GetAttachment ( LookupAttachment ( szName ) , absOrigin , absAngles ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the world location and world angles of an attachment
// Input : attachment index
// Output : location and angles
//-----------------------------------------------------------------------------
bool CBaseAnimating : : GetAttachment ( int iAttachment , Vector & absOrigin , QAngle & absAngles )
{
matrix3x4_t attachmentToWorld ;
bool bRet = GetAttachment ( iAttachment , attachmentToWorld ) ;
MatrixAngles ( attachmentToWorld , absAngles , absOrigin ) ;
return bRet ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the world location and world angles of an attachment
// Input : attachment index
// Output : location and angles
//-----------------------------------------------------------------------------
bool CBaseAnimating : : GetAttachment ( int iAttachment , matrix3x4_t & attachmentToWorld )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
{
MatrixCopy ( EntityToWorldTransform ( ) , attachmentToWorld ) ;
AssertOnce ( ! " CBaseAnimating::GetAttachment: model missing " ) ;
return false ;
}
if ( iAttachment < 1 | | iAttachment > pStudioHdr - > GetNumAttachments ( ) )
{
MatrixCopy ( EntityToWorldTransform ( ) , attachmentToWorld ) ;
// Assert(!"CBaseAnimating::GetAttachment: invalid attachment index");
return false ;
}
const mstudioattachment_t & pattachment = pStudioHdr - > pAttachment ( iAttachment - 1 ) ;
int iBone = pStudioHdr - > GetAttachmentBone ( iAttachment - 1 ) ;
matrix3x4_t bonetoworld ;
GetBoneTransform ( iBone , bonetoworld ) ;
if ( ( pattachment . flags & ATTACHMENT_FLAG_WORLD_ALIGN ) = = 0 )
{
ConcatTransforms ( bonetoworld , pattachment . local , attachmentToWorld ) ;
}
else
{
Vector vecLocalBonePos , vecWorldBonePos ;
MatrixGetColumn ( pattachment . local , 3 , vecLocalBonePos ) ;
VectorTransform ( vecLocalBonePos , bonetoworld , vecWorldBonePos ) ;
SetIdentityMatrix ( attachmentToWorld ) ;
MatrixSetColumn ( vecWorldBonePos , 3 , attachmentToWorld ) ;
}
return true ;
}
// gets the bone for an attachment
int CBaseAnimating : : GetAttachmentBone ( int iAttachment )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr | | iAttachment < 1 | | iAttachment > pStudioHdr - > GetNumAttachments ( ) )
{
AssertOnce ( pStudioHdr & & " CBaseAnimating::GetAttachment: model missing " ) ;
return 0 ;
}
return pStudioHdr - > GetAttachmentBone ( iAttachment - 1 ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the world location of an attachment
// Input : attachment index
// Output : location and angles
//-----------------------------------------------------------------------------
bool CBaseAnimating : : GetAttachment ( const char * szName , Vector & absOrigin , Vector * forward , Vector * right , Vector * up )
{
return GetAttachment ( LookupAttachment ( szName ) , absOrigin , forward , right , up ) ;
}
bool CBaseAnimating : : GetAttachment ( int iAttachment , Vector & absOrigin , Vector * forward , Vector * right , Vector * up )
{
matrix3x4_t attachmentToWorld ;
bool bRet = GetAttachment ( iAttachment , attachmentToWorld ) ;
MatrixPosition ( attachmentToWorld , absOrigin ) ;
if ( forward )
{
MatrixGetColumn ( attachmentToWorld , 0 , forward ) ;
}
if ( right )
{
MatrixGetColumn ( attachmentToWorld , 1 , right ) ;
}
if ( up )
{
MatrixGetColumn ( attachmentToWorld , 2 , up ) ;
}
return bRet ;
}
//-----------------------------------------------------------------------------
// Returns the attachment in local space
//-----------------------------------------------------------------------------
bool CBaseAnimating : : GetAttachmentLocal ( const char * szName , Vector & origin , QAngle & angles )
{
return GetAttachmentLocal ( LookupAttachment ( szName ) , origin , angles ) ;
}
bool CBaseAnimating : : GetAttachmentLocal ( int iAttachment , Vector & origin , QAngle & angles )
{
matrix3x4_t attachmentToEntity ;
bool bRet = GetAttachmentLocal ( iAttachment , attachmentToEntity ) ;
MatrixAngles ( attachmentToEntity , angles , origin ) ;
return bRet ;
}
bool CBaseAnimating : : GetAttachmentLocal ( int iAttachment , matrix3x4_t & attachmentToLocal )
{
matrix3x4_t attachmentToWorld ;
bool bRet = GetAttachment ( iAttachment , attachmentToWorld ) ;
matrix3x4_t worldToEntity ;
MatrixInvert ( EntityToWorldTransform ( ) , worldToEntity ) ;
ConcatTransforms ( worldToEntity , attachmentToWorld , attachmentToLocal ) ;
return bRet ;
}
//=========================================================
//=========================================================
void CBaseAnimating : : GetEyeballs ( Vector & origin , QAngle & angles )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
{
Assert ( ! " CBaseAnimating::GetAttachment: model missing " ) ;
return ;
}
for ( int iBodypart = 0 ; iBodypart < pStudioHdr - > numbodyparts ( ) ; iBodypart + + )
{
mstudiobodyparts_t * pBodypart = pStudioHdr - > pBodypart ( iBodypart ) ;
for ( int iModel = 0 ; iModel < pBodypart - > nummodels ; iModel + + )
{
mstudiomodel_t * pModel = pBodypart - > pModel ( iModel ) ;
for ( int iEyeball = 0 ; iEyeball < pModel - > numeyeballs ; iEyeball + + )
{
mstudioeyeball_t * pEyeball = pModel - > pEyeball ( iEyeball ) ;
matrix3x4_t bonetoworld ;
GetBoneTransform ( pEyeball - > bone , bonetoworld ) ;
VectorTransform ( pEyeball - > org , bonetoworld , origin ) ;
MatrixAngles ( bonetoworld , angles ) ; // ???
}
}
}
}
//=========================================================
//=========================================================
int CBaseAnimating : : FindTransitionSequence ( int iCurrentSequence , int iGoalSequence , int * piDir )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
if ( piDir = = NULL )
{
int iDir = 1 ;
int sequence = : : FindTransitionSequence ( GetModelPtr ( ) , iCurrentSequence , iGoalSequence , & iDir ) ;
if ( iDir ! = 1 )
return - 1 ;
else
return sequence ;
}
return : : FindTransitionSequence ( GetModelPtr ( ) , iCurrentSequence , iGoalSequence , piDir ) ;
}
bool CBaseAnimating : : GotoSequence ( int iCurrentSequence , float flCurrentCycle , float flCurrentRate , int iGoalSequence , int & nNextSequence , float & flNextCycle , int & iNextDir )
{
return : : GotoSequence ( GetModelPtr ( ) , iCurrentSequence , flCurrentCycle , flCurrentRate , iGoalSequence , nNextSequence , flNextCycle , iNextDir ) ;
}
int CBaseAnimating : : GetEntryNode ( int iSequence )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return 0 ;
return pstudiohdr - > EntryNode ( iSequence ) ;
}
int CBaseAnimating : : GetExitNode ( int iSequence )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return 0 ;
return pstudiohdr - > ExitNode ( iSequence ) ;
}
//=========================================================
//=========================================================
void CBaseAnimating : : SetBodygroup ( int iGroup , int iValue )
{
// SetBodygroup is not supported on pending dynamic models. Wait for it to load!
// XXX TODO we could buffer up the group and value if we really needed to. -henryg
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
int newBody = m_nBody ;
: : SetBodygroup ( GetModelPtr ( ) , newBody , iGroup , iValue ) ;
m_nBody = newBody ;
}
int CBaseAnimating : : GetBodygroup ( int iGroup )
{
Assert ( IsDynamicModelLoading ( ) | | GetModelPtr ( ) ) ;
return IsDynamicModelLoading ( ) ? 0 : : : GetBodygroup ( GetModelPtr ( ) , m_nBody , iGroup ) ;
}
const char * CBaseAnimating : : GetBodygroupName ( int iGroup )
{
Assert ( IsDynamicModelLoading ( ) | | GetModelPtr ( ) ) ;
return IsDynamicModelLoading ( ) ? " " : : : GetBodygroupName ( GetModelPtr ( ) , iGroup ) ;
}
int CBaseAnimating : : FindBodygroupByName ( const char * name )
{
Assert ( IsDynamicModelLoading ( ) | | GetModelPtr ( ) ) ;
return IsDynamicModelLoading ( ) ? - 1 : : : FindBodygroupByName ( GetModelPtr ( ) , name ) ;
}
int CBaseAnimating : : GetBodygroupCount ( int iGroup )
{
Assert ( IsDynamicModelLoading ( ) | | GetModelPtr ( ) ) ;
return IsDynamicModelLoading ( ) ? 0 : : : GetBodygroupCount ( GetModelPtr ( ) , iGroup ) ;
}
int CBaseAnimating : : GetNumBodyGroups ( void )
{
Assert ( IsDynamicModelLoading ( ) | | GetModelPtr ( ) ) ;
return IsDynamicModelLoading ( ) ? 0 : : : GetNumBodyGroups ( GetModelPtr ( ) ) ;
}
int CBaseAnimating : : ExtractBbox ( int sequence , Vector & mins , Vector & maxs )
{
Assert ( IsDynamicModelLoading ( ) | | GetModelPtr ( ) ) ;
return IsDynamicModelLoading ( ) ? 0 : : : ExtractBbox ( GetModelPtr ( ) , sequence , mins , maxs ) ;
}
//=========================================================
//=========================================================
void CBaseAnimating : : SetSequenceBox ( void )
{
Vector mins , maxs ;
// Get sequence bbox
if ( ExtractBbox ( GetSequence ( ) , mins , maxs ) )
{
// expand box for rotation
// find min / max for rotations
float yaw = GetLocalAngles ( ) . y * ( M_PI / 180.0 ) ;
Vector xvector , yvector ;
xvector . x = cos ( yaw ) ;
xvector . y = sin ( yaw ) ;
yvector . x = - sin ( yaw ) ;
yvector . y = cos ( yaw ) ;
Vector bounds [ 2 ] ;
bounds [ 0 ] = mins ;
bounds [ 1 ] = maxs ;
Vector rmin ( 9999 , 9999 , 9999 ) ;
Vector rmax ( - 9999 , - 9999 , - 9999 ) ;
Vector base , transformed ;
for ( int i = 0 ; i < = 1 ; i + + )
{
base . x = bounds [ i ] . x ;
for ( int j = 0 ; j < = 1 ; j + + )
{
base . y = bounds [ j ] . y ;
for ( int k = 0 ; k < = 1 ; k + + )
{
base . z = bounds [ k ] . z ;
// transform the point
transformed . x = xvector . x * base . x + yvector . x * base . y ;
transformed . y = xvector . y * base . x + yvector . y * base . y ;
transformed . z = base . z ;
for ( int l = 0 ; l < 3 ; l + + )
{
if ( transformed [ l ] < rmin [ l ] )
rmin [ l ] = transformed [ l ] ;
if ( transformed [ l ] > rmax [ l ] )
rmax [ l ] = transformed [ l ] ;
}
}
}
}
rmin . z = 0 ;
rmax . z = rmin . z + 1 ;
UTIL_SetSize ( this , rmin , rmax ) ;
}
}
//=========================================================
//=========================================================
int CBaseAnimating : : RegisterPrivateActivity ( const char * pszActivityName )
{
return ActivityList_RegisterPrivateActivity ( pszActivityName ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Notifies the console that this entity could not retrieve an
// animation sequence for the specified activity. This probably means
// there's a typo in the model QC file, or the sequence is missing
// entirely.
//
//
// Input : iActivity - The activity that failed to resolve to a sequence.
//
//
// NOTE : IMPORTANT - Something needs to be done so that private activities
// (which are allowed to collide in the activity list) remember each
// entity that registered an activity there, and the activity name
// each character registered.
//-----------------------------------------------------------------------------
void CBaseAnimating : : ReportMissingActivity ( int iActivity )
{
Msg ( " %s has no sequence for act:%s \n " , GetClassname ( ) , ActivityList_NameForIndex ( iActivity ) ) ;
}
LocalFlexController_t CBaseAnimating : : GetNumFlexControllers ( void )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return LocalFlexController_t ( 0 ) ;
return pstudiohdr - > numflexcontrollers ( ) ;
}
const char * CBaseAnimating : : GetFlexDescFacs ( int iFlexDesc )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return 0 ;
mstudioflexdesc_t * pflexdesc = pstudiohdr - > pFlexdesc ( iFlexDesc ) ;
return pflexdesc - > pszFACS ( ) ;
}
const char * CBaseAnimating : : GetFlexControllerName ( LocalFlexController_t iFlexController )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return 0 ;
mstudioflexcontroller_t * pflexcontroller = pstudiohdr - > pFlexcontroller ( iFlexController ) ;
return pflexcontroller - > pszName ( ) ;
}
const char * CBaseAnimating : : GetFlexControllerType ( LocalFlexController_t iFlexController )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return 0 ;
mstudioflexcontroller_t * pflexcontroller = pstudiohdr - > pFlexcontroller ( iFlexController ) ;
return pflexcontroller - > pszType ( ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Converts the ground speed of the animating entity into a true velocity
// Output : Vector - velocity of the character at its current m_flGroundSpeed
//-----------------------------------------------------------------------------
Vector CBaseAnimating : : GetGroundSpeedVelocity ( void )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return vec3_origin ;
QAngle vecAngles ;
Vector vecVelocity ;
vecAngles . y = GetSequenceMoveYaw ( GetSequence ( ) ) ;
vecAngles . x = 0 ;
vecAngles . z = 0 ;
vecAngles . y + = GetLocalAngles ( ) . y ;
AngleVectors ( vecAngles , & vecVelocity ) ;
vecVelocity = vecVelocity * m_flGroundSpeed ;
return vecVelocity ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
float CBaseAnimating : : GetInstantaneousVelocity ( float flInterval )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return 0 ;
// FIXME: someone needs to check for last frame, etc.
float flNextCycle = GetCycle ( ) + flInterval * GetSequenceCycleRate ( GetSequence ( ) ) * m_flPlaybackRate ;
Vector vecVelocity ;
Studio_SeqVelocity ( pstudiohdr , GetSequence ( ) , flNextCycle , GetPoseParameterArray ( ) , vecVelocity ) ;
vecVelocity * = m_flPlaybackRate ;
return vecVelocity . Length ( ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
float CBaseAnimating : : GetEntryVelocity ( int iSequence )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return 0 ;
Vector vecVelocity ;
Studio_SeqVelocity ( pstudiohdr , iSequence , 0.0 , GetPoseParameterArray ( ) , vecVelocity ) ;
return vecVelocity . Length ( ) ;
}
float CBaseAnimating : : GetExitVelocity ( int iSequence )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return 0 ;
Vector vecVelocity ;
Studio_SeqVelocity ( pstudiohdr , iSequence , 1.0 , GetPoseParameterArray ( ) , vecVelocity ) ;
return vecVelocity . Length ( ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
bool CBaseAnimating : : GetIntervalMovement ( float flIntervalUsed , bool & bMoveSeqFinished , Vector & newPosition , QAngle & newAngles )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr | | ! pstudiohdr - > SequencesAvailable ( ) )
return false ;
float flComputedCycleRate = GetSequenceCycleRate ( GetSequence ( ) ) ;
float flNextCycle = GetCycle ( ) + flIntervalUsed * flComputedCycleRate * m_flPlaybackRate ;
if ( ( ! m_bSequenceLoops ) & & flNextCycle > 1.0 )
{
flIntervalUsed = GetCycle ( ) / ( flComputedCycleRate * m_flPlaybackRate ) ;
flNextCycle = 1.0 ;
bMoveSeqFinished = true ;
}
else
{
bMoveSeqFinished = false ;
}
Vector deltaPos ;
QAngle deltaAngles ;
if ( Studio_SeqMovement ( pstudiohdr , GetSequence ( ) , GetCycle ( ) , flNextCycle , GetPoseParameterArray ( ) , deltaPos , deltaAngles ) )
{
VectorYawRotate ( deltaPos , GetLocalAngles ( ) . y , deltaPos ) ;
newPosition = GetLocalOrigin ( ) + deltaPos ;
newAngles . Init ( ) ;
newAngles . y = GetLocalAngles ( ) . y + deltaAngles . y ;
return true ;
}
else
{
newPosition = GetLocalOrigin ( ) ;
newAngles = GetLocalAngles ( ) ;
return false ;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
bool CBaseAnimating : : GetSequenceMovement ( int nSequence , float fromCycle , float toCycle , Vector & deltaPosition , QAngle & deltaAngles )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return false ;
return Studio_SeqMovement ( pstudiohdr , nSequence , fromCycle , toCycle , GetPoseParameterArray ( ) , deltaPosition , deltaAngles ) ;
}
//-----------------------------------------------------------------------------
// Purpose: find frame where they animation has moved a given distance.
// Output :
//-----------------------------------------------------------------------------
float CBaseAnimating : : GetMovementFrame ( float flDist )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return 0 ;
float t = Studio_FindSeqDistance ( pstudiohdr , GetSequence ( ) , GetPoseParameterArray ( ) , flDist ) ;
return t ;
}
//-----------------------------------------------------------------------------
// Purpose: does a specific sequence have movement?
// Output :
//-----------------------------------------------------------------------------
bool CBaseAnimating : : HasMovement ( int iSequence )
{
CStudioHdr * pstudiohdr = GetModelPtr ( ) ;
if ( ! pstudiohdr )
return false ;
// FIXME: this needs to check to see if there are keys, and the object is walking
Vector deltaPos ;
QAngle deltaAngles ;
if ( Studio_SeqMovement ( pstudiohdr , iSequence , 0.0f , 1.0f , GetPoseParameterArray ( ) , deltaPos , deltaAngles ) )
{
return true ;
}
return false ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *szModelName -
//-----------------------------------------------------------------------------
void CBaseAnimating : : SetModel ( const char * szModelName )
{
MDLCACHE_CRITICAL_SECTION ( ) ;
// delete exiting studio model container
UnlockStudioHdr ( ) ;
delete m_pStudioHdr ;
m_pStudioHdr = NULL ;
if ( szModelName [ 0 ] )
{
int modelIndex = modelinfo - > GetModelIndex ( szModelName ) ;
const model_t * model = modelinfo - > GetModel ( modelIndex ) ;
if ( model & & ( modelinfo - > GetModelType ( model ) ! = mod_studio ) )
{
Msg ( " Setting CBaseAnimating to non-studio model %s (type:%i) \n " , szModelName , modelinfo - > GetModelType ( model ) ) ;
}
}
if ( m_boneCacheHandle )
{
Studio_DestroyBoneCache ( m_boneCacheHandle ) ;
m_boneCacheHandle = 0 ;
}
UTIL_SetModel ( this , szModelName ) ;
InitBoneControllers ( ) ;
SetSequence ( 0 ) ;
PopulatePoseParameters ( ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
//-----------------------------------------------------------------------------
void CBaseAnimating : : LockStudioHdr ( )
{
AUTO_LOCK ( m_StudioHdrInitLock ) ;
const model_t * mdl = GetModel ( ) ;
if ( mdl )
{
MDLHandle_t hStudioHdr = modelinfo - > GetCacheHandle ( mdl ) ;
if ( hStudioHdr ! = MDLHANDLE_INVALID )
{
const studiohdr_t * pStudioHdr = mdlcache - > LockStudioHdr ( hStudioHdr ) ;
CStudioHdr * pStudioHdrContainer = NULL ;
if ( ! m_pStudioHdr )
{
if ( pStudioHdr )
{
pStudioHdrContainer = new CStudioHdr ;
pStudioHdrContainer - > Init ( pStudioHdr , mdlcache ) ;
}
}
else
{
pStudioHdrContainer = m_pStudioHdr ;
}
Assert ( ( pStudioHdr = = NULL & & pStudioHdrContainer = = NULL ) | | pStudioHdrContainer - > GetRenderHdr ( ) = = pStudioHdr ) ;
if ( pStudioHdrContainer & & pStudioHdrContainer - > GetVirtualModel ( ) )
{
2022-02-23 11:50:30 +00:00
MDLHandle_t hVirtualModel = VoidPtrToMDLHandle ( pStudioHdrContainer - > GetRenderHdr ( ) - > VirtualModel ( ) ) ;
2020-04-22 16:56:21 +00:00
mdlcache - > LockStudioHdr ( hVirtualModel ) ;
}
m_pStudioHdr = pStudioHdrContainer ; // must be last to ensure virtual model correctly set up
}
}
}
void CBaseAnimating : : UnlockStudioHdr ( )
{
if ( m_pStudioHdr )
{
const model_t * mdl = GetModel ( ) ;
if ( mdl )
{
mdlcache - > UnlockStudioHdr ( modelinfo - > GetCacheHandle ( mdl ) ) ;
if ( m_pStudioHdr - > GetVirtualModel ( ) )
{
2022-02-23 11:50:30 +00:00
MDLHandle_t hVirtualModel = VoidPtrToMDLHandle ( m_pStudioHdr - > GetRenderHdr ( ) - > VirtualModel ( ) ) ;
2020-04-22 16:56:21 +00:00
mdlcache - > UnlockStudioHdr ( hVirtualModel ) ;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: return the index to the shared bone cache
// Output :
//-----------------------------------------------------------------------------
CBoneCache * CBaseAnimating : : GetBoneCache ( void )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
Assert ( pStudioHdr ) ;
CBoneCache * pcache = Studio_GetBoneCache ( m_boneCacheHandle ) ;
int boneMask = BONE_USED_BY_HITBOX | BONE_USED_BY_ATTACHMENT ;
// TF queries these bones to position weapons when players are killed
# if defined( TF_DLL )
boneMask | = BONE_USED_BY_BONE_MERGE ;
# endif
if ( pcache )
{
if ( pcache - > IsValid ( gpGlobals - > curtime ) & & ( pcache - > m_boneMask & boneMask ) = = boneMask & & pcache - > m_timeValid < = gpGlobals - > curtime )
{
// Msg("%s:%s:%s (%x:%x:%8.4f) cache\n", GetClassname(), GetDebugName(), STRING(GetModelName()), boneMask, pcache->m_boneMask, pcache->m_timeValid );
// in memory and still valid, use it!
return pcache ;
}
// in memory, but missing some of the bone masks
if ( ( pcache - > m_boneMask & boneMask ) ! = boneMask )
{
Studio_DestroyBoneCache ( m_boneCacheHandle ) ;
m_boneCacheHandle = 0 ;
pcache = NULL ;
}
}
matrix3x4_t bonetoworld [ MAXSTUDIOBONES ] ;
SetupBones ( bonetoworld , boneMask ) ;
if ( pcache )
{
// still in memory but out of date, refresh the bones.
pcache - > UpdateBones ( bonetoworld , pStudioHdr - > numbones ( ) , gpGlobals - > curtime ) ;
}
else
{
bonecacheparams_t params ;
params . pStudioHdr = pStudioHdr ;
params . pBoneToWorld = bonetoworld ;
params . curtime = gpGlobals - > curtime ;
params . boneMask = boneMask ;
m_boneCacheHandle = Studio_CreateBoneCache ( params ) ;
pcache = Studio_GetBoneCache ( m_boneCacheHandle ) ;
}
Assert ( pcache ) ;
return pcache ;
}
void CBaseAnimating : : InvalidateBoneCache ( void )
{
Studio_InvalidateBoneCache ( m_boneCacheHandle ) ;
}
bool CBaseAnimating : : TestCollision ( const Ray_t & ray , unsigned int fContentsMask , trace_t & tr )
{
// Return a special case for scaled physics objects
if ( GetModelScale ( ) ! = 1.0f )
{
IPhysicsObject * pPhysObject = VPhysicsGetObject ( ) ;
Vector vecPosition ;
QAngle vecAngles ;
pPhysObject - > GetPosition ( & vecPosition , & vecAngles ) ;
const CPhysCollide * pScaledCollide = pPhysObject - > GetCollide ( ) ;
physcollision - > TraceBox ( ray , pScaledCollide , vecPosition , vecAngles , & tr ) ;
return tr . DidHit ( ) ;
}
if ( IsSolidFlagSet ( FSOLID_CUSTOMRAYTEST ) )
{
if ( ! TestHitboxes ( ray , fContentsMask , tr ) )
return true ;
return tr . DidHit ( ) ;
}
// We shouldn't get here.
Assert ( 0 ) ;
return false ;
}
bool CBaseAnimating : : TestHitboxes ( const Ray_t & ray , unsigned int fContentsMask , trace_t & tr )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
{
Assert ( ! " CBaseAnimating::GetBonePosition: model missing " ) ;
return false ;
}
mstudiohitboxset_t * set = pStudioHdr - > pHitboxSet ( m_nHitboxSet ) ;
if ( ! set | | ! set - > numhitboxes )
return false ;
CBoneCache * pcache = GetBoneCache ( ) ;
matrix3x4_t * hitboxbones [ MAXSTUDIOBONES ] ;
pcache - > ReadCachedBonePointers ( hitboxbones , pStudioHdr - > numbones ( ) ) ;
if ( TraceToStudio ( physprops , ray , pStudioHdr , set , hitboxbones , fContentsMask , GetAbsOrigin ( ) , GetModelScale ( ) , tr ) )
{
mstudiobbox_t * pbox = set - > pHitbox ( tr . hitbox ) ;
mstudiobone_t * pBone = pStudioHdr - > pBone ( pbox - > bone ) ;
tr . surface . name = " **studio** " ;
tr . surface . flags = SURF_HITBOX ;
tr . surface . surfaceProps = physprops - > GetSurfaceIndex ( pBone - > pszSurfaceProp ( ) ) ;
}
return true ;
}
void CBaseAnimating : : InitBoneControllers ( void ) // FIXME: rename
{
int i ;
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
return ;
int nBoneControllerCount = pStudioHdr - > numbonecontrollers ( ) ;
if ( nBoneControllerCount > NUM_BONECTRLS )
{
nBoneControllerCount = NUM_BONECTRLS ;
# ifdef _DEBUG
Warning ( " Model %s has too many bone controllers! (Max %d allowed) \n " , pStudioHdr - > pszName ( ) , NUM_BONECTRLS ) ;
# endif
}
for ( i = 0 ; i < nBoneControllerCount ; i + + )
{
SetBoneController ( i , 0.0 ) ;
}
Assert ( pStudioHdr - > SequencesAvailable ( ) ) ;
if ( pStudioHdr - > SequencesAvailable ( ) )
{
for ( i = 0 ; i < pStudioHdr - > GetNumPoseParameters ( ) ; i + + )
{
SetPoseParameter ( i , 0.0 ) ;
}
}
}
//=========================================================
//=========================================================
float CBaseAnimating : : SetBoneController ( int iController , float flValue )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
CStudioHdr * pmodel = ( CStudioHdr * ) GetModelPtr ( ) ;
Assert ( iController > = 0 & & iController < NUM_BONECTRLS ) ;
float newValue ;
float retVal = Studio_SetController ( pmodel , iController , flValue , newValue ) ;
m_flEncodedController . Set ( iController , newValue ) ;
return retVal ;
}
//=========================================================
//=========================================================
float CBaseAnimating : : GetBoneController ( int iController )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
CStudioHdr * pmodel = ( CStudioHdr * ) GetModelPtr ( ) ;
return Studio_GetController ( pmodel , iController , m_flEncodedController [ iController ] ) ;
}
//------------------------------------------------------------------------------
// Purpose : Returns velcocity of the NPC from it's animation.
// If physically simulated gets velocity from physics object
// Input :
// Output :
//------------------------------------------------------------------------------
void CBaseAnimating : : GetVelocity ( Vector * vVelocity , AngularImpulse * vAngVelocity )
{
if ( GetMoveType ( ) = = MOVETYPE_VPHYSICS )
{
BaseClass : : GetVelocity ( vVelocity , vAngVelocity ) ;
}
else if ( ! ( GetFlags ( ) & FL_ONGROUND ) )
{
BaseClass : : GetVelocity ( vVelocity , vAngVelocity ) ;
}
else
{
if ( vVelocity ! = NULL )
{
Vector vRawVel ;
GetSequenceLinearMotion ( GetSequence ( ) , & vRawVel ) ;
// Build a rotation matrix from NPC orientation
matrix3x4_t fRotateMatrix ;
AngleMatrix ( GetLocalAngles ( ) , fRotateMatrix ) ;
VectorRotate ( vRawVel , fRotateMatrix , * vVelocity ) ;
}
if ( vAngVelocity ! = NULL )
{
QAngle tmp = GetLocalAngularVelocity ( ) ;
QAngleToAngularImpulse ( tmp , * vAngVelocity ) ;
}
}
}
//=========================================================
//=========================================================
void CBaseAnimating : : GetSkeleton ( CStudioHdr * pStudioHdr , Vector pos [ ] , Quaternion q [ ] , int boneMask )
{
if ( ! pStudioHdr )
{
Assert ( ! " CBaseAnimating::GetSkeleton() without a model " ) ;
return ;
}
IBoneSetup boneSetup ( pStudioHdr , boneMask , GetPoseParameterArray ( ) ) ;
boneSetup . InitPose ( pos , q ) ;
boneSetup . AccumulatePose ( pos , q , GetSequence ( ) , GetCycle ( ) , 1.0 , gpGlobals - > curtime , m_pIk ) ;
if ( m_pIk )
{
CIKContext auto_ik ;
auto_ik . Init ( pStudioHdr , GetAbsAngles ( ) , GetAbsOrigin ( ) , gpGlobals - > curtime , 0 , boneMask ) ;
boneSetup . CalcAutoplaySequences ( pos , q , gpGlobals - > curtime , & auto_ik ) ;
}
else
{
boneSetup . CalcAutoplaySequences ( pos , q , gpGlobals - > curtime , NULL ) ;
}
boneSetup . CalcBoneAdj ( pos , q , GetEncodedControllerArray ( ) ) ;
}
int CBaseAnimating : : DrawDebugTextOverlays ( void )
{
int text_offset = BaseClass : : DrawDebugTextOverlays ( ) ;
if ( m_debugOverlays & OVERLAY_TEXT_BIT )
{
// ----------------
// Print Look time
// ----------------
char tempstr [ 1024 ] ;
Q_snprintf ( tempstr , sizeof ( tempstr ) , " Sequence: (%3d) %s " , GetSequence ( ) , GetSequenceName ( GetSequence ( ) ) ) ;
EntityText ( text_offset , tempstr , 0 ) ;
text_offset + + ;
const char * pActname = GetSequenceActivityName ( GetSequence ( ) ) ;
if ( pActname & & strlen ( pActname ) )
{
Q_snprintf ( tempstr , sizeof ( tempstr ) , " Activity %s " , pActname ) ;
EntityText ( text_offset , tempstr , 0 ) ;
text_offset + + ;
}
Q_snprintf ( tempstr , sizeof ( tempstr ) , " Cycle: %.5f (%.5f) " , ( float ) GetCycle ( ) , m_flAnimTime . Get ( ) ) ;
EntityText ( text_offset , tempstr , 0 ) ;
text_offset + + ;
}
// Visualize attachment points
if ( m_debugOverlays & OVERLAY_ATTACHMENTS_BIT )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( pStudioHdr )
{
Vector vecPos , vecForward , vecRight , vecUp ;
char tempstr [ 256 ] ;
// Iterate all the stored attachments
for ( int i = 1 ; i < = pStudioHdr - > GetNumAttachments ( ) ; i + + )
{
GetAttachment ( i , vecPos , & vecForward , & vecRight , & vecUp ) ;
// Red - forward, green - right, blue - up
NDebugOverlay : : Line ( vecPos , vecPos + ( vecForward * 4.0f ) , 255 , 0 , 0 , true , 0.05f ) ;
NDebugOverlay : : Line ( vecPos , vecPos + ( vecRight * 4.0f ) , 0 , 255 , 0 , true , 0.05f ) ;
NDebugOverlay : : Line ( vecPos , vecPos + ( vecUp * 4.0f ) , 0 , 0 , 255 , true , 0.05f ) ;
Q_snprintf ( tempstr , sizeof ( tempstr ) , " < %s (%d) " , pStudioHdr - > pAttachment ( i - 1 ) . pszName ( ) , i ) ;
NDebugOverlay : : Text ( vecPos , tempstr , true , 0.05f ) ;
}
}
}
return text_offset ;
}
//-----------------------------------------------------------------------------
// Purpose: Force a clientside-animating entity to reset it's frame
//-----------------------------------------------------------------------------
void CBaseAnimating : : ResetClientsideFrame ( void )
{
// TODO: Once we can chain MSG_ENTITY messages, use one of them
m_bClientSideFrameReset = ! ( bool ) m_bClientSideFrameReset ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the origin at which to play an inputted dispatcheffect
//-----------------------------------------------------------------------------
void CBaseAnimating : : GetInputDispatchEffectPosition ( const char * sInputString , Vector & pOrigin , QAngle & pAngles )
{
// See if there's a specified attachment point
int iAttachment ;
if ( GetModelPtr ( ) & & sscanf ( sInputString , " %d " , & iAttachment ) )
{
if ( ! GetAttachment ( iAttachment , pOrigin , pAngles ) )
{
Msg ( " ERROR: Mapmaker tried to spawn DispatchEffect %s, but %s has no attachment %d \n " ,
sInputString , STRING ( GetModelName ( ) ) , iAttachment ) ;
}
return ;
}
BaseClass : : GetInputDispatchEffectPosition ( sInputString , pOrigin , pAngles ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : setnum -
//-----------------------------------------------------------------------------
void CBaseAnimating : : SetHitboxSet ( int setnum )
{
# ifdef _DEBUG
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
return ;
if ( setnum > pStudioHdr - > numhitboxsets ( ) )
{
// Warn if an bogus hitbox set is being used....
static bool s_bWarned = false ;
if ( ! s_bWarned )
{
Warning ( " Using bogus hitbox set in entity %s! \n " , GetClassname ( ) ) ;
s_bWarned = true ;
}
setnum = 0 ;
}
# endif
m_nHitboxSet = setnum ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *setname -
//-----------------------------------------------------------------------------
void CBaseAnimating : : SetHitboxSetByName ( const char * setname )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
m_nHitboxSet = FindHitboxSetByName ( GetModelPtr ( ) , setname ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CBaseAnimating : : GetHitboxSet ( void )
{
return m_nHitboxSet ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : char const
//-----------------------------------------------------------------------------
const char * CBaseAnimating : : GetHitboxSetName ( void )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
return : : GetHitboxSetName ( GetModelPtr ( ) , m_nHitboxSet ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CBaseAnimating : : GetHitboxSetCount ( void )
{
2022-03-01 20:00:42 +00:00
Assert ( GetModelPtr ( ) ) ;
2020-04-22 16:56:21 +00:00
return : : GetHitboxSetCount ( GetModelPtr ( ) ) ;
}
static Vector hullcolor [ 8 ] =
{
Vector ( 1.0 , 1.0 , 1.0 ) ,
Vector ( 1.0 , 0.5 , 0.5 ) ,
Vector ( 0.5 , 1.0 , 0.5 ) ,
Vector ( 1.0 , 1.0 , 0.5 ) ,
Vector ( 0.5 , 0.5 , 1.0 ) ,
Vector ( 1.0 , 0.5 , 1.0 ) ,
Vector ( 0.5 , 1.0 , 1.0 ) ,
Vector ( 1.0 , 1.0 , 1.0 )
} ;
//-----------------------------------------------------------------------------
// Purpose: Send the current hitboxes for this model to the client ( to compare with
// r_drawentities 3 client side boxes ).
// WARNING: This uses a ton of bandwidth, only use on a listen server
//-----------------------------------------------------------------------------
void CBaseAnimating : : DrawServerHitboxes ( float duration /*= 0.0f*/ , bool monocolor /*= false*/ )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
return ;
mstudiohitboxset_t * set = pStudioHdr - > pHitboxSet ( m_nHitboxSet ) ;
if ( ! set )
return ;
Vector position ;
QAngle angles ;
int r = 0 ;
int g = 0 ;
int b = 255 ;
for ( int i = 0 ; i < set - > numhitboxes ; i + + )
{
mstudiobbox_t * pbox = set - > pHitbox ( i ) ;
GetBonePosition ( pbox - > bone , position , angles ) ;
if ( ! monocolor )
{
int j = ( pbox - > group % 8 ) ;
r = ( int ) ( 255.0f * hullcolor [ j ] [ 0 ] ) ;
g = ( int ) ( 255.0f * hullcolor [ j ] [ 1 ] ) ;
b = ( int ) ( 255.0f * hullcolor [ j ] [ 2 ] ) ;
}
NDebugOverlay : : BoxAngles ( position , pbox - > bbmin * GetModelScale ( ) , pbox - > bbmax * GetModelScale ( ) , angles , r , g , b , 0 , duration ) ;
}
}
void CBaseAnimating : : DrawRawSkeleton ( matrix3x4_t boneToWorld [ ] , int boneMask , bool noDepthTest , float duration , bool monocolor )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
return ;
int i ;
int r = 255 ;
int g = 255 ;
int b = monocolor ? 255 : 0 ;
for ( i = 0 ; i < pStudioHdr - > numbones ( ) ; i + + )
{
if ( pStudioHdr - > pBone ( i ) - > flags & boneMask )
{
Vector p1 ;
MatrixPosition ( boneToWorld [ i ] , p1 ) ;
if ( pStudioHdr - > pBone ( i ) - > parent ! = - 1 )
{
Vector p2 ;
MatrixPosition ( boneToWorld [ pStudioHdr - > pBone ( i ) - > parent ] , p2 ) ;
NDebugOverlay : : Line ( p1 , p2 , r , g , b , noDepthTest , duration ) ;
}
}
}
}
int CBaseAnimating : : GetHitboxBone ( int hitboxIndex )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( pStudioHdr )
{
mstudiohitboxset_t * set = pStudioHdr - > pHitboxSet ( m_nHitboxSet ) ;
if ( set & & hitboxIndex < set - > numhitboxes )
{
return set - > pHitbox ( hitboxIndex ) - > bone ;
}
}
return 0 ;
}
//-----------------------------------------------------------------------------
// Computes a box that surrounds all hitboxes
//-----------------------------------------------------------------------------
bool CBaseAnimating : : ComputeHitboxSurroundingBox ( Vector * pVecWorldMins , Vector * pVecWorldMaxs )
{
// Note that this currently should not be called during Relink because of IK.
// The code below recomputes bones so as to get at the hitboxes,
// which causes IK to trigger, which causes raycasts against the other entities to occur,
// which is illegal to do while in the Relink phase.
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
return false ;
mstudiohitboxset_t * set = pStudioHdr - > pHitboxSet ( m_nHitboxSet ) ;
if ( ! set | | ! set - > numhitboxes )
return false ;
CBoneCache * pCache = GetBoneCache ( ) ;
// Compute a box in world space that surrounds this entity
pVecWorldMins - > Init ( FLT_MAX , FLT_MAX , FLT_MAX ) ;
pVecWorldMaxs - > Init ( - FLT_MAX , - FLT_MAX , - FLT_MAX ) ;
Vector vecBoxAbsMins , vecBoxAbsMaxs ;
for ( int i = 0 ; i < set - > numhitboxes ; i + + )
{
mstudiobbox_t * pbox = set - > pHitbox ( i ) ;
matrix3x4_t * pMatrix = pCache - > GetCachedBone ( pbox - > bone ) ;
if ( pMatrix )
{
TransformAABB ( * pMatrix , pbox - > bbmin * GetModelScale ( ) , pbox - > bbmax * GetModelScale ( ) , vecBoxAbsMins , vecBoxAbsMaxs ) ;
VectorMin ( * pVecWorldMins , vecBoxAbsMins , * pVecWorldMins ) ;
VectorMax ( * pVecWorldMaxs , vecBoxAbsMaxs , * pVecWorldMaxs ) ;
}
}
return true ;
}
//-----------------------------------------------------------------------------
// Computes a box that surrounds all hitboxes, in entity space
//-----------------------------------------------------------------------------
bool CBaseAnimating : : ComputeEntitySpaceHitboxSurroundingBox ( Vector * pVecWorldMins , Vector * pVecWorldMaxs )
{
// Note that this currently should not be called during position recomputation because of IK.
// The code below recomputes bones so as to get at the hitboxes,
// which causes IK to trigger, which causes raycasts against the other entities to occur,
// which is illegal to do while in the computeabsposition phase.
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
return false ;
mstudiohitboxset_t * set = pStudioHdr - > pHitboxSet ( m_nHitboxSet ) ;
if ( ! set | | ! set - > numhitboxes )
return false ;
CBoneCache * pCache = GetBoneCache ( ) ;
matrix3x4_t * hitboxbones [ MAXSTUDIOBONES ] ;
pCache - > ReadCachedBonePointers ( hitboxbones , pStudioHdr - > numbones ( ) ) ;
// Compute a box in world space that surrounds this entity
pVecWorldMins - > Init ( FLT_MAX , FLT_MAX , FLT_MAX ) ;
pVecWorldMaxs - > Init ( - FLT_MAX , - FLT_MAX , - FLT_MAX ) ;
matrix3x4_t worldToEntity , boneToEntity ;
MatrixInvert ( EntityToWorldTransform ( ) , worldToEntity ) ;
Vector vecBoxAbsMins , vecBoxAbsMaxs ;
for ( int i = 0 ; i < set - > numhitboxes ; i + + )
{
mstudiobbox_t * pbox = set - > pHitbox ( i ) ;
ConcatTransforms ( worldToEntity , * hitboxbones [ pbox - > bone ] , boneToEntity ) ;
TransformAABB ( boneToEntity , pbox - > bbmin , pbox - > bbmax , vecBoxAbsMins , vecBoxAbsMaxs ) ;
VectorMin ( * pVecWorldMins , vecBoxAbsMins , * pVecWorldMins ) ;
VectorMax ( * pVecWorldMaxs , vecBoxAbsMaxs , * pVecWorldMaxs ) ;
}
return true ;
}
int CBaseAnimating : : GetPhysicsBone ( int boneIndex )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( pStudioHdr )
{
if ( boneIndex > = 0 & & boneIndex < pStudioHdr - > numbones ( ) )
return pStudioHdr - > pBone ( boneIndex ) - > physicsbone ;
}
return 0 ;
}
bool CBaseAnimating : : LookupHitbox ( const char * szName , int & outSet , int & outBox )
{
CStudioHdr * pHdr = GetModelPtr ( ) ;
outSet = - 1 ;
outBox = - 1 ;
if ( ! pHdr )
return false ;
for ( int set = 0 ; set < pHdr - > numhitboxsets ( ) ; set + + )
{
for ( int i = 0 ; i < pHdr - > iHitboxCount ( set ) ; i + + )
{
mstudiobbox_t * pBox = pHdr - > pHitbox ( i , set ) ;
if ( ! pBox )
continue ;
const char * szBoxName = pBox - > pszHitboxName ( ) ;
if ( Q_stricmp ( szBoxName , szName ) = = 0 )
{
outSet = set ;
outBox = i ;
return true ;
}
}
}
return false ;
}
void CBaseAnimating : : CopyAnimationDataFrom ( CBaseAnimating * pSource )
{
this - > SetModelName ( pSource - > GetModelName ( ) ) ;
this - > SetModelIndex ( pSource - > GetModelIndex ( ) ) ;
this - > SetCycle ( pSource - > GetCycle ( ) ) ;
this - > SetEffects ( pSource - > GetEffects ( ) ) ;
this - > IncrementInterpolationFrame ( ) ;
this - > SetSequence ( pSource - > GetSequence ( ) ) ;
this - > m_flAnimTime = pSource - > m_flAnimTime ;
this - > m_nBody = pSource - > m_nBody ;
this - > m_nSkin = pSource - > m_nSkin ;
this - > LockStudioHdr ( ) ;
}
int CBaseAnimating : : GetHitboxesFrontside ( int * boxList , int boxMax , const Vector & normal , float dist )
{
int count = 0 ;
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( pStudioHdr )
{
mstudiohitboxset_t * set = pStudioHdr - > pHitboxSet ( m_nHitboxSet ) ;
if ( set )
{
matrix3x4_t matrix ;
for ( int b = 0 ; b < set - > numhitboxes ; b + + )
{
mstudiobbox_t * pbox = set - > pHitbox ( b ) ;
GetBoneTransform ( pbox - > bone , matrix ) ;
Vector center = ( pbox - > bbmax + pbox - > bbmin ) * 0.5 ;
Vector centerWs ;
VectorTransform ( center , matrix , centerWs ) ;
if ( DotProduct ( centerWs , normal ) > = dist )
{
if ( count < boxMax )
{
boxList [ count ] = b ;
count + + ;
}
}
}
}
}
return count ;
}
void CBaseAnimating : : EnableServerIK ( )
{
if ( ! m_pIk )
{
m_pIk = new CIKContext ;
m_iIKCounter = 0 ;
}
}
void CBaseAnimating : : DisableServerIK ( )
{
delete m_pIk ;
m_pIk = NULL ;
}
Activity CBaseAnimating : : GetSequenceActivity ( int iSequence )
{
if ( iSequence = = - 1 )
{
return ACT_INVALID ;
}
if ( ! GetModelPtr ( ) )
return ACT_INVALID ;
return ( Activity ) : : GetSequenceActivity ( GetModelPtr ( ) , iSequence ) ;
}
void CBaseAnimating : : ModifyOrAppendCriteria ( AI_CriteriaSet & set )
{
BaseClass : : ModifyOrAppendCriteria ( set ) ;
// TODO
// Append any animation state parameters here
}
void CBaseAnimating : : DoMuzzleFlash ( )
{
m_nMuzzleFlashParity = ( m_nMuzzleFlashParity + 1 ) & ( ( 1 < < EF_MUZZLEFLASH_BITS ) - 1 ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : scale -
//-----------------------------------------------------------------------------
void CBaseAnimating : : SetModelScale ( float scale , float change_duration /*= 0.0f*/ )
{
if ( change_duration > 0.0f )
{
ModelScale * mvs = ( ModelScale * ) CreateDataObject ( MODELSCALE ) ;
mvs - > m_flModelScaleStart = m_flModelScale ;
mvs - > m_flModelScaleGoal = scale ;
mvs - > m_flModelScaleStartTime = gpGlobals - > curtime ;
mvs - > m_flModelScaleFinishTime = mvs - > m_flModelScaleStartTime + change_duration ;
}
else
{
m_flModelScale = scale ;
RefreshCollisionBounds ( ) ;
if ( HasDataObjectType ( MODELSCALE ) )
{
DestroyDataObject ( MODELSCALE ) ;
}
}
}
void CBaseAnimating : : UpdateModelScale ( )
{
ModelScale * mvs = ( ModelScale * ) GetDataObject ( MODELSCALE ) ;
if ( ! mvs )
{
return ;
}
float dt = mvs - > m_flModelScaleFinishTime - mvs - > m_flModelScaleStartTime ;
Assert ( dt > 0.0f ) ;
float frac = ( gpGlobals - > curtime - mvs - > m_flModelScaleStartTime ) / dt ;
frac = clamp ( frac , 0.0f , 1.0f ) ;
if ( gpGlobals - > curtime > = mvs - > m_flModelScaleFinishTime )
{
m_flModelScale = mvs - > m_flModelScaleGoal ;
DestroyDataObject ( MODELSCALE ) ;
}
else
{
m_flModelScale = Lerp ( frac , mvs - > m_flModelScaleStart , mvs - > m_flModelScaleGoal ) ;
}
RefreshCollisionBounds ( ) ;
}
void CBaseAnimating : : RefreshCollisionBounds ( void )
{
CollisionProp ( ) - > RefreshScaledCollisionBounds ( ) ;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CBaseAnimating : : Ignite ( float flFlameLifetime , bool bNPCOnly , float flSize , bool bCalledByLevelDesigner )
{
if ( IsOnFire ( ) )
return ;
bool bIsNPC = IsNPC ( ) ;
// Right now this prevents stuff we don't want to catch on fire from catching on fire.
if ( bNPCOnly & & bIsNPC = = false )
{
return ;
}
if ( bIsNPC = = true & & bCalledByLevelDesigner = = false )
{
CAI_BaseNPC * pNPC = MyNPCPointer ( ) ;
if ( pNPC & & pNPC - > AllowedToIgnite ( ) = = false )
return ;
}
CEntityFlame * pFlame = CEntityFlame : : Create ( this ) ;
if ( pFlame )
{
pFlame - > SetLifetime ( flFlameLifetime ) ;
AddFlag ( FL_ONFIRE ) ;
SetEffectEntity ( pFlame ) ;
if ( flSize > 0.0f )
{
pFlame - > SetSize ( flSize ) ;
}
}
m_OnIgnite . FireOutput ( this , this ) ;
}
void CBaseAnimating : : IgniteLifetime ( float flFlameLifetime )
{
if ( ! IsOnFire ( ) )
Ignite ( 30 , false , 0.0f , true ) ;
CEntityFlame * pFlame = dynamic_cast < CEntityFlame * > ( GetEffectEntity ( ) ) ;
if ( ! pFlame )
return ;
pFlame - > SetLifetime ( flFlameLifetime ) ;
}
void CBaseAnimating : : IgniteNumHitboxFires ( int iNumHitBoxFires )
{
if ( ! IsOnFire ( ) )
Ignite ( 30 , false , 0.0f , true ) ;
CEntityFlame * pFlame = dynamic_cast < CEntityFlame * > ( GetEffectEntity ( ) ) ;
if ( ! pFlame )
return ;
pFlame - > SetNumHitboxFires ( iNumHitBoxFires ) ;
}
void CBaseAnimating : : IgniteHitboxFireScale ( float flHitboxFireScale )
{
if ( ! IsOnFire ( ) )
Ignite ( 30 , false , 0.0f , true ) ;
CEntityFlame * pFlame = dynamic_cast < CEntityFlame * > ( GetEffectEntity ( ) ) ;
if ( ! pFlame )
return ;
pFlame - > SetHitboxFireScale ( flHitboxFireScale ) ;
}
//-----------------------------------------------------------------------------
// Fades out!
//-----------------------------------------------------------------------------
bool CBaseAnimating : : Dissolve ( const char * pMaterialName , float flStartTime , bool bNPCOnly , int nDissolveType , Vector vDissolverOrigin , int iMagnitude )
{
// Right now this prevents stuff we don't want to catch on fire from catching on fire.
if ( bNPCOnly & & ! ( GetFlags ( ) & FL_NPC ) )
return false ;
// Can't dissolve twice
if ( IsDissolving ( ) )
return false ;
bool bRagdollCreated = false ;
CEntityDissolve * pDissolve = CEntityDissolve : : Create ( this , pMaterialName , flStartTime , nDissolveType , & bRagdollCreated ) ;
if ( pDissolve )
{
SetEffectEntity ( pDissolve ) ;
AddFlag ( FL_DISSOLVING ) ;
m_flDissolveStartTime = flStartTime ;
pDissolve - > SetDissolverOrigin ( vDissolverOrigin ) ;
pDissolve - > SetMagnitude ( iMagnitude ) ;
}
// if this is a ragdoll dissolving, fire an event
if ( ( CLASS_NONE = = Classify ( ) ) & & ( ClassMatches ( " prop_ragdoll " ) ) )
{
IGameEvent * event = gameeventmanager - > CreateEvent ( " ragdoll_dissolved " ) ;
if ( event )
{
event - > SetInt ( " entindex " , entindex ( ) ) ;
gameeventmanager - > FireEvent ( event ) ;
}
}
return bRagdollCreated ;
}
//-----------------------------------------------------------------------------
// Make a model look as though it's burning.
//-----------------------------------------------------------------------------
void CBaseAnimating : : Scorch ( int rate , int floor )
{
color32 color = GetRenderColor ( ) ;
if ( color . r > floor )
color . r - = rate ;
if ( color . g > floor )
color . g - = rate ;
if ( color . b > floor )
color . b - = rate ;
SetRenderColor ( color . r , color . g , color . b ) ;
}
void CBaseAnimating : : ResetSequence ( int nSequence )
{
if ( ai_sequence_debug . GetBool ( ) = = true & & ( m_debugOverlays & OVERLAY_NPC_SELECTED_BIT ) )
{
DevMsg ( " ResetSequence : %s: %s -> %s \n " , GetClassname ( ) , GetSequenceName ( GetSequence ( ) ) , GetSequenceName ( nSequence ) ) ;
}
if ( ! SequenceLoops ( ) )
{
SetCycle ( 0 ) ;
}
// Tracker 17868: If the sequence number didn't actually change, but you call resetsequence info, it changes
// the newsequenceparity bit which causes the client to call m_flCycle.Reset() which causes a very slight
// discontinuity in looping animations as they reset around to cycle 0.0. This was causing the parentattached
// helmet on barney to hitch every time barney's idle cycled back around to its start.
bool changed = nSequence ! = GetSequence ( ) ? true : false ;
SetSequence ( nSequence ) ;
if ( changed | | ! SequenceLoops ( ) )
{
ResetSequenceInfo ( ) ;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CBaseAnimating : : InputIgnite ( inputdata_t & inputdata )
{
Ignite ( 30 , false , 0.0f , true ) ;
}
void CBaseAnimating : : InputIgniteLifetime ( inputdata_t & inputdata )
{
IgniteLifetime ( inputdata . value . Float ( ) ) ;
}
void CBaseAnimating : : InputIgniteNumHitboxFires ( inputdata_t & inputdata )
{
IgniteNumHitboxFires ( inputdata . value . Int ( ) ) ;
}
void CBaseAnimating : : InputIgniteHitboxFireScale ( inputdata_t & inputdata )
{
IgniteHitboxFireScale ( inputdata . value . Float ( ) ) ;
}
void CBaseAnimating : : InputBecomeRagdoll ( inputdata_t & inputdata )
{
BecomeRagdollOnClient ( vec3_origin ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseAnimating : : SetFadeDistance ( float minFadeDist , float maxFadeDist )
{
m_fadeMinDist = minFadeDist ;
m_fadeMaxDist = maxFadeDist ;
}
//-----------------------------------------------------------------------------
// Purpose: Async prefetches all anim data used by a particular sequence. Returns true if all of the required data is memory resident
// Input : iSequence -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseAnimating : : PrefetchSequence ( int iSequence )
{
CStudioHdr * pStudioHdr = GetModelPtr ( ) ;
if ( ! pStudioHdr )
return true ;
return Studio_PrefetchSequence ( pStudioHdr , iSequence ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseAnimating : : IsSequenceLooping ( CStudioHdr * pStudioHdr , int iSequence )
{
return ( : : GetSequenceFlags ( pStudioHdr , iSequence ) & STUDIO_LOOPING ) ! = 0 ;
}
//-----------------------------------------------------------------------------
// Purpose: model-change notification. Fires on dynamic load completion as well
//-----------------------------------------------------------------------------
CStudioHdr * CBaseAnimating : : OnNewModel ( )
{
( void ) BaseClass : : OnNewModel ( ) ;
// TODO: if dynamic, validate m_Sequence and apply queued body group settings?
if ( IsDynamicModelLoading ( ) )
{
// Called while dynamic model still loading -> new model, clear deferred state
m_bResetSequenceInfoOnLoad = false ;
return NULL ;
}
CStudioHdr * hdr = GetModelPtr ( ) ;
if ( m_bResetSequenceInfoOnLoad )
{
m_bResetSequenceInfoOnLoad = false ;
ResetSequenceInfo ( ) ;
}
return hdr ;
}