xutaxkamay/css_enhanced_waf
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Improved bone cache invalidation

Browse source 
Also improved lag comp, for now animations won't be interpolated
This commit is contained in:
Kamay Xutax 2024-09-02 10:33:13 +02:00
parent b9586237f1
commit ece2f9a81f
10 changed files with 116 additions and 105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
game/client/c_baseanimating.cpp
View file

@ -3012,8 +3012,18 @@ C_BaseAnimating* C_BaseAnimating::FindFollowedEntity()
void C_BaseAnimating::InvalidateBoneCache() void C_BaseAnimating::InvalidateBoneCache()
{ {
m_iMostRecentModelBoneCounter = g_iModelBoneCounter - 1; m_iMostRecentModelBoneCounter = 0xFFFFFFFF;
m_flLastBoneSetupTime = -FLT_MAX; m_flLastBoneSetupTime = -FLT_MAX;
if ( m_pBoneMergeCache )
{
delete m_pBoneMergeCache;
m_pBoneMergeCache = NULL;
// recreated in BuildTransformations
}
Studio_DestroyBoneCache( m_hitboxBoneCacheHandle );
m_hitboxBoneCacheHandle = 0;
} }

2
game/client/c_baseanimating.h
View file

@ -535,7 +535,7 @@ protected:
float m_flFadeScale; float m_flFadeScale;
bool m_bClientSideAnimation; bool m_bClientSideAnimation;
private: protected:
float m_flGroundSpeed; // computed linear movement rate for current sequence float m_flGroundSpeed; // computed linear movement rate for current sequence
float m_flLastEventCheck; // cycle index of when events were last checked float m_flLastEventCheck; // cycle index of when events were last checked

72
game/client/cstrike/c_cs_player.cpp
View file

