Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

2101 lines
65 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "tier0/vprof.h"
#include "animation.h"
#include "studio.h"
#include "apparent_velocity_helper.h"
#include "utldict.h"
#include "multiplayer_animstate.h"
#include "activitylist.h"
#ifdef CLIENT_DLL
#include "c_baseplayer.h"
#include "engine/ivdebugoverlay.h"
#include "filesystem.h"
#include "eventlist.h"
ConVar anim_showmainactivity( "anim_showmainactivity", "0", FCVAR_CHEAT, "Show the idle, walk, run, and/or sprint activities." );
#else
#include "player.h"
#endif
#if defined(TF_CLIENT_DLL) || defined(TF_DLL)
#include "tf_gamerules.h"
#endif
#ifndef CALL_ATTRIB_HOOK_FLOAT_ON_OTHER
#define CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( o, r, n )
#endif
#define MOVING_MINIMUM_SPEED 0.5f
ConVar anim_showstate( "anim_showstate", "-1", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Show the (client) animation state for the specified entity (-1 for none)." );
ConVar anim_showstatelog( "anim_showstatelog", "0", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "1 to output anim_showstate to Msg(). 2 to store in AnimState.log. 3 for both." );
ConVar mp_showgestureslots( "mp_showgestureslots", "-1", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Show multiplayer client/server gesture slot information for the specified player index (-1 for no one)." );
ConVar mp_slammoveyaw( "mp_slammoveyaw", "0", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Force movement yaw along an animation path." );
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
// &movementData -
//-----------------------------------------------------------------------------
CMultiPlayerAnimState::CMultiPlayerAnimState( CBasePlayer *pPlayer, MultiPlayerMovementData_t &movementData )
#ifdef CLIENT_DLL
: m_iv_flMaxGroundSpeed( "CMultiPlayerAnimState::m_iv_flMaxGroundSpeed" )
#endif
{
// Pose parameters.
m_bPoseParameterInit = false;
m_PoseParameterData.Init();
m_DebugAnimData.Init();
m_pPlayer = NULL;
m_angRender.Init();
m_bCurrentFeetYawInitialized = false;
m_flLastAnimationStateClearTime = 0.0f;
m_flEyeYaw = 0.0f;
m_flEyePitch = 0.0f;
m_flGoalFeetYaw = 0.0f;
m_flCurrentFeetYaw = 0.0f;
m_flLastAimTurnTime = 0.0f;
// Jumping.
m_bJumping = false;
m_flJumpStartTime = 0.0f;
m_bFirstJumpFrame = false;
// Swimming
m_bInSwim = false;
m_bFirstSwimFrame = true;
// Dying
m_bDying = false;
m_bFirstDyingFrame = true;
m_eCurrentMainSequenceActivity = ACT_INVALID;
m_nSpecificMainSequence = -1;
// Weapon data.
m_hActiveWeapon = NULL;
// Ground speed interpolators.
#ifdef CLIENT_DLL
m_iv_flMaxGroundSpeed.Setup( &m_flMaxGroundSpeed, LATCH_ANIMATION_VAR | INTERPOLATE_LINEAR_ONLY );
m_flLastGroundSpeedUpdateTime = 0.0f;
#endif
m_flMaxGroundSpeed = 0.0f;
// If you are forcing aim yaw, your code is almost definitely broken if you don't include a delay between
// teleporting and forcing yaw. This is due to an unfortunate interaction between the command lookback window,
// and the fact that m_flEyeYaw is never propogated from the server to the client.
// TODO: Fix this after Halloween 2014.
m_bForceAimYaw = false;
Init( pPlayer, movementData );
// movement playback options
m_nMovementSequence = -1;
m_LegAnimType = LEGANIM_9WAY;
InitGestureSlots();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
//-----------------------------------------------------------------------------
CMultiPlayerAnimState::~CMultiPlayerAnimState()
{
ShutdownGestureSlots();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
// &movementData -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::Init( CBasePlayer *pPlayer, MultiPlayerMovementData_t &movementData )
{
// Get the player this animation data works on.
m_pPlayer = pPlayer;
// Copy the movement data.
memcpy( &m_MovementData, &movementData, sizeof( MultiPlayerMovementData_t ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ClearAnimationState()
{
// Reset state.
m_bJumping = false;
m_bDying = false;
m_bCurrentFeetYawInitialized = false;
m_flLastAnimationStateClearTime = gpGlobals->curtime;
m_nSpecificMainSequence = -1;
ResetGestureSlots();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : event -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
{
switch( event )
{
case PLAYERANIMEVENT_ATTACK_PRIMARY:
{
// Weapon primary fire.
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_ATTACK_STAND_PRIMARYFIRE );
break;
}
case PLAYERANIMEVENT_ATTACK_SECONDARY:
{
// Weapon secondary fire.
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_ATTACK_STAND_SECONDARYFIRE );
break;
}
case PLAYERANIMEVENT_ATTACK_GRENADE:
{
// Grenade throw.
RestartGesture( GESTURE_SLOT_GRENADE, ACT_MP_ATTACK_STAND_GRENADE );
break;
}
case PLAYERANIMEVENT_RELOAD:
{
// Weapon reload.
if ( GetBasePlayer()->GetFlags() & FL_DUCKING )
{
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_CROUCH );
}
else if ( m_bInSwim )
{
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_SWIM );
}
else
{
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_STAND );
}
// Set the modified reload playback rate
float flPlaybackRate = 1.0f;
#if defined(TF_CLIENT_DLL) || defined(TF_DLL)
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBasePlayer(), flPlaybackRate, mult_reload_time );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBasePlayer(), flPlaybackRate, mult_reload_time_hidden );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBasePlayer(), flPlaybackRate, fast_reload );
#endif
m_aGestureSlots[ GESTURE_SLOT_ATTACK_AND_RELOAD ].m_pAnimLayer->m_flPlaybackRate = flPlaybackRate;
break;
}
case PLAYERANIMEVENT_RELOAD_LOOP:
{
// Weapon reload.
if ( GetBasePlayer()->GetFlags() & FL_DUCKING )
{
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_CROUCH_LOOP );
}
else if ( m_bInSwim )
{
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_SWIM_LOOP );
}
else
{
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_STAND_LOOP );
}
// Set the modified reload playback rate
float flPlaybackRate = 1.0f;
#if defined(TF_CLIENT_DLL) || defined(TF_DLL)
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBasePlayer(), flPlaybackRate, mult_reload_time );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBasePlayer(), flPlaybackRate, mult_reload_time_hidden );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBasePlayer(), flPlaybackRate, fast_reload );
#endif
m_aGestureSlots[ GESTURE_SLOT_ATTACK_AND_RELOAD ].m_pAnimLayer->m_flPlaybackRate = flPlaybackRate;
break;
}
case PLAYERANIMEVENT_RELOAD_END:
{
// Weapon reload.
if ( GetBasePlayer()->GetFlags() & FL_DUCKING )
{
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_CROUCH_END );
}
else if ( m_bInSwim )
{
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_SWIM_END );
}
else
{
RestartGesture( GESTURE_SLOT_ATTACK_AND_RELOAD, ACT_MP_RELOAD_STAND_END );
}
// Set the modified reload playback rate
float flPlaybackRate = 1.0f;
#if defined(TF_CLIENT_DLL) || defined(TF_DLL)
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBasePlayer(), flPlaybackRate, mult_reload_time );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBasePlayer(), flPlaybackRate, mult_reload_time_hidden );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBasePlayer(), flPlaybackRate, fast_reload );
#endif
m_aGestureSlots[ GESTURE_SLOT_ATTACK_AND_RELOAD ].m_pAnimLayer->m_flPlaybackRate = flPlaybackRate;
break;
}
case PLAYERANIMEVENT_JUMP:
{
// Jump.
m_bJumping = true;
m_bFirstJumpFrame = true;
m_flJumpStartTime = gpGlobals->curtime;
RestartMainSequence();
break;
}
case PLAYERANIMEVENT_DIE:
{
// Should be here - not supporting this yet!
Assert( 0 );
// Start playing the death animation
m_bDying = true;
RestartMainSequence();
break;
}
case PLAYERANIMEVENT_SPAWN:
{
// Player has respawned. Clear flags.
ClearAnimationState();
break;
}
case PLAYERANIMEVENT_SNAP_YAW:
m_PoseParameterData.m_flLastAimTurnTime = 0.0f;
break;
case PLAYERANIMEVENT_CUSTOM:
{
Activity iIdealActivity = TranslateActivity( (Activity)nData );
m_nSpecificMainSequence = GetBasePlayer()->SelectWeightedSequence( iIdealActivity );
RestartMainSequence();
}
break;
case PLAYERANIMEVENT_CUSTOM_GESTURE:
// Weapon primary fire.
RestartGesture( GESTURE_SLOT_CUSTOM, (Activity)nData );
break;
case PLAYERANIMEVENT_CUSTOM_SEQUENCE:
m_nSpecificMainSequence = nData;
RestartMainSequence();
break;
case PLAYERANIMEVENT_CUSTOM_GESTURE_SEQUENCE:
// Weapon primary fire.
// RestartGestureSequence( nData, false );
break;
case PLAYERANIMEVENT_FLINCH_CHEST:
PlayFlinchGesture( ACT_MP_GESTURE_FLINCH_CHEST );
break;
case PLAYERANIMEVENT_FLINCH_HEAD:
PlayFlinchGesture( ACT_MP_GESTURE_FLINCH_HEAD );
break;
case PLAYERANIMEVENT_FLINCH_LEFTARM:
PlayFlinchGesture( ACT_MP_GESTURE_FLINCH_LEFTARM );
break;
case PLAYERANIMEVENT_FLINCH_RIGHTARM:
PlayFlinchGesture( ACT_MP_GESTURE_FLINCH_RIGHTARM );
break;
case PLAYERANIMEVENT_FLINCH_LEFTLEG:
PlayFlinchGesture( ACT_MP_GESTURE_FLINCH_LEFTLEG );
break;
case PLAYERANIMEVENT_FLINCH_RIGHTLEG:
PlayFlinchGesture( ACT_MP_GESTURE_FLINCH_RIGHTLEG );
break;
default:
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::PlayFlinchGesture( Activity iActivity )
{
if ( !IsGestureSlotActive( GESTURE_SLOT_FLINCH ) )
{
// See if we have the custom flinch. If not, revert to chest
if ( iActivity != ACT_MP_GESTURE_FLINCH_CHEST && GetBasePlayer()->SelectWeightedSequence( iActivity ) == -1 )
{
RestartGesture( GESTURE_SLOT_FLINCH, ACT_MP_GESTURE_FLINCH_CHEST );
}
else
{
RestartGesture( GESTURE_SLOT_FLINCH, iActivity );
}
}
}
//=============================================================================
//
// Multiplayer gesture code.
//
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::InitGestureSlots( void )
{
// Setup the number of gesture slots.
m_aGestureSlots.AddMultipleToTail( GESTURE_SLOT_COUNT );
// Assign all of the the CAnimationLayer pointers to null early in case we bail.
for ( int iGesture = 0; iGesture < GESTURE_SLOT_COUNT; ++iGesture )
{
m_aGestureSlots[iGesture].m_pAnimLayer = NULL;
}
// Get the base player.
CBasePlayer *pPlayer = GetBasePlayer();
// Set the number of animation overlays we will use.
pPlayer->SetNumAnimOverlays( GESTURE_SLOT_COUNT );
for ( int iGesture = 0; iGesture < GESTURE_SLOT_COUNT; ++iGesture )
{
m_aGestureSlots[iGesture].m_pAnimLayer = pPlayer->GetAnimOverlay( iGesture );
if ( !m_aGestureSlots[iGesture].m_pAnimLayer )
return false;
ResetGestureSlot( iGesture );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ShutdownGestureSlots( void )
{
// Clean up the gesture slots.
m_aGestureSlots.Purge();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ResetGestureSlots( void )
{
// Clear out all the gesture slots.
for ( int iGesture = 0; iGesture < GESTURE_SLOT_COUNT; ++iGesture )
{
ResetGestureSlot( iGesture );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ResetGestureSlot( int iGestureSlot )
{
// Sanity Check
Assert( iGestureSlot >= 0 && iGestureSlot < GESTURE_SLOT_COUNT );
if ( !VerifyAnimLayerInSlot( iGestureSlot ) )
return;
GestureSlot_t *pGestureSlot = &m_aGestureSlots[iGestureSlot];
if ( pGestureSlot )
{
#ifdef CLIENT_DLL
// briefly set to 1.0 so we catch the events, before we reset the slot
pGestureSlot->m_pAnimLayer->m_flCycle = 1.0;
RunGestureSlotAnimEventsToCompletion( pGestureSlot );
#endif
pGestureSlot->m_iGestureSlot = GESTURE_SLOT_INVALID;
pGestureSlot->m_iActivity = ACT_INVALID;
pGestureSlot->m_bAutoKill = false;
pGestureSlot->m_bActive = false;
if ( pGestureSlot->m_pAnimLayer )
{
pGestureSlot->m_pAnimLayer->SetOrder( CBaseAnimatingOverlay::MAX_OVERLAYS );
#ifdef CLIENT_DLL
pGestureSlot->m_pAnimLayer->Reset();
#endif
}
}
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::RunGestureSlotAnimEventsToCompletion( GestureSlot_t *pGesture )
{
CBasePlayer *pPlayer = GetBasePlayer();
if( !pPlayer )
return;
// Get the studio header for the player.
CStudioHdr *pStudioHdr = pPlayer->GetModelPtr();
if ( !pStudioHdr )
return;
// Do all the anim events between previous cycle and 1.0, inclusive
mstudioseqdesc_t &seqdesc = pStudioHdr->pSeqdesc( pGesture->m_pAnimLayer->m_nSequence );
if ( seqdesc.numevents > 0 )
{
mstudioevent_t *pevent = seqdesc.pEvent( 0 );
for (int i = 0; i < (int)seqdesc.numevents; i++)
{
if ( pevent[i].type & AE_TYPE_NEWEVENTSYSTEM )
{
if ( !( pevent[i].type & AE_TYPE_CLIENT ) )
continue;
}
else if ( pevent[i].event < 5000 ) //Adrian - Support the old event system
continue;
if ( pevent[i].cycle > pGesture->m_pAnimLayer->m_flPrevCycle &&
pevent[i].cycle <= pGesture->m_pAnimLayer->m_flCycle )
{
pPlayer->FireEvent( pPlayer->GetAbsOrigin(), pPlayer->GetAbsAngles(), pevent[ i ].event, pevent[ i ].pszOptions() );
}
}
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::IsGestureSlotActive( int iGestureSlot )
{
// Sanity Check
Assert( iGestureSlot >= 0 && iGestureSlot < GESTURE_SLOT_COUNT );
return m_aGestureSlots[iGestureSlot].m_bActive;
}
//-----------------------------------------------------------------------------
// Purpose: Track down a crash
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::VerifyAnimLayerInSlot( int iGestureSlot )
{
if ( iGestureSlot < 0 || iGestureSlot >= GESTURE_SLOT_COUNT )
{
return false;
}
if ( GetBasePlayer()->GetNumAnimOverlays() < iGestureSlot + 1 )
{
AssertMsg2( false, "Player %d doesn't have gesture slot %d any more.", GetBasePlayer()->entindex(), iGestureSlot );
Msg( "Player %d doesn't have gesture slot %d any more.\n", GetBasePlayer()->entindex(), iGestureSlot );
m_aGestureSlots[iGestureSlot].m_pAnimLayer = NULL;
return false;
}
CAnimationLayer *pExpected = GetBasePlayer()->GetAnimOverlay( iGestureSlot );
if ( m_aGestureSlots[iGestureSlot].m_pAnimLayer != pExpected )
{
AssertMsg3( false, "Gesture slot %d pointing to wrong address %p. Updating to new address %p.", iGestureSlot, m_aGestureSlots[iGestureSlot].m_pAnimLayer, pExpected );
Msg( "Gesture slot %d pointing to wrong address %p. Updating to new address %p.\n", iGestureSlot, m_aGestureSlots[iGestureSlot].m_pAnimLayer, pExpected );
m_aGestureSlots[iGestureSlot].m_pAnimLayer = pExpected;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::IsGestureSlotPlaying( int iGestureSlot, Activity iGestureActivity )
{
// Sanity Check
Assert( iGestureSlot >= 0 && iGestureSlot < GESTURE_SLOT_COUNT );
// Check to see if the slot is active.
if ( !IsGestureSlotActive( iGestureSlot ) )
return false;
return ( m_aGestureSlots[iGestureSlot].m_iActivity == iGestureActivity );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::RestartGesture( int iGestureSlot, Activity iGestureActivity, bool bAutoKill )
{
// Sanity Check
Assert( iGestureSlot >= 0 && iGestureSlot < GESTURE_SLOT_COUNT );
if ( !VerifyAnimLayerInSlot( iGestureSlot ) )
return;
if ( !IsGestureSlotPlaying( iGestureSlot, iGestureActivity ) )
{
#ifdef CLIENT_DLL
if ( IsGestureSlotActive( iGestureSlot ) )
{
GestureSlot_t *pGesture = &m_aGestureSlots[iGestureSlot];
if ( pGesture && pGesture->m_pAnimLayer )
{
pGesture->m_pAnimLayer->m_flCycle = 1.0; // run until the end
RunGestureSlotAnimEventsToCompletion( &m_aGestureSlots[iGestureSlot] );
}
}
#endif
Activity iIdealGestureActivity = TranslateActivity( iGestureActivity );
AddToGestureSlot( iGestureSlot, iIdealGestureActivity, bAutoKill );
return;
}
// Reset the cycle = restart the gesture.
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flCycle = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flPrevCycle = 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::AddToGestureSlot( int iGestureSlot, Activity iGestureActivity, bool bAutoKill )
{
// Sanity Check
Assert( iGestureSlot >= 0 && iGestureSlot < GESTURE_SLOT_COUNT );
CBasePlayer *pPlayer = GetBasePlayer();
if ( !pPlayer )
return;
// Make sure we have a valid animation layer to fill out.
if ( !m_aGestureSlots[iGestureSlot].m_pAnimLayer )
return;
if ( !VerifyAnimLayerInSlot( iGestureSlot ) )
return;
// Get the sequence.
int iGestureSequence = pPlayer->SelectWeightedSequence( iGestureActivity );
if ( iGestureSequence <= 0 )
return;
#ifdef CLIENT_DLL
// Setup the gesture.
m_aGestureSlots[iGestureSlot].m_iGestureSlot = iGestureSlot;
m_aGestureSlots[iGestureSlot].m_iActivity = iGestureActivity;
m_aGestureSlots[iGestureSlot].m_bAutoKill = bAutoKill;
m_aGestureSlots[iGestureSlot].m_bActive = true;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nSequence = iGestureSequence;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nOrder = iGestureSlot;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flWeight = 1.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flPlaybackRate = 1.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flCycle = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flPrevCycle = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flLayerAnimtime = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flLayerFadeOuttime = 0.0f;
pPlayer->m_flOverlayPrevEventCycle[iGestureSlot] = -1.0;
#else
// Setup the gesture.
m_aGestureSlots[iGestureSlot].m_iGestureSlot = iGestureSlot;
m_aGestureSlots[iGestureSlot].m_iActivity = iGestureActivity;
m_aGestureSlots[iGestureSlot].m_bAutoKill = bAutoKill;
m_aGestureSlots[iGestureSlot].m_bActive = true;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nActivity = iGestureActivity;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nOrder = iGestureSlot;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nPriority = 0;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flCycle = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flPrevCycle = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flPlaybackRate = 1.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nActivity = iGestureActivity;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nSequence = iGestureSequence;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flWeight = 1.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flBlendIn = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flBlendOut = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_bSequenceFinished = false;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flLastEventCheck = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flLastEventCheck = gpGlobals->curtime;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_bLooping = false;//( ( GetSequenceFlags( GetModelPtr(), iGestureSequence ) & STUDIO_LOOPING ) != 0);
if ( bAutoKill )
{
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_fFlags |= ANIM_LAYER_AUTOKILL;
}
else
{
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_fFlags &= ~ANIM_LAYER_AUTOKILL;
}
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_fFlags |= ANIM_LAYER_ACTIVE;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::AddVCDSequenceToGestureSlot( int iGestureSlot, int iGestureSequence, float flCycle, bool bAutoKill )
{
// Sanity Check
Assert( iGestureSlot >= 0 && iGestureSlot < GESTURE_SLOT_COUNT );
CBasePlayer *pPlayer = GetBasePlayer();
if ( !pPlayer )
return;
// Make sure we have a valid animation layer to fill out.
if ( !m_aGestureSlots[iGestureSlot].m_pAnimLayer )
return;
if ( !VerifyAnimLayerInSlot( iGestureSlot ) )
return;
// Set the activity.
Activity iGestureActivity = ACT_MP_VCD;
#ifdef CLIENT_DLL
// Setup the gesture.
m_aGestureSlots[iGestureSlot].m_iGestureSlot = iGestureSlot;
m_aGestureSlots[iGestureSlot].m_iActivity = iGestureActivity;
m_aGestureSlots[iGestureSlot].m_bAutoKill = bAutoKill;
m_aGestureSlots[iGestureSlot].m_bActive = true;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nSequence = iGestureSequence;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nOrder = iGestureSlot;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flWeight = 1.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flPlaybackRate = 1.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flCycle = flCycle;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flPrevCycle = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flLayerAnimtime = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flLayerFadeOuttime = 0.0f;
pPlayer->m_flOverlayPrevEventCycle[iGestureSlot] = flCycle == 0.f ? -1.0 : flCycle;
#else
// Setup the gesture.
m_aGestureSlots[iGestureSlot].m_iGestureSlot = iGestureSlot;
m_aGestureSlots[iGestureSlot].m_iActivity = iGestureActivity;
m_aGestureSlots[iGestureSlot].m_bAutoKill = bAutoKill;
m_aGestureSlots[iGestureSlot].m_bActive = true;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nActivity = iGestureActivity;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nOrder = iGestureSlot;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nPriority = 0;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flCycle = flCycle;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flPrevCycle = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flPlaybackRate = 1.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nActivity = iGestureActivity;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_nSequence = iGestureSequence;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flWeight = 1.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flBlendIn = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flBlendOut = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_bSequenceFinished = false;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flLastEventCheck = 0.0f;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_flLastEventCheck = gpGlobals->curtime;
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_bLooping = false;//( ( GetSequenceFlags( GetModelPtr(), iGestureSequence ) & STUDIO_LOOPING ) != 0);
if ( bAutoKill )
{
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_fFlags |= ANIM_LAYER_AUTOKILL;
}
else
{
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_fFlags &= ~ANIM_LAYER_AUTOKILL;
}
m_aGestureSlots[iGestureSlot].m_pAnimLayer->m_fFlags |= ANIM_LAYER_ACTIVE;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAnimationLayer* CMultiPlayerAnimState::GetGestureSlotLayer( int iGestureSlot )
{
return m_aGestureSlots[iGestureSlot].m_pAnimLayer;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ShowDebugInfo( void )
{
if ( anim_showstate.GetInt() == GetBasePlayer()->entindex() )
{
DebugShowAnimStateForPlayer( GetBasePlayer()->IsServer() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Cancel the current gesture and restart the main sequence.
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::RestartMainSequence( void )
{
CBaseAnimatingOverlay *pPlayer = GetBasePlayer();
if ( pPlayer )
{
pPlayer->m_flAnimTime = gpGlobals->curtime;
pPlayer->SetCycle( 0 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *idealActivity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::HandleJumping( Activity &idealActivity )
{
if ( m_bJumping )
{
if ( m_bFirstJumpFrame )
{
m_bFirstJumpFrame = false;
RestartMainSequence(); // Reset the animation.
}
// Check to see if we hit water and stop jumping animation.
if ( GetBasePlayer()->GetWaterLevel() >= WL_Waist )
{
m_bJumping = false;
RestartMainSequence();
}
// Don't check if he's on the ground for a sec.. sometimes the client still has the
// on-ground flag set right when the message comes in.
else if ( gpGlobals->curtime - m_flJumpStartTime > 0.2f )
{
if ( GetBasePlayer()->GetFlags() & FL_ONGROUND )
{
m_bJumping = false;
RestartMainSequence();
}
}
}
if ( m_bJumping )
{
idealActivity = ACT_MP_JUMP;
return true;
}
else
{
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *idealActivity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::HandleDucking( Activity &idealActivity )
{
if ( GetBasePlayer()->GetFlags() & FL_DUCKING )
{
if ( GetOuterXYSpeed() > MOVING_MINIMUM_SPEED )
{
idealActivity = ACT_MP_CROUCHWALK;
}
else
{
idealActivity = ACT_MP_CROUCH_IDLE;
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &idealActivity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::HandleSwimming( Activity &idealActivity )
{
if ( GetBasePlayer()->GetWaterLevel() >= WL_Waist )
{
if ( m_bFirstSwimFrame )
{
// Reset the animation.
RestartMainSequence();
m_bFirstSwimFrame = false;
}
idealActivity = ACT_MP_SWIM;
m_bInSwim = true;
return true;
}
else
{
m_bInSwim = false;
if ( !m_bFirstSwimFrame )
{
m_bFirstSwimFrame = true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *idealActivity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::HandleDying( Activity &idealActivity )
{
if ( m_bDying )
{
if ( m_bFirstDyingFrame )
{
// Reset the animation.
RestartMainSequence();
m_bFirstDyingFrame = false;
}
idealActivity = ACT_DIESIMPLE;
return true;
}
else
{
if ( !m_bFirstDyingFrame )
{
m_bFirstDyingFrame = true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *idealActivity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::HandleMoving( Activity &idealActivity )
{
// In TF we run all the time now.
float flSpeed = GetOuterXYSpeed();
if ( flSpeed > MOVING_MINIMUM_SPEED )
{
// Always assume a run.
idealActivity = ACT_MP_RUN;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
// Output : Activity
//-----------------------------------------------------------------------------
Activity CMultiPlayerAnimState::CalcMainActivity()
{
Activity idealActivity = ACT_MP_STAND_IDLE;
if ( HandleJumping( idealActivity ) ||
HandleDucking( idealActivity ) ||
HandleSwimming( idealActivity ) ||
HandleDying( idealActivity ) )
{
// intentionally blank
}
else
{
HandleMoving( idealActivity );
}
ShowDebugInfo();
// Client specific.
#ifdef CLIENT_DLL
if ( anim_showmainactivity.GetBool() )
{
DebugShowActivity( idealActivity );
}
#endif
return idealActivity;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : actDesired -
// Output : Activity
//-----------------------------------------------------------------------------
Activity CMultiPlayerAnimState::TranslateActivity( Activity actDesired )
{
// Translate activities for swimming.
if ( m_bInSwim )
{
switch ( actDesired )
{
case ACT_MP_ATTACK_STAND_PRIMARYFIRE: { actDesired = ACT_MP_ATTACK_SWIM_PRIMARYFIRE; break; }
case ACT_MP_ATTACK_STAND_SECONDARYFIRE: { actDesired = ACT_MP_ATTACK_SWIM_SECONDARYFIRE; break; }
case ACT_MP_ATTACK_STAND_GRENADE: { actDesired = ACT_MP_ATTACK_SWIM_GRENADE; break; }
case ACT_MP_RELOAD_STAND: { actDesired = ACT_MP_RELOAD_SWIM; break; }
}
}
return actDesired;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
// Output : float
//-----------------------------------------------------------------------------
float CMultiPlayerAnimState::GetCurrentMaxGroundSpeed()
{
CStudioHdr *pStudioHdr = GetBasePlayer()->GetModelPtr();
if ( pStudioHdr == NULL )
return 1.0f;
float prevX = GetBasePlayer()->GetPoseParameter( m_PoseParameterData.m_iMoveX );
float prevY = GetBasePlayer()->GetPoseParameter( m_PoseParameterData.m_iMoveY );
float d = MAX( fabs( prevX ), fabs( prevY ) );
float newX, newY;
if ( d == 0.0 )
{
newX = 1.0;
newY = 0.0;
}
else
{
newX = prevX / d;
newY = prevY / d;
}
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, newX );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, newY );
float speed = GetBasePlayer()->GetSequenceGroundSpeed( GetBasePlayer()->GetSequence() );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, prevX );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, prevY );
return speed;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *bIsMoving -
// Output : float
//-----------------------------------------------------------------------------
float CMultiPlayerAnimState::CalcMovementSpeed( bool *bIsMoving )
{
// Get the player's current velocity and speed.
Vector vecVelocity;
GetOuterAbsVelocity( vecVelocity );
float flSpeed = vecVelocity.Length2D();
if ( flSpeed > MOVING_MINIMUM_SPEED )
{
*bIsMoving = true;
return flSpeed;
}
*bIsMoving = false;
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *bIsMoving -
// Output : float
//-----------------------------------------------------------------------------
float CMultiPlayerAnimState::CalcMovementPlaybackRate( bool *bIsMoving )
{
float flSpeed = CalcMovementSpeed( bIsMoving );
float flReturn = 1.0f;
// If we are moving.
if ( *bIsMoving )
{
// float flGroundSpeed = GetInterpolatedGroundSpeed();
float flGroundSpeed = GetCurrentMaxGroundSpeed();
if ( flGroundSpeed < 0.001f )
{
flReturn = 0.01f;
}
else
{
// Note this gets set back to 1.0 if sequence changes due to ResetSequenceInfo below
flReturn = flSpeed / flGroundSpeed;
flReturn = clamp( flReturn, 0.01f, 10.0f );
}
}
return flReturn;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CMultiPlayerAnimState::GetInterpolatedGroundSpeed( void )
{
return m_flMaxGroundSpeed;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pStudioHdr -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ComputeSequences( CStudioHdr *pStudioHdr )
{
VPROF( "CBasePlayerAnimState::ComputeSequences" );
// Lower body (walk/run/idle).
ComputeMainSequence();
// The groundspeed interpolator uses the main sequence info.
UpdateInterpolators();
ComputeGestureSequence( pStudioHdr );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ComputeMainSequence()
{
VPROF( "CBasePlayerAnimState::ComputeMainSequence" );
CBaseAnimatingOverlay *pPlayer = GetBasePlayer();
// Have our class or the mod-specific class determine what the current activity is.
Activity idealActivity = CalcMainActivity();
#ifdef CLIENT_DLL
Activity oldActivity = m_eCurrentMainSequenceActivity;
#endif
// Store our current activity so the aim and fire layers know what to do.
m_eCurrentMainSequenceActivity = idealActivity;
// Hook to force playback of a specific requested full-body sequence
if ( m_nSpecificMainSequence >= 0 )
{
if ( pPlayer->GetSequence() != m_nSpecificMainSequence )
{
pPlayer->ResetSequence( m_nSpecificMainSequence );
ResetGroundSpeed();
return;
}
if ( !pPlayer->IsSequenceFinished() )
return;
m_nSpecificMainSequence = -1;
RestartMainSequence();
ResetGroundSpeed();
}
// Export to our outer class..
int animDesired = SelectWeightedSequence( TranslateActivity( idealActivity ) );
if ( pPlayer->GetSequenceActivity( pPlayer->GetSequence() ) == pPlayer->GetSequenceActivity( animDesired ) )
return;
if ( animDesired < 0 )
{
animDesired = 0;
}
pPlayer->ResetSequence( animDesired );
#ifdef CLIENT_DLL
// If we went from idle to walk, reset the interpolation history.
// Kind of hacky putting this here.. it might belong outside the base class.
if ( (oldActivity == ACT_MP_CROUCH_IDLE || oldActivity == ACT_MP_STAND_IDLE || oldActivity == ACT_MP_DEPLOYED_IDLE || oldActivity == ACT_MP_CROUCH_DEPLOYED_IDLE ) &&
(idealActivity == ACT_MP_WALK || idealActivity == ACT_MP_CROUCHWALK ) )
{
ResetGroundSpeed();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ResetGroundSpeed( void )
{
#ifdef CLIENT_DLL
m_flMaxGroundSpeed = GetCurrentMaxGroundSpeed();
m_iv_flMaxGroundSpeed.Reset();
m_iv_flMaxGroundSpeed.NoteChanged( gpGlobals->curtime, 0, false );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::UpdateInterpolators()
{
VPROF( "CBasePlayerAnimState::UpdateInterpolators" );
// First, figure out their current max speed based on their current activity.
float flCurMaxSpeed = GetCurrentMaxGroundSpeed();
#ifdef CLIENT_DLL
float flGroundSpeedInterval = 0.1;
// Only update this 10x/sec so it has an interval to interpolate over.
if ( gpGlobals->curtime - m_flLastGroundSpeedUpdateTime >= flGroundSpeedInterval )
{
m_flLastGroundSpeedUpdateTime = gpGlobals->curtime;
m_flMaxGroundSpeed = flCurMaxSpeed;
m_iv_flMaxGroundSpeed.NoteChanged( gpGlobals->curtime, flGroundSpeedInterval, false );
}
m_iv_flMaxGroundSpeed.Interpolate( gpGlobals->curtime, flGroundSpeedInterval );
#else
m_flMaxGroundSpeed = flCurMaxSpeed;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ComputeFireSequence( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pStudioHdr -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ComputeGestureSequence( CStudioHdr *pStudioHdr )
{
// Update all active gesture layers.
for ( int iGesture = 0; iGesture < GESTURE_SLOT_COUNT; ++iGesture )
{
if ( !m_aGestureSlots[iGesture].m_bActive )
continue;
if ( !VerifyAnimLayerInSlot( iGesture ) )
continue;
UpdateGestureLayer( pStudioHdr, &m_aGestureSlots[iGesture] );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::UpdateGestureLayer( CStudioHdr *pStudioHdr, GestureSlot_t *pGesture )
{
// Sanity check.
if ( !pStudioHdr || !pGesture )
return;
CBasePlayer *pPlayer = GetBasePlayer();
if( !pPlayer )
return;
#ifdef CLIENT_DLL
// Get the current cycle.
float flCycle = pGesture->m_pAnimLayer->m_flCycle;
flCycle += pPlayer->GetSequenceCycleRate( pStudioHdr, pGesture->m_pAnimLayer->m_nSequence ) * gpGlobals->frametime * GetGesturePlaybackRate() * pGesture->m_pAnimLayer->m_flPlaybackRate;
pGesture->m_pAnimLayer->m_flPrevCycle = pGesture->m_pAnimLayer->m_flCycle;
pGesture->m_pAnimLayer->m_flCycle = flCycle;
if( flCycle > 1.0f )
{
RunGestureSlotAnimEventsToCompletion( pGesture );
if ( pGesture->m_bAutoKill )
{
ResetGestureSlot( pGesture->m_iGestureSlot );
return;
}
else
{
pGesture->m_pAnimLayer->m_flCycle = 1.0f;
}
}
#else
if ( pGesture->m_iActivity != ACT_INVALID && pGesture->m_pAnimLayer->m_nActivity == ACT_INVALID )
{
ResetGestureSlot( pGesture->m_iGestureSlot );
}
#endif
}
extern ConVar mp_facefronttime;
extern ConVar mp_feetyawrate;
//-----------------------------------------------------------------------------
// Purpose:
// Input : eyeYaw -
// eyePitch -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::Update( float eyeYaw, float eyePitch )
{
// Profile the animation update.
VPROF( "CMultiPlayerAnimState::Update" );
// Get the studio header for the player.
CStudioHdr *pStudioHdr = GetBasePlayer()->GetModelPtr();
if ( !pStudioHdr )
return;
// Check to see if we should be updating the animation state - dead, ragdolled?
if ( !ShouldUpdateAnimState() )
{
ClearAnimationState();
return;
}
// Store the eye angles.
m_flEyeYaw = AngleNormalize( eyeYaw );
m_flEyePitch = AngleNormalize( eyePitch );
// Compute the player sequences.
ComputeSequences( pStudioHdr );
if ( SetupPoseParameters( pStudioHdr ) )
{
// Pose parameter - what direction are the player's legs running in.
ComputePoseParam_MoveYaw( pStudioHdr );
// Pose parameter - Torso aiming (up/down).
ComputePoseParam_AimPitch( pStudioHdr );
// Pose parameter - Torso aiming (rotation).
ComputePoseParam_AimYaw( pStudioHdr );
}
#ifdef CLIENT_DLL
if ( C_BasePlayer::ShouldDrawLocalPlayer() )
{
GetBasePlayer()->SetPlaybackRate( 1.0f );
}
#endif
if( mp_showgestureslots.GetInt() == GetBasePlayer()->entindex() )
{
DebugGestureInfo();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::ShouldUpdateAnimState()
{
// Don't update anim state if we're not visible
if ( GetBasePlayer()->IsEffectActive( EF_NODRAW ) )
return false;
// By default, don't update their animation state when they're dead because they're
// either a ragdoll or they're not drawn.
#ifdef CLIENT_DLL
if ( GetBasePlayer()->IsDormant() )
return false;
#endif
return (GetBasePlayer()->IsAlive() || m_bDying);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CMultiPlayerAnimState::SetupPoseParameters( CStudioHdr *pStudioHdr )
{
// Check to see if this has already been done.
if ( m_bPoseParameterInit )
return true;
// Save off the pose parameter indices.
if ( !pStudioHdr )
return false;
m_bPoseParameterInit = true;
// Look for the movement blenders.
m_PoseParameterData.m_iMoveX = GetBasePlayer()->LookupPoseParameter( pStudioHdr, "move_x" );
m_PoseParameterData.m_iMoveY = GetBasePlayer()->LookupPoseParameter( pStudioHdr, "move_y" );
/*
if ( ( m_PoseParameterData.m_iMoveX < 0 ) || ( m_PoseParameterData.m_iMoveY < 0 ) )
return false;
*/
// Look for the aim pitch blender.
m_PoseParameterData.m_iAimPitch = GetBasePlayer()->LookupPoseParameter( pStudioHdr, "body_pitch" );
/*
if ( m_PoseParameterData.m_iAimPitch < 0 )
return false;
*/
// Look for aim yaw blender.
m_PoseParameterData.m_iAimYaw = GetBasePlayer()->LookupPoseParameter( pStudioHdr, "body_yaw" );
/*
if ( m_PoseParameterData.m_iAimYaw < 0 )
return false;
*/
m_PoseParameterData.m_iMoveYaw = GetBasePlayer()->LookupPoseParameter( pStudioHdr, "move_yaw" );
m_PoseParameterData.m_iMoveScale = GetBasePlayer()->LookupPoseParameter( pStudioHdr, "move_scale" );
/*
if ( ( m_PoseParameterData.m_iMoveYaw < 0 ) || ( m_PoseParameterData.m_iMoveScale < 0 ) )
return false;
*/
return true;
}
float SnapYawTo( float flValue )
{
float flSign = 1.0f;
if ( flValue < 0.0f )
{
flSign = -1.0f;
flValue = -flValue;
}
if ( flValue < 23.0f )
{
flValue = 0.0f;
}
else if ( flValue < 67.0f )
{
flValue = 45.0f;
}
else if ( flValue < 113.0f )
{
flValue = 90.0f;
}
else if ( flValue < 157 )
{
flValue = 135.0f;
}
else
{
flValue = 180.0f;
}
return ( flValue * flSign );
}
//-----------------------------------------------------------------------------
// Purpose: double check that the movement animations actually have movement
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::DoMovementTest( CStudioHdr *pStudioHdr, float flX, float flY )
{
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, flX );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, flY );
#ifdef STAGING_ONLY
float flTestSpeed = GetBasePlayer()->GetSequenceGroundSpeed( m_nMovementSequence );
if ( flTestSpeed < 10.0f )
{
Warning( "%s : %s (X %.0f Y %.0f) missing movement\n", pStudioHdr->pszName(), GetBasePlayer()->GetSequenceName( m_nMovementSequence ), flX, flY );
}
#endif
/*
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, flX );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, flY );
float flDuration = GetBasePlayer()->SequenceDuration( m_nMovementSequence );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, 1.0f );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, 0.0f );
float flForward = GetBasePlayer()->SequenceDuration( m_nMovementSequence );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, 0.0f );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, 0.0f );
float flCenter = GetBasePlayer()->SequenceDuration( m_nMovementSequence );
if ( flDuration > flForward * 1.1f || flDuration < flForward * 0.9f )
{
Warning( "%s : %s (X %.0f Y %.0f) mismatched duration with forward %.1f vs %.1f\n", pStudioHdr->pszName(), GetBasePlayer()->GetSequenceName( m_nMovementSequence ), flX, flY, flDuration, flForward );
}
if ( flDuration > flCenter * 1.1f || flDuration < flCenter * 0.9f )
{
Warning( "%s : %s (X %.0f Y %.0f) mismatched duration with center %.1f vs %.1f\n", pStudioHdr->pszName(), GetBasePlayer()->GetSequenceName( m_nMovementSequence ), flX, flY, flDuration, flCenter );
}
*/
}
void CMultiPlayerAnimState::DoMovementTest( CStudioHdr *pStudioHdr )
{
if ( m_LegAnimType == LEGANIM_9WAY )
{
DoMovementTest( pStudioHdr, -1.0f, -1.0f );
DoMovementTest( pStudioHdr, -1.0f, 0.0f );
DoMovementTest( pStudioHdr, -1.0f, 1.0f );
DoMovementTest( pStudioHdr, 0.0f, -1.0f );
DoMovementTest( pStudioHdr, 0.0f, 1.0f );
DoMovementTest( pStudioHdr, 1.0f, -1.0f );
DoMovementTest( pStudioHdr, 1.0f, 0.0f );
DoMovementTest( pStudioHdr, 1.0f, 1.0f );
}
}
void CMultiPlayerAnimState::GetMovementFlags( CStudioHdr *pStudioHdr )
{
if ( m_nMovementSequence == GetBasePlayer()->GetSequence() )
{
return;
}
m_nMovementSequence = GetBasePlayer()->GetSequence();
m_LegAnimType = LEGANIM_9WAY;
KeyValues *seqKeyValues = GetBasePlayer()->GetSequenceKeyValues( m_nMovementSequence );
// Msg("sequence %d : %s (%d)\n", sequence, GetOuter()->GetSequenceName( sequence ), seqKeyValues != NULL );
if (seqKeyValues)
{
KeyValues *pkvMovement = seqKeyValues->FindKey( "movement" );
if (pkvMovement)
{
const char *szStyle = pkvMovement->GetString();
if ( V_stricmp( szStyle, "robot2" ) == 0 )
{
m_LegAnimType = LEGANIM_8WAY;
}
}
seqKeyValues->deleteThis();
}
// skip tests if it's not a movement animation
if ( m_nMovementSequence < 0 || !( GetBasePlayer()->GetFlags() & FL_ONGROUND ) || pStudioHdr->pSeqdesc( m_nMovementSequence ).groupsize[0] == 1 )
{
return;
}
DoMovementTest( pStudioHdr );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pStudioHdr -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ComputePoseParam_MoveYaw( CStudioHdr *pStudioHdr )
{
// Get the estimated movement yaw.
EstimateYaw();
// Get the view yaw.
float flAngle = AngleNormalize( m_flEyeYaw );
// Calc side to side turning - the view vs. movement yaw.
float flYaw = flAngle - m_PoseParameterData.m_flEstimateYaw;
flYaw = AngleNormalize( -flYaw );
// Get the current speed the character is running.
bool bIsMoving;
float flSpeed = CalcMovementSpeed( &bIsMoving );
// Setup the 9-way blend parameters based on our speed and direction.
Vector2D vecCurrentMoveYaw( 0.0f, 0.0f );
if ( bIsMoving )
{
GetMovementFlags( pStudioHdr );
if ( mp_slammoveyaw.GetBool() )
{
flYaw = SnapYawTo( flYaw );
}
if ( m_LegAnimType == LEGANIM_9WAY )
{
// convert YAW back into vector
vecCurrentMoveYaw.x = cos( DEG2RAD( flYaw ) );
vecCurrentMoveYaw.y = -sin( DEG2RAD( flYaw ) );
// push edges out to -1 to 1 box
float flInvScale = MAX( fabs( vecCurrentMoveYaw.x ), fabs( vecCurrentMoveYaw.y ) );
if ( flInvScale != 0.0f )
{
vecCurrentMoveYaw.x /= flInvScale;
vecCurrentMoveYaw.y /= flInvScale;
}
// find what speed was actually authored
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, vecCurrentMoveYaw.x );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, vecCurrentMoveYaw.y );
float flMaxSpeed = GetBasePlayer()->GetSequenceGroundSpeed( GetBasePlayer()->GetSequence() );
// scale playback
if ( flMaxSpeed > flSpeed )
{
vecCurrentMoveYaw.x *= flSpeed / flMaxSpeed;
vecCurrentMoveYaw.y *= flSpeed / flMaxSpeed;
}
// Set the 9-way blend movement pose parameters.
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, vecCurrentMoveYaw.x );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, vecCurrentMoveYaw.y );
}
else
{
// find what speed was actually authored
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveYaw, flYaw );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveScale, 1.0f );
float flMaxSpeed = GetBasePlayer()->GetSequenceGroundSpeed( GetBasePlayer()->GetSequence() );
// scale playback
if ( flMaxSpeed > flSpeed )
{
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveScale, flSpeed / flMaxSpeed );
}
}
}
else
{
// Set the 9-way blend movement pose parameters.
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveX, 0.0f );
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iMoveY, 0.0f );
}
m_DebugAnimData.m_vecMoveYaw = vecCurrentMoveYaw;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::EstimateYaw( void )
{
// Get the frame time.
float flDeltaTime = gpGlobals->frametime;
if ( flDeltaTime == 0.0f )
return;
// Get the player's velocity and angles.
Vector vecEstVelocity;
GetOuterAbsVelocity( vecEstVelocity );
QAngle angles = GetBasePlayer()->GetLocalAngles();
// If we are not moving, sync up the feet and eyes slowly.
if ( vecEstVelocity.x == 0.0f && vecEstVelocity.y == 0.0f )
{
float flYawDelta = angles[YAW] - m_PoseParameterData.m_flEstimateYaw;
flYawDelta = AngleNormalize( flYawDelta );
if ( flDeltaTime < 0.25f )
{
flYawDelta *= ( flDeltaTime * 4.0f );
}
else
{
flYawDelta *= flDeltaTime;
}
m_PoseParameterData.m_flEstimateYaw += flYawDelta;
AngleNormalize( m_PoseParameterData.m_flEstimateYaw );
}
else
{
m_PoseParameterData.m_flEstimateYaw = ( atan2( vecEstVelocity.y, vecEstVelocity.x ) * 180.0f / M_PI );
m_PoseParameterData.m_flEstimateYaw = clamp( m_PoseParameterData.m_flEstimateYaw, -180.0f, 180.0f );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ComputePoseParam_AimPitch( CStudioHdr *pStudioHdr )
{
// Get the view pitch.
float flAimPitch = m_flEyePitch;
// Set the aim pitch pose parameter and save.
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iAimPitch, -flAimPitch );
m_DebugAnimData.m_flAimPitch = flAimPitch;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ComputePoseParam_AimYaw( CStudioHdr *pStudioHdr )
{
// Get the movement velocity.
Vector vecVelocity;
GetOuterAbsVelocity( vecVelocity );
// Check to see if we are moving.
bool bMoving = ( vecVelocity.Length() > 1.0f ) ? true : false;
// If we are moving or are prone and undeployed.
// If you are forcing aim yaw, your code is almost definitely broken if you don't include a delay between
// teleporting and forcing yaw. This is due to an unfortunate interaction between the command lookback window,
// and the fact that m_flEyeYaw is never propogated from the server to the client.
// TODO: Fix this after Halloween 2014.
if ( bMoving || m_bForceAimYaw )
{
// The feet match the eye direction when moving - the move yaw takes care of the rest.
m_flGoalFeetYaw = m_flEyeYaw;
}
// Else if we are not moving.
else
{
// Initialize the feet.
if ( m_PoseParameterData.m_flLastAimTurnTime <= 0.0f )
{
m_flGoalFeetYaw = m_flEyeYaw;
m_flCurrentFeetYaw = m_flEyeYaw;
m_PoseParameterData.m_flLastAimTurnTime = gpGlobals->curtime;
}
// Make sure the feet yaw isn't too far out of sync with the eye yaw.
// TODO: Do something better here!
else
{
float flYawDelta = AngleNormalize( m_flGoalFeetYaw - m_flEyeYaw );
if ( fabs( flYawDelta ) > 45.0f/*m_AnimConfig.m_flMaxBodyYawDegrees*/ )
{
float flSide = ( flYawDelta > 0.0f ) ? -1.0f : 1.0f;
m_flGoalFeetYaw += ( 45.0f/*m_AnimConfig.m_flMaxBodyYawDegrees*/ * flSide );
}
}
}
// Fix up the feet yaw.
m_flGoalFeetYaw = AngleNormalize( m_flGoalFeetYaw );
if ( m_flGoalFeetYaw != m_flCurrentFeetYaw )
{
// If you are forcing aim yaw, your code is almost definitely broken if you don't include a delay between
// teleporting and forcing yaw. This is due to an unfortunate interaction between the command lookback window,
// and the fact that m_flEyeYaw is never propogated from the server to the client.
// TODO: Fix this after Halloween 2014.
if ( m_bForceAimYaw )
{
m_flCurrentFeetYaw = m_flGoalFeetYaw;
}
else
{
ConvergeYawAngles( m_flGoalFeetYaw, /*DOD_BODYYAW_RATE*/720.0f, gpGlobals->frametime, m_flCurrentFeetYaw );
m_flLastAimTurnTime = gpGlobals->curtime;
}
}
// Rotate the body into position.
m_angRender[YAW] = m_flCurrentFeetYaw;
// Find the aim(torso) yaw base on the eye and feet yaws.
float flAimYaw = m_flEyeYaw - m_flCurrentFeetYaw;
flAimYaw = AngleNormalize( flAimYaw );
// Set the aim yaw and save.
GetBasePlayer()->SetPoseParameter( pStudioHdr, m_PoseParameterData.m_iAimYaw, -flAimYaw );
m_DebugAnimData.m_flAimYaw = flAimYaw;
// Turn off a force aim yaw - either we have already updated or we don't need to.
m_bForceAimYaw = false;
#ifndef CLIENT_DLL
QAngle angle = GetBasePlayer()->GetAbsAngles();
angle[YAW] = m_flCurrentFeetYaw;
GetBasePlayer()->SetAbsAngles( angle );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flGoalYaw -
// flYawRate -
// flDeltaTime -
// &flCurrentYaw -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::ConvergeYawAngles( float flGoalYaw, float flYawRate, float flDeltaTime, float &flCurrentYaw )
{
#define FADE_TURN_DEGREES 60.0f
// Find the yaw delta.
float flDeltaYaw = flGoalYaw - flCurrentYaw;
float flDeltaYawAbs = fabs( flDeltaYaw );
flDeltaYaw = AngleNormalize( flDeltaYaw );
// Always do at least a bit of the turn (1%).
float flScale = 1.0f;
flScale = flDeltaYawAbs / FADE_TURN_DEGREES;
flScale = clamp( flScale, 0.01f, 1.0f );
float flYaw = flYawRate * flDeltaTime * flScale;
if ( flDeltaYawAbs < flYaw )
{
flCurrentYaw = flGoalYaw;
}
else
{
float flSide = ( flDeltaYaw < 0.0f ) ? -1.0f : 1.0f;
flCurrentYaw += ( flYaw * flSide );
}
flCurrentYaw = AngleNormalize( flCurrentYaw );
#undef FADE_TURN_DEGREES
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
// Output : const QAngle&
//-----------------------------------------------------------------------------
const QAngle& CMultiPlayerAnimState::GetRenderAngles()
{
return m_angRender;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : vel -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::GetOuterAbsVelocity( Vector& vel )
{
#if defined( CLIENT_DLL )
GetBasePlayer()->EstimateAbsVelocity( vel );
#else
vel = GetBasePlayer()->GetAbsVelocity();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::Release( void )
{
delete this;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
// Output : float
//-----------------------------------------------------------------------------
float CMultiPlayerAnimState::GetOuterXYSpeed()
{
Vector vel;
GetOuterAbsVelocity( vel );
return vel.Length2D();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Anim_StateLog( const char *pMsg, ... )
{
// Format the string.
char str[4096];
va_list marker;
va_start( marker, pMsg );
Q_vsnprintf( str, sizeof( str ), pMsg, marker );
va_end( marker );
// Log it?
if ( anim_showstatelog.GetInt() == 1 || anim_showstatelog.GetInt() == 3 )
{
Msg( "%s", str );
}
if ( anim_showstatelog.GetInt() > 1 )
{
// static FileHandle_t hFile = filesystem->Open( "AnimState.log", "wt" );
// filesystem->FPrintf( hFile, "%s", str );
// filesystem->Flush( hFile );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Anim_StatePrintf( int iLine, const char *pMsg, ... )
{
// Format the string.
char str[4096];
va_list marker;
va_start( marker, pMsg );
Q_vsnprintf( str, sizeof( str ), pMsg, marker );
va_end( marker );
// Show it with Con_NPrintf.
engine->Con_NPrintf( iLine, "%s", str );
// Log it.
Anim_StateLog( "%s\n", str );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::DebugShowAnimStateForPlayer( bool bIsServer )
{
// Get the player's velocity.
Vector vecVelocity;
GetOuterAbsVelocity( vecVelocity );
// Start animation state logging.
int iLine = 5;
if ( bIsServer )
{
iLine = 12;
}
// Anim_StateLog( "-------------%s: frame %d -----------------\n", bIsServer ? "Server" : "Client", gpGlobals->framecount );
Anim_StatePrintf( iLine++, "-------------%s: frame %d -----------------\n", bIsServer ? "Server" : "Client", gpGlobals->framecount );
// Write out the main sequence and its data.
Anim_StatePrintf( iLine++, "Main: %s, Cycle: %.2f\n", GetSequenceName( GetBasePlayer()->GetModelPtr(), GetBasePlayer()->GetSequence() ), GetBasePlayer()->GetCycle() );
#if 0
if ( m_bPlayingGesture )
{
Anim_StatePrintf( iLine++, "Gesture: %s, Cycle: %.2f\n",
GetSequenceName( GetBasePlayer()->GetModelPtr(), m_iGestureSequence ),
m_flGestureCycle );
}
#endif
// Write out the layers and their data.
for ( int iAnim = 0; iAnim < GetBasePlayer()->GetNumAnimOverlays(); ++iAnim )
{
#ifdef CLIENT_DLL
C_AnimationLayer *pLayer = GetBasePlayer()->GetAnimOverlay( iAnim );
if ( pLayer && ( pLayer->m_nOrder != CBaseAnimatingOverlay::MAX_OVERLAYS ) )
{
Anim_StatePrintf( iLine++, "Layer %s: Weight: %.2f, Cycle: %.2f", GetSequenceName( GetBasePlayer()->GetModelPtr(), pLayer->m_nSequence ), (float)pLayer->m_flWeight, (float)pLayer->m_flCycle );
}
#else
CAnimationLayer *pLayer = GetBasePlayer()->GetAnimOverlay( iAnim );
if ( pLayer && ( pLayer->m_nOrder != CBaseAnimatingOverlay::MAX_OVERLAYS ) )
{
Anim_StatePrintf( iLine++, "Layer %s: Weight: %.2f, Cycle: %.2f", GetSequenceName( GetBasePlayer()->GetModelPtr(), pLayer->m_nSequence ), (float)pLayer->m_flWeight, (float)pLayer->m_flCycle );
}
#endif
}
// Write out the speed data.
Anim_StatePrintf( iLine++, "Time: %.2f, Speed: %.2f, MaxSpeed: %.2f", gpGlobals->curtime, vecVelocity.Length2D(), GetCurrentMaxGroundSpeed() );
// Write out the 9-way blend data.
Anim_StatePrintf( iLine++, "EntityYaw: %.2f, AimYaw: %.2f, AimPitch: %.2f, MoveX: %.2f, MoveY: %.2f", m_angRender[YAW], m_DebugAnimData.m_flAimYaw, m_DebugAnimData.m_flAimPitch, m_DebugAnimData.m_vecMoveYaw.x, m_DebugAnimData.m_vecMoveYaw.y );
// Anim_StateLog( "--------------------------------------------\n\n" );
Anim_StatePrintf( iLine++, "--------------------------------------------\n\n" );
DebugShowEyeYaw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::DebugShowEyeYaw( void )
{
#ifdef _NDEBUG
float flBaseSize = 10;
float flHeight = 80;
Vector vecPos = GetOuter()->GetAbsOrigin() + Vector( 0.0f, 0.0f, 3.0f );
QAngle angles( 0.0f, 0.0f, 0.0f );
angles[YAW] = m_flEyeYaw;
Vector vecForward, vecRight, vecUp;
AngleVectors( angles, &vecForward, &vecRight, &vecUp );
// Draw a red triangle on the ground for the eye yaw.
if ( debugoverlay )
{
debugoverlay->AddTriangleOverlay( ( vecPos + vecRight * flBaseSize / 2.0f ),
( vecPos - vecRight * flBaseSize / 2.0f ),
( vecPos + vecForward * flHeight, 255, 0, 0, 255, false, 0.01f );
}
#endif
}
#if defined( CLIENT_DLL )
//-----------------------------------------------------------------------------
// Purpose:
// Input : activity -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::DebugShowActivity( Activity activity )
{
#ifdef _DEBUG
const char *pszActivity = "other";
switch( activity )
{
case ACT_MP_STAND_IDLE:
{
pszActivity = "idle";
break;
}
case ACT_MP_SPRINT:
{
pszActivity = "sprint";
break;
}
case ACT_MP_WALK:
{
pszActivity = "walk";
break;
}
case ACT_MP_RUN:
{
pszActivity = "run";
break;
}
}
Msg( "Activity: %s\n", pszActivity );
#endif
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
// Input : iStartLine -
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::DebugShowAnimState( int iStartLine )
{
Vector vOuterVel;
GetOuterAbsVelocity( vOuterVel );
Anim_StateLog( "----------------- frame %d -----------------\n", gpGlobals->framecount );
int iLine = iStartLine;
Anim_StatePrintf( iLine++, "main: %s, cycle: %.2f\n", GetSequenceName( GetBasePlayer()->GetModelPtr(), GetBasePlayer()->GetSequence() ), GetBasePlayer()->GetCycle() );
#if defined( CLIENT_DLL )
for ( int i=0; i < GetBasePlayer()->GetNumAnimOverlays()-1; i++ )
{
C_AnimationLayer *pLayer = GetBasePlayer()->GetAnimOverlay( i /*i+1?*/ );
Anim_StatePrintf( iLine++, "%s, weight: %.2f, cycle: %.2f, aim (%d)",
pLayer->m_nOrder == CBaseAnimatingOverlay::MAX_OVERLAYS ? "--" : GetSequenceName( GetBasePlayer()->GetModelPtr(), pLayer->m_nSequence ),
pLayer->m_nOrder == CBaseAnimatingOverlay::MAX_OVERLAYS ? -1 :(float)pLayer->m_flWeight,
pLayer->m_nOrder == CBaseAnimatingOverlay::MAX_OVERLAYS ? -1 :(float)pLayer->m_flCycle,
i
);
}
#endif
Anim_StatePrintf( iLine++, "vel: %.2f, time: %.2f, max: %.2f",
vOuterVel.Length2D(), gpGlobals->curtime, GetInterpolatedGroundSpeed() );
// AnimStatePrintf( iLine++, "ent yaw: %.2f, body_yaw: %.2f, body_pitch: %.2f, move_x: %.2f, move_y: %.2f",
// m_angRender[YAW], g_flLastBodyYaw, g_flLastBodyPitch, m_vLastMovePose.x, m_vLastMovePose.y );
Anim_StateLog( "--------------------------------------------\n\n" );
if ( debugoverlay )
{
// Draw a red triangle on the ground for the eye yaw.
float flBaseSize = 10;
float flHeight = 80;
Vector vBasePos = GetBasePlayer()->GetAbsOrigin() + Vector( 0, 0, 3 );
QAngle angles( 0, 0, 0 );
angles[YAW] = m_flEyeYaw;
Vector vForward, vRight, vUp;
AngleVectors( angles, &vForward, &vRight, &vUp );
debugoverlay->AddTriangleOverlay( vBasePos+vRight*flBaseSize/2, vBasePos-vRight*flBaseSize/2, vBasePos+vForward*flHeight, 255, 0, 0, 255, false, 0.01 );
// Draw a blue triangle on the ground for the body yaw.
angles[YAW] = m_angRender[YAW];
AngleVectors( angles, &vForward, &vRight, &vUp );
debugoverlay->AddTriangleOverlay( vBasePos+vRight*flBaseSize/2, vBasePos-vRight*flBaseSize/2, vBasePos+vForward*flHeight, 0, 0, 255, 255, false, 0.01 );
}
}
// Debug!
const char *s_aGestureSlotNames[GESTURE_SLOT_COUNT] =
{
"Attack and Reload",
"Grenade",
"Jump",
"Swim",
"Flinch",
"VCD",
"Custom"
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::DebugGestureInfo( void )
{
CBasePlayer *pPlayer = GetBasePlayer();
if ( !pPlayer )
return;
int iLine = ( pPlayer->IsServer() ? 12 : ( 14 + GESTURE_SLOT_COUNT ) );
Anim_StatePrintf( iLine++, "%s\n", ( pPlayer->IsServer() ? "Server" : "Client" ) );
for ( int iGesture = 0; iGesture < GESTURE_SLOT_COUNT; ++iGesture )
{
GestureSlot_t *pGesture = &m_aGestureSlots[iGesture];
if ( pGesture )
{
if( pGesture->m_bActive )
{
Anim_StatePrintf( iLine++, "Gesture Slot %d(%s): %s %s(A:%s, C:%f P:%f)\n",
iGesture,
s_aGestureSlotNames[iGesture],
ActivityList_NameForIndex( pGesture->m_iActivity ),
GetSequenceName( pPlayer->GetModelPtr(), pGesture->m_pAnimLayer->m_nSequence ),
( pGesture->m_bAutoKill ? "true" : "false" ),
(float)pGesture->m_pAnimLayer->m_flCycle, (float)pGesture->m_pAnimLayer->m_flPlaybackRate );
}
else
{
Anim_StatePrintf( iLine++, "Gesture Slot %d(%s): NOT ACTIVE!\n", iGesture, s_aGestureSlotNames[iGesture] );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: New Model, init the pose parameters
//-----------------------------------------------------------------------------
void CMultiPlayerAnimState::OnNewModel( void )
{
m_bPoseParameterInit = false;
m_PoseParameterData.Init();
ClearAnimationState();
}