d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
195 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 5e1ed3bd26
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5e1ed3bd26'
${ noResults }
source-engine/public/posedebugger.cpp

655 lines
16 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include "tier0/dbg.h"
#include "tier0/platform.h"
#include "mathlib/mathlib.h"
#include "tier0/tslist.h"
#include "tier1/utlmap.h"
#include "tier1/convar.h"
#include "bone_setup.h"
#include "con_nprint.h"
#include "cdll_int.h"
#include "globalvars_base.h"
#include "posedebugger.h"
#include "iclientnetworkable.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern IVEngineClient *engine;
extern CGlobalVarsBase *gpGlobals;
static ConVar ui_posedebug_fade_in_time( "ui_posedebug_fade_in_time", "0.2",
FCVAR_CHEAT | FCVAR_DONTRECORD,
"Time during which a new pose activity layer is shown in green in +posedebug UI" );
static ConVar ui_posedebug_fade_out_time( "ui_posedebug_fade_out_time", "0.8",
FCVAR_CHEAT | FCVAR_DONTRECORD,
"Time to keep a no longer active pose activity layer in red until removing it from +posedebug UI" );
//////////////////////////////////////////////////////////////////////////
//
// CPoseDebuggerStub : IPoseDebugger
// empty interface implementation
//
//////////////////////////////////////////////////////////////////////////
class CPoseDebuggerStub : public IPoseDebugger
{
public:
virtual void StartBlending( IClientNetworkable *pEntity, const CStudioHdr *pStudioHdr ) { }
virtual void AccumulatePose(
const CStudioHdr *pStudioHdr,
CIKContext *pIKContext,
Vector pos[],
Quaternion q[],
int sequence,
float cycle,
const float poseParameter[],
int boneMask,
float flWeight,
float flTime
) { }
};
static CPoseDebuggerStub s_PoseDebuggerStub;
IPoseDebugger *g_pPoseDebugger = &s_PoseDebuggerStub;
//////////////////////////////////////////////////////////////////////////
//
// CPoseDebuggerImpl : IPoseDebugger
// Purpose: Main implementation of the pose debugger
// Declaration
//
//////////////////////////////////////////////////////////////////////////
class ModelPoseDebugInfo
{
public:
ModelPoseDebugInfo() : m_iEntNum( 0 ), m_iCurrentText( 0 ) { }
public:
// Entity number
int m_iEntNum;
// Currently processed text
int m_iCurrentText;
// Info Text Flags
enum InfoTextFlags
{
F_SEEN_THIS_FRAME = 1 << 0,
F_SEEN_LAST_FRAME = 1 << 1,
};
struct InfoText
{
InfoText() { memset( this, 0, sizeof( *this ) ); }
// Flags
uint32 m_uiFlags;
// Time seen
float m_flTimeToLive, m_flTimeAlive;
// Activity/label
int m_iActivity;
char m_chActivity[100];
char m_chLabel[100];
// Text
char m_chTextLines[4][256];
enum
{
MAX_TEXT_LINES = 4
};
};
CCopyableUtlVector< InfoText > m_arrTxt;
public:
// Add an info text
void AddInfoText( InfoText *x, ModelPoseDebugInfo *pOld );
// Lookup an info text
InfoText *LookupInfoText( InfoText *x );
// Print pending info text
void PrintPendingInfoText( int &rnPosPrint );
};
void ModelPoseDebugInfo::AddInfoText( InfoText *x, ModelPoseDebugInfo *pOld )
{
if ( x )
{
// Try to set the proper flags on the info text
x->m_uiFlags &= ~F_SEEN_LAST_FRAME;
x->m_uiFlags |= F_SEEN_THIS_FRAME;
}
// If we have smth to compare against
if ( pOld )
{
// Search for the same activity/label in the other model pose debug info
ModelPoseDebugInfo &o = *pOld;
int k = o.m_iCurrentText;
if ( x )
{
for ( ; k < o.m_arrTxt.Count(); ++ k )
{
InfoText &txt = o.m_arrTxt[k];
if ( ( txt.m_uiFlags & F_SEEN_THIS_FRAME ) &&
!stricmp( x->m_chActivity, txt.m_chActivity ) &&
!stricmp( x->m_chLabel, txt.m_chLabel ) &&
( x->m_iActivity == txt.m_iActivity ) )
{
x->m_flTimeAlive = txt.m_flTimeAlive;
break;
}
}
}
else
{
k = o.m_arrTxt.Count();
}
// Range of finished activities
int iFinishedRange[2] = { o.m_iCurrentText, k };
// Check whether this is a new message
if ( k == o.m_arrTxt.Count() )
{
if ( !x )
{
o.m_iCurrentText = k;
}
else
{
// Don't update the current when insertion happens and don't have finished commands
iFinishedRange[1] = iFinishedRange[0];
}
}
else
{
o.m_iCurrentText = k + 1;
if ( x )
{
x->m_uiFlags |= F_SEEN_LAST_FRAME;
x->m_flTimeAlive += gpGlobals->frametime;
}
}
// Everything before finished
for ( int iFinished = iFinishedRange[0]; iFinished < iFinishedRange[1]; ++ iFinished )
{
InfoText &txtFinished = o.m_arrTxt[ iFinished ];
if ( txtFinished.m_uiFlags & F_SEEN_THIS_FRAME )
txtFinished.m_uiFlags |= F_SEEN_LAST_FRAME;
txtFinished.m_uiFlags &= ~F_SEEN_THIS_FRAME;
txtFinished.m_flTimeToLive -= gpGlobals->frametime;
txtFinished.m_flTimeAlive += gpGlobals->frametime;
if ( txtFinished.m_flTimeToLive >= 0.0f )
m_arrTxt.AddToTail( txtFinished );
}
}
if ( x )
{
// Now add it to the array
x->m_flTimeToLive = ui_posedebug_fade_out_time.GetFloat();
m_arrTxt.AddToTail( *x );
}
}
ModelPoseDebugInfo::InfoText * ModelPoseDebugInfo::LookupInfoText( InfoText *x )
{
int k = m_iCurrentText;
if ( x )
{
for ( ; k < m_arrTxt.Count(); ++ k )
{
InfoText &txt = m_arrTxt[k];
if ( ( txt.m_uiFlags & F_SEEN_THIS_FRAME ) &&
!stricmp( x->m_chActivity, txt.m_chActivity ) &&
!stricmp( x->m_chLabel, txt.m_chLabel ) &&
( x->m_iActivity == txt.m_iActivity ) )
{
return &txt;
}
}
}
return NULL;
}
void ModelPoseDebugInfo::PrintPendingInfoText( int &rnPosPrint )
{
con_nprint_s nxPrn = { 0 };
nxPrn.time_to_live = -1;
nxPrn.color[0] = 1.0f, nxPrn.color[1] = 1.0f, nxPrn.color[2] = 1.0f;
nxPrn.fixed_width_font = true;
float const flFadeInTime = ui_posedebug_fade_in_time.GetFloat();
float const flFadeOutTime = ui_posedebug_fade_out_time.GetFloat();
// Now print all the accumulated spew
for ( int k = m_iCurrentText; k < m_arrTxt.Count(); ++ k )
{
InfoText &prntxt = m_arrTxt[k];
switch( prntxt.m_uiFlags & ( F_SEEN_LAST_FRAME | F_SEEN_THIS_FRAME ) )
{
case ( F_SEEN_LAST_FRAME | F_SEEN_THIS_FRAME ) :
nxPrn.color[0] = 1.f;
nxPrn.color[1] = 1.f;
nxPrn.color[2] = 1.f;
if ( prntxt.m_flTimeAlive > flFadeInTime )
break;
else
NULL; // Fall-through to keep showing in green
case F_SEEN_THIS_FRAME :
if ( flFadeInTime > 0.f )
{
nxPrn.color[0] = 1.f * prntxt.m_flTimeAlive / flFadeInTime;
nxPrn.color[1] = 1.f;
nxPrn.color[2] = 1.f * prntxt.m_flTimeAlive / flFadeInTime;
}
else
{
nxPrn.color[0] = ( prntxt.m_flTimeAlive > 0.0f ) ? 1.f : 0.f;
nxPrn.color[1] = 1.f;
nxPrn.color[2] = ( prntxt.m_flTimeAlive > 0.0f ) ? 1.f : 0.f;
}
break;
case F_SEEN_LAST_FRAME :
case 0:
if ( flFadeOutTime > 0.f )
nxPrn.color[0] = 1.f * prntxt.m_flTimeToLive / flFadeOutTime;
else
nxPrn.color[0] = ( prntxt.m_flTimeToLive > 0.0f ) ? 1.f : 0.f;
nxPrn.color[1] = 0.f;
nxPrn.color[2] = 0.f;
break;
}
nxPrn.index = ( rnPosPrint += 1 );
engine->Con_NXPrintf( &nxPrn, "%s", prntxt.m_chTextLines[0] );
for ( int iLine = 1; iLine < ModelPoseDebugInfo::InfoText::MAX_TEXT_LINES; ++ iLine)
{
if ( !prntxt.m_chTextLines[iLine][0] )
break;
nxPrn.index = ( rnPosPrint += 1 );
engine->Con_NXPrintf( &nxPrn, "%s", prntxt.m_chTextLines[iLine] );
}
}
m_iCurrentText = m_arrTxt.Count();
}
class CPoseDebuggerImpl : public IPoseDebugger
{
public:
CPoseDebuggerImpl();
~CPoseDebuggerImpl();
public:
void ShowAllModels( bool bShow );
void ShowModel( int iEntNum, bool bShow );
bool IsModelShown( int iEntNum ) const;
public:
virtual void StartBlending( IClientNetworkable *pEntity, const CStudioHdr *pStudioHdr );
virtual void AccumulatePose(
const CStudioHdr *pStudioHdr,
CIKContext *pIKContext,
Vector pos[],
Quaternion q[],
int sequence,
float cycle,
const float poseParameter[],
int boneMask,
float flWeight,
float flTime
);
protected:
typedef CUtlMap< CStudioHdr const *, ModelPoseDebugInfo > MapModel;
MapModel m_mapModel, m_mapModelOld;
int m_nPosPrint;
CBitVec< MAX_EDICTS > m_uiMaskShowModels;
CStudioHdr const *m_pLastModel;
};
static CPoseDebuggerImpl s_PoseDebuggerImpl;
//////////////////////////////////////////////////////////////////////////
//
// CPoseDebuggerImpl
// Implementation
//
//////////////////////////////////////////////////////////////////////////
CPoseDebuggerImpl::CPoseDebuggerImpl() :
m_mapModel( DefLessFunc( CStudioHdr const * ) ),
m_mapModelOld( DefLessFunc( CStudioHdr const * ) ),
m_nPosPrint( 0 ),
m_pLastModel( NULL )
{
m_uiMaskShowModels.SetAll();
}
CPoseDebuggerImpl::~CPoseDebuggerImpl()
{
// g_pPoseDebugger = &s_PoseDebuggerStub;
}
void CPoseDebuggerImpl::ShowAllModels( bool bShow )
{
bShow ? m_uiMaskShowModels.SetAll() : m_uiMaskShowModels.ClearAll();
}
void CPoseDebuggerImpl::ShowModel( int iEntNum, bool bShow )
{
Assert( iEntNum >= 0 && iEntNum < MAX_EDICTS );
if ( iEntNum >= 0 && iEntNum < MAX_EDICTS )
m_uiMaskShowModels.Set( iEntNum, bShow );
}
bool CPoseDebuggerImpl::IsModelShown( int iEntNum ) const
{
Assert( iEntNum >= 0 && iEntNum < MAX_EDICTS );
if ( iEntNum >= 0 && iEntNum < MAX_EDICTS )
return m_uiMaskShowModels.IsBitSet( iEntNum );
else
return false;
}
void CPoseDebuggerImpl::StartBlending( IClientNetworkable *pEntity, const CStudioHdr *pStudioHdr )
{
// virtualmodel_t const *pVMdl = pStudioHdr->GetVirtualModel();
// if ( !pVMdl )
// return;
// If we are starting a new model then finalize the previous one
if ( pStudioHdr != m_pLastModel && m_pLastModel )
{
MapModel::IndexType_t idx = m_mapModel.Find( m_pLastModel );
if ( idx != m_mapModel.InvalidIndex() )
{
ModelPoseDebugInfo &mpi = m_mapModel.Element( idx );
ModelPoseDebugInfo *pMpiOld = NULL;
MapModel::IndexType_t idxMapModelOld = m_mapModelOld.Find( m_pLastModel );
if ( idxMapModelOld != m_mapModelOld.InvalidIndex() )
{
pMpiOld = &m_mapModelOld.Element( idxMapModelOld );
}
mpi.AddInfoText( NULL, pMpiOld );
mpi.PrintPendingInfoText( m_nPosPrint );
}
}
m_pLastModel = pStudioHdr;
// Go ahead with the new model
studiohdr_t const *pRMdl = pStudioHdr->GetRenderHdr();
if ( !pRMdl ||
!pRMdl->numincludemodels )
return;
// Entity number
int iEntNum = pEntity->entindex();
if ( !IsModelShown( iEntNum ) )
return;
// Check if we saw the model
if ( m_mapModel.Find( pStudioHdr ) != m_mapModel.InvalidIndex() )
{
// Initialize the printing position
m_nPosPrint = 9;
// Swap the maps
m_mapModelOld.RemoveAll();
m_mapModelOld.Swap( m_mapModel );
// Zero out the text on the old map
for ( int k = m_mapModelOld.FirstInorder();
k != m_mapModelOld.InvalidIndex();
k = m_mapModelOld.NextInorder( k ) )
{
ModelPoseDebugInfo &mpi = m_mapModelOld[k];
mpi.m_iCurrentText = 0;
}
}
else
{
// Next model
m_nPosPrint += 3;
}
ModelPoseDebugInfo mpi;
mpi.m_iEntNum = iEntNum;
m_mapModel.Insert( pStudioHdr, mpi );
con_nprint_s nxPrn = { 0 };
nxPrn.index = m_nPosPrint;
nxPrn.time_to_live = -1;
nxPrn.color[0] = 0.9f, nxPrn.color[1] = 1.0f, nxPrn.color[2] = 0.9f;
nxPrn.fixed_width_font = false;
engine->Con_NXPrintf( &nxPrn, "[ %2d ] Model: %s", iEntNum, pRMdl->pszName() );
m_nPosPrint += 3;
}
void CPoseDebuggerImpl::AccumulatePose( const CStudioHdr *pStudioHdr, CIKContext *pIKContext,
Vector pos[], Quaternion q[], int sequence, float cycle,
const float poseParameter[], int boneMask,
float flWeight, float flTime )
{
// virtualmodel_t const *pVMdl = pStudioHdr->GetVirtualModel();
// if ( !pVMdl )
// return;
studiohdr_t const *pRMdl = pStudioHdr->GetRenderHdr();
if ( !pRMdl ||
!pRMdl->numincludemodels )
return;
MapModel::IndexType_t idxMapModel = m_mapModel.Find( pStudioHdr );
if ( idxMapModel == m_mapModel.InvalidIndex() )
return;
ModelPoseDebugInfo &mpi = m_mapModel.Element( idxMapModel );
if ( !IsModelShown( mpi.m_iEntNum ) )
return;
ModelPoseDebugInfo *pMpiOld = NULL;
MapModel::IndexType_t idxMapModelOld = m_mapModelOld.Find( pStudioHdr );
if ( idxMapModelOld != m_mapModelOld.InvalidIndex() )
{
pMpiOld = &m_mapModelOld.Element( idxMapModelOld );
}
//
// Actual processing
//
mstudioseqdesc_t &seqdesc = ((CStudioHdr *)pStudioHdr)->pSeqdesc( sequence );
if ( sequence >= pStudioHdr->GetNumSeq() )
{
sequence = 0;
seqdesc = ((CStudioHdr *)pStudioHdr)->pSeqdesc( sequence );
}
enum
{
widthActivity = 35,
widthLayer = 35,
widthIks = 60,
widthPercent = 6,
};
// Prepare the text
char chBuffer[256];
ModelPoseDebugInfo::InfoText txt;
int numLines = 0;
txt.m_iActivity = seqdesc.activity;
sprintf( txt.m_chActivity, "%s", seqdesc.pszActivityName() );
sprintf( txt.m_chLabel, "%s", seqdesc.pszLabel() );
if ( !txt.m_chActivity[0] )
{
// Try to find the last seen activity and re-use it
for ( int iLast = mpi.m_arrTxt.Count(); iLast --> 0; )
{
ModelPoseDebugInfo::InfoText &lastSeenTxt = mpi.m_arrTxt[iLast];
if ( lastSeenTxt.m_uiFlags & ModelPoseDebugInfo::F_SEEN_THIS_FRAME &&
lastSeenTxt.m_chActivity[0] )
{
sprintf( txt.m_chActivity, "%s", lastSeenTxt.m_chActivity );
break;
}
}
}
// The layer information
ModelPoseDebugInfo::InfoText *pOldTxt = pMpiOld ? pMpiOld->LookupInfoText( &txt ) : NULL;
sprintf( txt.m_chTextLines[numLines],
"%-*s %-*s %*.2f %*.1f/%-*d %*.0f%% ",
widthActivity,
seqdesc.pszActivityName(),
widthLayer,
seqdesc.pszLabel(),
7,
pOldTxt ? pOldTxt->m_flTimeAlive : 0.f,
5,
cycle * ( ((CStudioHdr *)pStudioHdr)->pAnimdesc( seqdesc.anim( 0, 0 ) ).numframes - 1 ),
3,
((CStudioHdr *)pStudioHdr)->pAnimdesc( seqdesc.anim( 0, 0 ) ).numframes,
widthPercent,
flWeight * 100.0f
);
++ numLines;
if ( seqdesc.numiklocks )
{
sprintf( chBuffer,
"iklocks : %-2d : ",
seqdesc.numiklocks );
for ( int k = 0; k < seqdesc.numiklocks; ++ k )
{
mstudioiklock_t *plock = seqdesc.pIKLock( k );
mstudioikchain_t *pchain = pStudioHdr->pIKChain( plock->chain );
sprintf( chBuffer + strlen( chBuffer ), "%s ", pchain->pszName() );
// plock->flPosWeight;
// plock->flLocalQWeight;
}
sprintf( txt.m_chTextLines[numLines],
"%-*s",
widthIks,
chBuffer
);
++ numLines;
}
if ( seqdesc.numikrules )
{
sprintf( chBuffer, "ikrules : %-2d",
seqdesc.numikrules );
sprintf( txt.m_chTextLines[numLines],
"%-*s",
widthIks,
chBuffer
);
++ numLines;
}
// Now add the accumulated text into the container
mpi.AddInfoText( &txt, pMpiOld );
mpi.PrintPendingInfoText( m_nPosPrint );
}
//////////////////////////////////////////////////////////////////////////
//
// Con-commands
//
//////////////////////////////////////////////////////////////////////////
static void IN_PoseDebuggerStart( const CCommand &args )
{
if ( args.ArgC() <= 1 )
{
// No args, enable all
s_PoseDebuggerImpl.ShowAllModels( true );
}
else
{
// If explicitly showing the pose debugger when it was disabled
if ( g_pPoseDebugger != &s_PoseDebuggerImpl )
{
s_PoseDebuggerImpl.ShowAllModels( false );
}
// Show only specific models
for ( int k = 1; k < args.ArgC(); ++ k )
{
int iEntNum = atoi( args.Arg( k ) );
s_PoseDebuggerImpl.ShowModel( iEntNum, true );
}
}
g_pPoseDebugger = &s_PoseDebuggerImpl;
}
static void IN_PoseDebuggerEnd( const CCommand &args )
{
if ( args.ArgC() <= 1 )
{
// No args, disable all
s_PoseDebuggerImpl.ShowAllModels( false );
// Set the stub pointer
g_pPoseDebugger = &s_PoseDebuggerStub;
}
else
{
// Hide only specific models
for ( int k = 1; k < args.ArgC(); ++ k )
{
int iEntNum = atoi( args.Arg( k ) );
s_PoseDebuggerImpl.ShowModel( iEntNum, false );
}
}
}
static ConCommand posedebuggerstart( "+posedebug", IN_PoseDebuggerStart, "Turn on pose debugger or add ents to pose debugger UI", FCVAR_CHEAT );
static ConCommand posedebuggerend ( "-posedebug", IN_PoseDebuggerEnd, "Turn off pose debugger or hide ents from pose debugger UI", FCVAR_CHEAT );