@ -10,6 +10,7 @@
#include "c_user_message_register.h" #include "c_user_message_register.h"
#include "cdll_client_int.h" #include "cdll_client_int.h"
#include "convar.h" #include "convar.h"
#include "datacache/imdlcache.h"
#include "dt_recv.h" #include "dt_recv.h"
#include "iconvar.h" #include "iconvar.h"
#include "interpolatedvar.h" #include "interpolatedvar.h"
@ -737,7 +738,7 @@ C_CSPlayer::C_CSPlayer() :
m_angRenderAngles.Init(); m_angRenderAngles.Init();
AddVar( &m_angEyeAngles, &m_iv_angEyeAngles, LATCH_SIMULATION_VAR ); AddVar( &m_angEyeAngles, &m_iv_angEyeAngles, LATCH_SIMULATION_VAR );
AddVar( &m_angRenderAngles, &m_iv_angRenderAngles, LATCH_SIMULATION_VAR ); // AddVar( &m_angRenderAngles, &m_iv_angRenderAngles, LATCH_SIMULATION_VAR );
m_iLastAddonBits = m_iAddonBits = 0; m_iLastAddonBits = m_iAddonBits = 0;
m_iLastPrimaryAddon = m_iLastSecondaryAddon = WEAPON_NONE; m_iLastPrimaryAddon = m_iLastSecondaryAddon = WEAPON_NONE;
@ -2131,8 +2132,11 @@ void C_CSPlayer::FireGameEvent( IGameEvent* event )
bool shouldShowFireBulletHitboxes = cl_showfirebullethitboxes.GetInt() == 1 bool shouldShowFireBulletHitboxes = cl_showfirebullethitboxes.GetInt() == 1
|| cl_showfirebullethitboxes.GetInt() == 3; || cl_showfirebullethitboxes.GetInt() == 3;
// TODO_ENHANCED: compare from client's prediction values !
const auto ShowEventHitboxes = [&]( float flDuration ) const auto ShowEventHitboxes = [&]( float flDuration )
{ {
MDLCACHE_CRITICAL_SECTION();
const int index = event->GetInt( "userid" ); const int index = event->GetInt( "userid" );
if ( index == GetUserID() && IsLocalPlayer() ) if ( index == GetUserID() && IsLocalPlayer() )
{ {
@ -2173,26 +2177,27 @@ void C_CSPlayer::FireGameEvent( IGameEvent* event )
float flBackupBoneControllers[MAXSTUDIOBONECTRLS]; float flBackupBoneControllers[MAXSTUDIOBONECTRLS];
C_AnimationLayer backupAnimLayers[C_BaseAnimatingOverlay::MAX_OVERLAYS]; C_AnimationLayer backupAnimLayers[C_BaseAnimatingOverlay::MAX_OVERLAYS];
Vector vecBackupPosition = player->GetAbsOrigin(); Vector vecBackupPosition = player->GetAbsOrigin();
QAngle angBackupAngles = player->m_angRenderAngles; QAngle angBackupAngles = player->GetRenderAngles();
auto flOldCycle = GetCycle(); auto flOldCycle = GetCycle();
auto iOldSequence = GetSequence(); auto iOldSequence = GetSequence();
auto pStudioHdr = GetModelPtr(); for ( int i = 0; i < MAXSTUDIOPOSEPARAM; i++ )
{
flBackupPoseParams[i] = player->m_flPoseParameter[i];
}
player->GetPoseParameters( pStudioHdr, flBackupPoseParams ); for ( int i = 0; i < MAXSTUDIOBONECTRLS; i++ )
player->GetBoneControllers( flBackupBoneControllers ); {
flBackupBoneControllers[i] = player->m_flEncodedController[i];
}
for ( int i = 0; i < GetNumAnimOverlays(); i++ ) for ( int i = 0; i < GetNumAnimOverlays(); i++ )
{ {
backupAnimLayers[i] = m_AnimOverlay[i]; backupAnimLayers[i] = *player->GetAnimOverlay(i);
} }
player->SetSequence( event->GetInt( "sequence" ) ); player->SetSequence( event->GetInt( "sequence" ) );
player->SetCycle( event->GetFloat( "cycle" ) ); player->SetCycle( event->GetFloat( "cycle" ) );
// printf("was sequence: %i, cycle: %f\n", player->GetSequence(), player->GetCycle() );
// Set setup bones modifiers
player->SetAbsOrigin( Vector( event->GetFloat( "position_x" ), player->SetAbsOrigin( Vector( event->GetFloat( "position_x" ),
event->GetFloat( "position_y" ), event->GetFloat( "position_y" ),
event->GetFloat( "position_z" ) ) ); event->GetFloat( "position_z" ) ) );
@ -2209,9 +2214,7 @@ void C_CSPlayer::FireGameEvent( IGameEvent* event )
char buffer[256]; char buffer[256];
V_sprintf_safe( buffer, "pose_param_%i", i ); V_sprintf_safe( buffer, "pose_param_%i", i );
player->SetPoseParameter( i, event->GetFloat( buffer ) ); player->m_flPoseParameter[i] = event->GetFloat( buffer );
// printf("pose_param_%i: %f\n", i, player->GetPoseParameter(i) );
} }
const auto numbonecontrollers = event->GetInt( "num_bonecontrollers" ); const auto numbonecontrollers = event->GetInt( "num_bonecontrollers" );
@ -2222,11 +2225,7 @@ void C_CSPlayer::FireGameEvent( IGameEvent* event )
char buffer[256]; char buffer[256];
V_sprintf_safe( buffer, "bone_controller_%i", i ); V_sprintf_safe( buffer, "bone_controller_%i", i );
player->SetBoneController( i, event->GetFloat( buffer ) ); player->m_flEncodedController[i] = event->GetFloat( buffer );
float tmp[MAXSTUDIOBONECTRLS];
player->GetBoneControllers( tmp );
// printf( "bone_controller_%i: %f\n", i, tmp[i] );
} }
auto numanimoverlays = event->GetInt( "num_anim_overlays" ); auto numanimoverlays = event->GetInt( "num_anim_overlays" );
@ -2239,32 +2238,27 @@ void C_CSPlayer::FireGameEvent( IGameEvent* event )
char buffer[256]; char buffer[256];
V_sprintf_safe( buffer, "anim_overlay_cycle_%i", i ); V_sprintf_safe( buffer, "anim_overlay_cycle_%i", i );
animOverlay->m_flCycle = event->GetFloat( buffer ); animOverlay->m_flCycle = event->GetFloat( buffer );
// printf( "anim_overlay_cycle_%i: %f\n", i, animOverlay->m_flCycle.GetRaw() );
V_sprintf_safe( buffer, "anim_overlay_sequence_%i", i ); V_sprintf_safe( buffer, "anim_overlay_sequence_%i", i );
animOverlay->m_nSequence = event->GetInt( buffer ); animOverlay->m_nSequence = event->GetInt( buffer );
// printf( "anim_overlay_sequence_%i: %i\n", i, animOverlay->m_nSequence.GetRaw() );
V_sprintf_safe( buffer, "anim_overlay_weight_%i", i ); V_sprintf_safe( buffer, "anim_overlay_weight_%i", i );
animOverlay->m_flWeight = event->GetFloat( buffer ); animOverlay->m_flWeight = event->GetFloat( buffer );
// printf( "anim_overlay_weight_%i: %f\n", i,animOverlay->m_flWeight.GetRaw() );
V_sprintf_safe( buffer, "anim_overlay_order_%i", i ); V_sprintf_safe( buffer, "anim_overlay_order_%i", i );
animOverlay->m_nOrder = event->GetInt( buffer ); animOverlay->m_nOrder = event->GetInt( buffer );
// printf( "anim_overlay_order_%i: %i\n", i, animOverlay->m_nOrder );
V_sprintf_safe( buffer, "anim_overlay_flags_%i", i );
animOverlay->m_fFlags = event->GetInt( buffer );
} }
PushAllowBoneAccess( true, false, "Lag compensation context" ); player->PushAllowBoneAccess( true, false, "Lag compensation context" );
// Be sure we setup the bones again. // Be sure we setup the bones again.
player->InvalidateBoneCache(); player->InvalidateBoneCache();
player->SetupBones( NULL, player->SetupBones( NULL, -1, BONE_USED_BY_ANYTHING, gpGlobals->curtime );
MAXSTUDIOBONES,
BONE_USED_BY_HITBOX | BONE_USED_BY_ATTACHMENT | BONE_USED_BY_BONE_MERGE,
gpGlobals->curtime );
player->DrawClientHitboxes( cl_debug_duration.GetFloat(), false ); player->DrawClientHitboxes( cl_debug_duration.GetFloat(), false );
// Re-invalidate bone cache for the next frame player->PopBoneAccess( "Lag compensation context" );
player->InvalidateBoneCache();
PopBoneAccess( "Lag compensation context" );
// Set back original stuff. // Set back original stuff.
player->SetSequence( iOldSequence ); player->SetSequence( iOldSequence );
@ -2272,25 +2266,25 @@ void C_CSPlayer::FireGameEvent( IGameEvent* event )
player->SetAbsOrigin( vecBackupPosition ); player->SetAbsOrigin( vecBackupPosition );
player->m_angRenderAngles = angBackupAngles; player->m_angRenderAngles = angBackupAngles;
for ( int i = 0; i < numposeparams; i++ ) for ( int i = 0; i < MAXSTUDIOPOSEPARAM; i++ )
{ {
player->SetPoseParameter( i, flBackupPoseParams[i] ); player->m_flPoseParameter[i] = flBackupPoseParams[i];
} }
for ( int i = 0; i < numbonecontrollers; i++ ) for ( int i = 0; i < MAXSTUDIOBONECTRLS; i++ )
{ {
player->SetBoneController( i, flBackupBoneControllers[i] ); player->m_flEncodedController[i] = flBackupBoneControllers[i];
} }
for ( int i = 0; i < numanimoverlays; i++ ) for ( int i = 0; i < numanimoverlays; i++ )
{ {
auto animOverlay = player->GetAnimOverlay( i ); auto animOverlay = player->GetAnimOverlay( i );
*animOverlay = backupAnimLayers[i];
animOverlay->m_flCycle = backupAnimLayers[i].m_flCycle;
animOverlay->m_nSequence = backupAnimLayers[i].m_nSequence;
animOverlay->m_flWeight = backupAnimLayers[i].m_flWeight;
animOverlay->m_nOrder = backupAnimLayers[i].m_nOrder;
} }
player->PushAllowBoneAccess( true, false, "Lag compensation context" );
player->InvalidateBoneCache();
player->PopBoneAccess( "Lag compensation context" );
} }
} }
}; };

6
game/client/in_main.cpp
View file

@ -1319,9 +1319,9 @@ void CInput::CreateMove ( int sequence_number, float input_sample_frametime, boo
continue; continue;
} }
cmd->simulationdata[pEntity->index].lerp_time = pEntity->m_flInterpolatedSimulationTime; cmd->simulationdata[pEntity->index].sim_time = pEntity->m_flInterpolatedSimulationTime;
cmd->simulationdata[pEntity->index].animated_sim_time = pEntity->m_flAnimTime; cmd->simulationdata[pEntity->index].anim_time = pEntity->m_flAnimTime;
cmd->simulationdata[pEntity->index].entityexists = true; cmd->simulationdata[pEntity->index].entityexists = true;
} }
#ifdef CSTRIKE_DLL #ifdef CSTRIKE_DLL

19
game/server/baseanimating.cpp
View file

@ -1615,6 +1615,10 @@ public:
} }
}; };
//-----------------------------------------------------------------------------
// Purpose: update latched IK contacts if they're in a moving reference frame.
//-----------------------------------------------------------------------------
void CBaseAnimating::UpdateIKLocks( float currentTime ) void CBaseAnimating::UpdateIKLocks( float currentTime )
{ {
if (!m_pIk) if (!m_pIk)
@ -1643,9 +1647,7 @@ void CBaseAnimating::UpdateIKLocks( float currentTime )
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Find IK collisions with world // Purpose: Find the ground or external attachment points needed by IK rules
// Input :
// Output : fills out m_pIk targets, calcs floor offset for rendering
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void CBaseAnimating::CalculateIKLocks( float currentTime ) void CBaseAnimating::CalculateIKLocks( float currentTime )
@ -1668,7 +1670,7 @@ void CBaseAnimating::CalculateIKLocks( float currentTime )
// FIXME: trace based on gravity or trace based on angles? // FIXME: trace based on gravity or trace based on angles?
Vector up; Vector up;
AngleVectors( GetAbsAngles(), NULL, NULL, &up ); AngleVectors( GetRenderAngles(), NULL, NULL, &up );
// FIXME: check number of slots? // FIXME: check number of slots?
float minHeight = FLT_MAX; float minHeight = FLT_MAX;
@ -1690,7 +1692,7 @@ void CBaseAnimating::CalculateIKLocks( float currentTime )
Vector p1, p2; Vector p1, p2;
// adjust ground to original ground position // adjust ground to original ground position
estGround = (pTarget->est.pos - GetAbsOrigin()); estGround = (pTarget->est.pos - GetRenderOrigin());
estGround = estGround - (estGround * up) * up; estGround = estGround - (estGround * up) * up;
estGround = GetAbsOrigin() + estGround + pTarget->est.floor * up; estGround = GetAbsOrigin() + estGround + pTarget->est.floor * up;
@ -1779,7 +1781,7 @@ void CBaseAnimating::CalculateIKLocks( float currentTime )
else if (trace.DidHitNonWorldEntity()) else if (trace.DidHitNonWorldEntity())
{ {
pTarget->SetPos( trace.endpos ); pTarget->SetPos( trace.endpos );
pTarget->SetAngles( GetAbsAngles() ); pTarget->SetAngles( GetRenderAngles() );
// only do this on forward tracking or commited IK ground rules // only do this on forward tracking or commited IK ground rules
if (pTarget->est.release < 0.1) if (pTarget->est.release < 0.1)
@ -1813,7 +1815,7 @@ void CBaseAnimating::CalculateIKLocks( float currentTime )
else else
{ {
pTarget->SetPos( trace.endpos ); pTarget->SetPos( trace.endpos );
pTarget->SetAngles( GetAbsAngles() ); pTarget->SetAngles( GetRenderAngles() );
pTarget->SetOnWorld( true ); pTarget->SetOnWorld( true );
} }
} }
@ -1872,7 +1874,7 @@ void CBaseAnimating::CalculateIKLocks( float currentTime )
} }
} }
#if defined( HL2_DLL ) #if defined( HL2_CLIENT_DLL )
if (minHeight < FLT_MAX) if (minHeight < FLT_MAX)
{ {
input->AddIKGroundContactInfo( entindex(), minHeight, maxHeight ); input->AddIKGroundContactInfo( entindex(), minHeight, maxHeight );
@ -2854,6 +2856,7 @@ CBoneCache *CBaseAnimating::GetBoneCache( void )
void CBaseAnimating::InvalidateBoneCache( void ) void CBaseAnimating::InvalidateBoneCache( void )
{ {
Studio_InvalidateBoneCache( m_boneCacheHandle ); Studio_InvalidateBoneCache( m_boneCacheHandle );
m_boneCacheHandle = 0;
} }
bool CBaseAnimating::TestCollision( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr ) bool CBaseAnimating::TestCollision( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr )

31
game/server/player_lagcompensation.cpp
View file

@ -39,7 +39,8 @@
#define MAX_TICKS_SAVED 1000 #define MAX_TICKS_SAVED 1000
ConVar sv_unlag( "sv_unlag", "1", FCVAR_DEVELOPMENTONLY, "Enables player lag compensation" ); ConVar sv_unlag( "sv_unlag", "1", FCVAR_DEVELOPMENTONLY, "Enables player lag compensation" );
ConVar sv_lagflushbonecache( "sv_lagflushbonecache", "0", 0, "Flushes entity bone cache on lag compensation" ); // Enable by default to avoid some bugs.
ConVar sv_lagflushbonecache( "sv_lagflushbonecache", "1", 0, "Flushes entity bone cache on lag compensation" );
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: // Purpose:
@ -420,8 +421,8 @@ void CLagCompensationManager::BacktrackPlayer( CBasePlayer* pPlayer, CUserCmd* c
int pl_index = pPlayer->entindex(); int pl_index = pPlayer->entindex();
float flTargetLerpSimTime = cmd->simulationdata[pl_index].lerp_time; float flTargetSimTime = cmd->simulationdata[pl_index].sim_time;
float flTargetAnimatedSimulationTime = cmd->simulationdata[pl_index].animated_sim_time; float flTargetAnimTime = cmd->simulationdata[pl_index].anim_time;
// get track history of this player // get track history of this player
auto track = &m_EntityTrack[pl_index]; auto track = &m_EntityTrack[pl_index];
@ -440,12 +441,12 @@ void CLagCompensationManager::BacktrackPlayer( CBasePlayer* pPlayer, CUserCmd* c
break; break;
} }
if ( flTargetLerpSimTime == recordSim->m_flSimulationTime ) if ( flTargetSimTime == recordSim->m_flSimulationTime )
{ {
break; break;
} }
if ( recordSim->m_flSimulationTime < flTargetLerpSimTime ) if ( recordSim->m_flSimulationTime < flTargetSimTime )
{ {
prevRecordSim = track->Get( i - 1 ); prevRecordSim = track->Get( i - 1 );
break; break;
@ -461,7 +462,7 @@ void CLagCompensationManager::BacktrackPlayer( CBasePlayer* pPlayer, CUserCmd* c
break; break;
} }
if ( recordAnim->m_flAnimTime == flTargetAnimatedSimulationTime ) if ( recordAnim->m_flAnimTime == flTargetAnimTime )
{ {
break; break;
} }
@ -481,7 +482,7 @@ void CLagCompensationManager::BacktrackPlayer( CBasePlayer* pPlayer, CUserCmd* c
} }
float fracSim = 0.0f; float fracSim = 0.0f;
if ( prevRecordSim && ( recordSim->m_flSimulationTime < flTargetLerpSimTime ) if ( prevRecordSim && ( recordSim->m_flSimulationTime < flTargetSimTime )
&& ( recordSim->m_flSimulationTime < prevRecordSim->m_flSimulationTime ) ) && ( recordSim->m_flSimulationTime < prevRecordSim->m_flSimulationTime ) )
{ {
// we didn't find the exact time but have a valid previous record // we didn't find the exact time but have a valid previous record
@ -491,7 +492,7 @@ void CLagCompensationManager::BacktrackPlayer( CBasePlayer* pPlayer, CUserCmd* c
Assert( flTargetLerpSimTime < prevRecordSim->m_flSimulationTime ); Assert( flTargetLerpSimTime < prevRecordSim->m_flSimulationTime );
// calc fraction between both records // calc fraction between both records
fracSim = float( ( double( flTargetLerpSimTime ) - double( recordSim->m_flSimulationTime ) ) fracSim = float( ( double( flTargetSimTime ) - double( recordSim->m_flSimulationTime ) )
/ ( double( prevRecordSim->m_flSimulationTime ) - double( recordSim->m_flSimulationTime ) ) ); / ( double( prevRecordSim->m_flSimulationTime ) - double( recordSim->m_flSimulationTime ) ) );
Assert( fracSim > 0 && fracSim < 1 ); // should never extrapolate Assert( fracSim > 0 && fracSim < 1 ); // should never extrapolate
@ -500,12 +501,6 @@ void CLagCompensationManager::BacktrackPlayer( CBasePlayer* pPlayer, CUserCmd* c
org = Lerp( fracSim, recordSim->m_vecOrigin, prevRecordSim->m_vecOrigin ); org = Lerp( fracSim, recordSim->m_vecOrigin, prevRecordSim->m_vecOrigin );
minsPreScaled = Lerp( fracSim, recordSim->m_vecMinsPreScaled, prevRecordSim->m_vecMinsPreScaled ); minsPreScaled = Lerp( fracSim, recordSim->m_vecMinsPreScaled, prevRecordSim->m_vecMinsPreScaled );
maxsPreScaled = Lerp( fracSim, recordSim->m_vecMaxsPreScaled, prevRecordSim->m_vecMaxsPreScaled ); maxsPreScaled = Lerp( fracSim, recordSim->m_vecMaxsPreScaled, prevRecordSim->m_vecMaxsPreScaled );
#ifdef CSTRIKE_DLL
if ( csPlayer )
{
renderAngles = Lerp( fracSim, recordSim->m_angRenderAngles, prevRecordSim->m_angRenderAngles );
}
#endif
} }
else else
{ {
@ -515,9 +510,6 @@ void CLagCompensationManager::BacktrackPlayer( CBasePlayer* pPlayer, CUserCmd* c
ang = recordSim->m_vecAngles; ang = recordSim->m_vecAngles;
minsPreScaled = recordSim->m_vecMinsPreScaled; minsPreScaled = recordSim->m_vecMinsPreScaled;
maxsPreScaled = recordSim->m_vecMaxsPreScaled; maxsPreScaled = recordSim->m_vecMaxsPreScaled;
#ifdef CSTRIKE_DLL
renderAngles = recordSim->m_angRenderAngles;
#endif
} }
// See if this represents a change for the player // See if this represents a change for the player
@ -535,6 +527,7 @@ void CLagCompensationManager::BacktrackPlayer( CBasePlayer* pPlayer, CUserCmd* c
#ifdef CSTRIKE_DLL #ifdef CSTRIKE_DLL
if ( csPlayer ) if ( csPlayer )
{ {
renderAngles = recordAnim->m_angRenderAngles;
restore->m_angRenderAngles = csPlayer->m_angRenderAngles; restore->m_angRenderAngles = csPlayer->m_angRenderAngles;
csPlayer->m_angRenderAngles = renderAngles; csPlayer->m_angRenderAngles = renderAngles;
} }
@ -638,8 +631,8 @@ void CLagCompensationManager::BacktrackPlayer( CBasePlayer* pPlayer, CUserCmd* c
} }
// Set lag compensated player's times // Set lag compensated player's times
pPlayer->SetSimulationTime( flTargetLerpSimTime ); pPlayer->SetSimulationTime( flTargetSimTime );
// pPlayer->SetAnimTime(animationData->m_flAnimTime); pPlayer->SetAnimTime( flTargetAnimTime );
if ( sv_lagflushbonecache.GetBool() ) if ( sv_lagflushbonecache.GetBool() )
{ {

3
game/shared/cstrike/cs_player_shared.cpp
View file

@ -618,6 +618,9 @@ void CCSPlayer::FireBullet(
V_sprintf_safe( buffer, "anim_overlay_order_%i", i ); V_sprintf_safe( buffer, "anim_overlay_order_%i", i );
event->SetInt( buffer, animOverlay->m_nOrder.Get() ); event->SetInt( buffer, animOverlay->m_nOrder.Get() );
V_sprintf_safe( buffer, "anim_overlay_flags_%i", i );
event->SetInt( buffer, animOverlay->m_fFlags.Get() );
} }
gameeventmanager->FireEvent( event ); gameeventmanager->FireEvent( event );

58
game/shared/cstrike/cs_playeranimstate.cpp
View file

@ -613,40 +613,48 @@ int CCSPlayerAnimState::CalcReloadLayerSequence( PlayerAnimEvent_t event )
return -1; return -1;
} }
void CCSPlayerAnimState::UpdateLayerSequenceGeneric( CStudioHdr *pStudioHdr, int iLayer, bool &bEnabled, float &flCurCycle, int &iSequence, bool bWaitAtEnd ) void CCSPlayerAnimState::UpdateLayerSequenceGeneric( CStudioHdr* pStudioHdr,
int iLayer,
bool& bEnabled,
float& flCurCycle,
int& iSequence,
bool bWaitAtEnd )
{ {
if ( !bEnabled || iSequence < 0 ) if ( !bEnabled || iSequence < 0 )
{
return; return;
}
// Increment the fire sequence's cycle. // Increment the fire sequence's cycle.
flCurCycle += m_pOuter->GetSequenceCycleRate( pStudioHdr, iSequence ) * gpGlobals->frametime; flCurCycle += m_pOuter->GetSequenceCycleRate( pStudioHdr, iSequence ) * gpGlobals->frametime;
if ( flCurCycle > 1 )
if ( flCurCycle > 1 )
{
if ( bWaitAtEnd )
{ {
if ( bWaitAtEnd ) flCurCycle = 1;
{
flCurCycle = 1;
}
else
{
// Not firing anymore.
bEnabled = false;
iSequence = 0;
return;
}
} }
else
{
// Not firing anymore.
bEnabled = false;
iSequence = 0;
CAnimationLayer* pLayer = m_pOuter->GetAnimOverlay( iLayer );
pLayer->m_fFlags = 0;
return;
}
}
// Now dump the state into its animation layer. // Now dump the state into its animation layer.
CAnimationLayer *pLayer = m_pOuter->GetAnimOverlay( iLayer ); CAnimationLayer* pLayer = m_pOuter->GetAnimOverlay( iLayer );
pLayer->m_flCycle = flCurCycle; pLayer->m_flCycle = flCurCycle;
pLayer->m_nSequence = iSequence; pLayer->m_nSequence = iSequence;
pLayer->m_flPlaybackRate = 1.0f;
pLayer->m_flPlaybackRate = 1.0f; pLayer->m_flWeight = 1.0f;
pLayer->m_flWeight = 1.0f; pLayer->m_nOrder = iLayer;
pLayer->m_nOrder = iLayer; pLayer->m_fFlags |= ANIM_LAYER_ACTIVE;
#ifndef CLIENT_DLL
pLayer->m_fFlags |= ANIM_LAYER_ACTIVE;
#endif
} }
bool CCSPlayerAnimState::IsOuterGrenadePrimed() bool CCSPlayerAnimState::IsOuterGrenadePrimed()

12
game/shared/usercmd.cpp
View file

@ -162,20 +162,20 @@ void WriteUsercmd( bf_write *buf, const CUserCmd *to, const CUserCmd *from )
// Write finally simulation data with entity index // Write finally simulation data with entity index
for ( unsigned int i = 0; i <= highestEntityIndex; i++ ) for ( unsigned int i = 0; i <= highestEntityIndex; i++ )
{ {
if ( from->simulationdata[i].lerp_time != to->simulationdata[i].lerp_time ) if ( from->simulationdata[i].sim_time != to->simulationdata[i].sim_time )
{ {
buf->WriteOneBit( 1 ); buf->WriteOneBit( 1 );
buf->WriteBitFloat( to->simulationdata[i].lerp_time ); buf->WriteBitFloat( to->simulationdata[i].sim_time );
} }
else else
{ {
buf->WriteOneBit( 0 ); buf->WriteOneBit( 0 );
} }
if ( from->simulationdata[i].animated_sim_time != to->simulationdata[i].animated_sim_time ) if ( from->simulationdata[i].anim_time != to->simulationdata[i].anim_time )
{ {
buf->WriteOneBit( 1 ); buf->WriteOneBit( 1 );
buf->WriteBitFloat( to->simulationdata[i].animated_sim_time ); buf->WriteBitFloat( to->simulationdata[i].anim_time );
} }
else else
{ {
@ -309,12 +309,12 @@ void ReadUsercmd( bf_read *buf, CUserCmd *move, CUserCmd *from )
{ {
if (buf->ReadOneBit()) if (buf->ReadOneBit())
{ {
move->simulationdata[i].lerp_time = buf->ReadBitFloat(); move->simulationdata[i].sim_time = buf->ReadBitFloat();
} }
if (buf->ReadOneBit()) if (buf->ReadOneBit())
{ {
move->simulationdata[i].animated_sim_time = buf->ReadBitFloat(); move->simulationdata[i].anim_time = buf->ReadBitFloat();
} }
} }

4
game/shared/usercmd.h
View file

@ -41,8 +41,8 @@ struct SimulationData
// TODO_ENHANCED: // TODO_ENHANCED:
// For now we send the last received update for animations. // For now we send the last received update for animations.
// anim time is unreliable on low fps. // anim time is unreliable on low fps.
float lerp_time; float sim_time;
float animated_sim_time; float anim_time;
bool entityexists; bool entityexists;
}; };