H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 14:16:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
source-engine/engine/vgui_vprofpanel.cpp

1156 lines
29 KiB
C++
Raw Permalink Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: VGUI scoreboard
//
// $Workfile: $
// $Date: $
// $NoKeywords: $
//===========================================================================//
#include "client_pch.h"
#include "vgui_vprofpanel.h"
#include <KeyValues.h>
#include "vgui_budgetpanel.h"
#include "vprof_engine.h"
#include "vprof_record.h"
#include "ivideomode.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
using namespace vgui;
// positions
#define VPROF_INDENT_X XRES(20)
#define VPROF_INDENT_Y YRES(10)
// Scoreboard dimensions
#define VPROF_TITLE_SIZE_Y YRES(22)
#define X_BORDER XRES(4)
#define Y_BORDER YRES(4)
static ConVar vprof_verbose( "vprof_verbose", "1", FCVAR_ARCHIVE, "Set to one to show average and peak times" );
static ConVar vprof_unaccounted_limit( "vprof_unaccounted_limit", "0.3", FCVAR_ARCHIVE,
"number of milliseconds that a node must exceed to turn red in the vprof panel" );
static ConVar vprof_warningmsec( "vprof_warningmsec", "10", FCVAR_ARCHIVE, "Above this many milliseconds render the label red to indicate slow code." );
#ifdef VPROF_ENABLED
//-----------------------------------------------------------------------------
// Singleton accessor
//-----------------------------------------------------------------------------
static CVProfPanel *g_pVProfPanel = NULL;
CVProfPanel *GetVProfPanel( void )
{
return g_pVProfPanel;
}
static void ClearNodeClientData( CVProfNode *pNode )
{
pNode->SetClientData( -1 );
if( pNode->GetSibling() )
{
ClearNodeClientData( pNode->GetSibling() );
}
if( pNode->GetChild() )
{
ClearNodeClientData( pNode->GetChild() );
}
}
void CVProfPanel::Reset()
{
m_pHierarchy->RemoveAll();
m_RootItem = -1;
ClearNodeClientData( m_pVProfile->GetRoot() );
}
CON_COMMAND( vprof_expand_all, "Expand the whole vprof tree" )
{
Msg("VProf expand all.\n");
GetVProfPanel()->ExpandAll();
}
CON_COMMAND( vprof_collapse_all, "Collapse the whole vprof tree" )
{
Msg("VProf collapse all.\n");
GetVProfPanel()->CollapseAll();
}
CON_COMMAND( vprof_expand_group, "Expand a budget group in the vprof tree by name" )
{
Msg("VProf expand group.\n");
if ( args.ArgC() >= 2 )
{
GetVProfPanel()->ExpandGroup( args[ 1 ] );
}
}
void IN_VProfDown(void)
{
GetVProfPanel()->UserCmd_ShowVProf();
}
void IN_VProfUp(void)
{
GetVProfPanel()->UserCmd_HideVProf();
}
static ConCommand startshowvprof("+showvprof", IN_VProfDown);
static ConCommand endshowvprof("-showvprof", IN_VProfUp);
void ChangeVProfScopeCallback( IConVar *pConVar, const char *pOldString, float flOldValue )
{
ConVarRef var( pConVar );
Msg( "VProf setting scope to %s\n", var.GetString( ) );
if ( g_pVProfPanel )
{
g_pVProfPanel->Reset();
}
}
ConVar vprof_scope(
"vprof_scope",
"",
0,
"Set a specific scope to start showing vprof tree",
0, 0, 0, 0,
ChangeVProfScopeCallback );
#define PROF_FONT "DefaultFixed"
class CProfileTree : public TreeView
{
DECLARE_CLASS_SIMPLE( CProfileTree, TreeView );
public:
CProfileTree( CVProfPanel *parent, const char *panelName );
~CProfileTree();
virtual void OnCommand( const char *cmd );
virtual void InvalidateLayout( bool layoutNow = false, bool reloadScheme = false );
virtual void ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
SetFont( pScheme->GetFont( PROF_FONT ) );
}
virtual void SetBgColor( Color color )
{
BaseClass::SetBgColor( color );
}
private:
Menu *m_pEditMenu;
CVProfPanel *m_pParent;
};
CProfileTree::CProfileTree( CVProfPanel *parent, const char *panelName ) :
BaseClass( (Panel *)parent, panelName ),
m_pEditMenu( 0 ),
m_pParent( parent )
{
}
CProfileTree::~CProfileTree()
{
delete m_pEditMenu;
}
void CProfileTree::InvalidateLayout( bool layoutNow, bool reloadScheme )
{
BaseClass::InvalidateLayout( layoutNow, reloadScheme );
if ( GetParent() )
{
GetParent()->InvalidateLayout( layoutNow, reloadScheme );
}
}
void CProfileTree::OnCommand( const char *cmd )
{
// Relay to parent
GetParent()->OnCommand( cmd );
}
CProfileHierarchyPanel::ColumnPanels_t::ColumnPanels_t() :
treeViewItem( -1 )
{
}
CProfileHierarchyPanel::ColumnPanels_t::ColumnPanels_t( const ColumnPanels_t& src )
{
treeViewItem = src.treeViewItem;
int c = src.m_Columns.Count();
for ( int i = 0; i < c; ++i )
{
PanelEntry_t pe;
pe.dataname = src.m_Columns[ i ].dataname;
pe.label = src.m_Columns[ i ].label;
m_Columns.AddToTail( pe );
}
}
void CProfileHierarchyPanel::ColumnPanels_t::AddColumn( int index, const char *name, vgui::Label *label )
{
m_Columns.EnsureCount( index + 1 );
m_Columns[ index ].label = label;
m_Columns[ index ].dataname = name;
}
void CProfileHierarchyPanel::ColumnPanels_t::Refresh( KeyValues *kv )
{
VPROF( "CProfileHierarchyPanel::ColumnPanels_t" );
int c = m_Columns.Count();
for ( int i = 0; i < c; ++i )
{
vgui::Label *label = m_Columns[ i ].label;
if ( !label )
continue;
const char *name = m_Columns[ i ].dataname.String();
if ( name && name[ 0 ] )
{
const char *value = kv->GetString( name, "" );
if ( value )
{
if ( !value[ 0 ] )
{
label->SetText( "" );
label->SetVisible( false );
}
else
{
label->SetVisible( true );
label->SetText( value );
}
}
else
{
label->SetVisible( false );
}
}
}
}
CProfileHierarchyPanel::CProfileHierarchyPanel(vgui::Panel *parent, const char *panelName)
: BaseClass(parent,panelName),
m_Panels( 0, 0, PanelsLessFunc )
{
}
CProfileHierarchyPanel::~CProfileHierarchyPanel()
{
}
void CProfileHierarchyPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
//SetProportional( true );
BaseClass::ApplySchemeSettings( pScheme );
m_itemFont = pScheme->GetFont( PROF_FONT );
SetTitleBarInfo( m_itemFont, 20 );
SetBgColor( Color(0, 0, 0, 176) );
(( CProfileTree *)GetTree())->SetBgColor( Color( 0, 0, 0, 176 ) );
}
void CProfileHierarchyPanel::SetItemColors( int id, const Color& fg, const Color& bg )
{
VPROF( "CProfileHierarchyPanel::SetItemColors" );
GetTree()->SetItemFgColor( id, fg );
GetTree()->SetItemBgColor( id, bg );
ColumnPanels_t search;
search.treeViewItem = id;
int idx = m_Panels.Find( search );
if ( idx == m_Panels.InvalidIndex() )
{
return;
}
ColumnPanels_t& info = m_Panels[ idx ];
int c = info.m_Columns.Count();
for ( int i = 0; i < c; ++i )
{
Label *label = info.m_Columns[ i ].label;
if ( !label )
continue;
label->SetFgColor( fg );
label->SetBgColor( bg );
}
}
void CProfileHierarchyPanel::SetItemColumnColors( int id, int col, const Color& fg, const Color& bg )
{
VPROF( "CProfileHierarchyPanel::SetItemColumnColors" );
ColumnPanels_t search;
search.treeViewItem = id;
int idx = m_Panels.Find( search );
if ( idx == m_Panels.InvalidIndex() )
{
return;
}
ColumnPanels_t& info = m_Panels[ idx ];
int c = info.m_Columns.Count();
if ( col < 0 || col >= c )
return;
Label *label = info.m_Columns[ col ].label;
if ( !label )
return;
label->SetFgColor( fg );
label->SetBgColor( bg );
}
void CProfileHierarchyPanel::ModifyItem( KeyValues *data, int itemIndex )
{
GetTree()->SetItemFgColor( itemIndex, GetFgColor() );
GetTree()->SetItemBgColor( itemIndex, GetBgColor() );
ColumnPanels_t search;
search.treeViewItem = itemIndex;
int idx = m_Panels.Find( search );
if ( idx == m_Panels.InvalidIndex() )
{
Assert( 0 );
return;
}
ColumnPanels_t& info = m_Panels[ idx ];
info.Refresh( data );
}
int CProfileHierarchyPanel::AddItem( KeyValues *data, int parentItemIndex, ColumnPanels_t& columnPanels )
{
int itemIndex = GetTree()->AddItem( data, parentItemIndex );
columnPanels.treeViewItem = itemIndex;
ColumnPanels_t search;
search.treeViewItem = itemIndex;
int idx = m_Panels.Find( search );
if ( idx == m_Panels.InvalidIndex() )
{
m_Panels.Insert( columnPanels );
int c = columnPanels.m_Columns.Count();
for ( int i = 0; i < c; ++i )
{
if ( columnPanels.m_Columns[ i ].label )
{
columnPanels.m_Columns[ i ].label->SetParent( this );
}
}
}
ModifyItem( data, itemIndex );
return itemIndex;
}
void CProfileHierarchyPanel::PostChildPaint()
{
}
void CProfileHierarchyPanel::PerformLayout()
{
VPROF( "CProfileHierarchyPanel::PerformLayout" );
BaseClass::PerformLayout();
// Assume all invisible at first
HideAll();
int tall = GetTall();
int rowheight = GetTree()->GetRowHeight();
int top, visitems;
bool hbarVisible = false;
GetTree()->GetVBarInfo( top, visitems, hbarVisible );
int offset = -top * rowheight;
int numColumns = GetNumColumns();
// Now position column panels into the correct spot
int rows = GetNumRows();
for ( int row = 0; row < rows; ++row )
{
int tvi = GetTreeItemAtRow( row );
for ( int col = 0; col < numColumns; ++col )
{
int left, right, bottom;
GetGridElementBounds( col, row, left, top, right, bottom );
ColumnPanels_t search;
search.treeViewItem = tvi;
int idx = m_Panels.Find( search );
if ( idx != m_Panels.InvalidIndex() )
{
ColumnPanels_t& info = m_Panels[ idx ];
if ( col >= info.m_Columns.Count() )
continue;
vgui::Label *p = info.m_Columns[ col ].label;
if ( !p )
{
continue;
}
bool vis = ( top + offset - 20 ) >= 0 && ( bottom + offset ) < tall;
p->SetParent( vis ? this : NULL );
p->SetVisible( vis );
p->SetBounds( left, top + offset, right - left, bottom - top );
p->InvalidateLayout();
}
else
{
Assert( 0 );
}
}
}
}
void CProfileHierarchyPanel::HideAll()
{
for ( int i = m_Panels.FirstInorder(); i != m_Panels.InvalidIndex(); i = m_Panels.NextInorder( i ) )
{
ColumnPanels_t& info = m_Panels[ i ];
int c = info.m_Columns.Count();
for ( int j = 0 ; j < c; ++j )
{
Label *panel = info.m_Columns[ j ].label;
if ( !panel )
{
continue;
}
panel->SetVisible( false );
}
}
}
void CProfileHierarchyPanel::RemoveAll()
{
GetTree()->RemoveAll();
for ( int i = m_Panels.FirstInorder(); i != m_Panels.InvalidIndex(); i = m_Panels.NextInorder( i ) )
{
ColumnPanels_t& info = m_Panels[ i ];
int c = info.m_Columns.Count();
for ( int j = 0 ; j < c; ++j )
{
delete info.m_Columns[ j ].label;
}
info.m_Columns.RemoveAll();
}
m_Panels.RemoveAll();
InvalidateLayout();
}
void CProfileHierarchyPanel::ExpandItem(int itemIndex, bool bExpand)
{
GetTree()->ExpandItem( itemIndex, bExpand );
}
bool CProfileHierarchyPanel::IsItemExpanded( int itemIndex )
{
return GetTree()->IsItemExpanded( itemIndex );
}
KeyValues *CProfileHierarchyPanel::GetItemData(int itemIndex)
{
return GetTree()->GetItemData( itemIndex );
}
//-----------------------------------------------------------------------------
// Purpose: Create the VProf panel
//-----------------------------------------------------------------------------
CVProfPanel::CVProfPanel( vgui::Panel *pParent, const char *pElementName )
: vgui::Frame( pParent, pElementName )
{
m_pVProfile = g_pVProfileForDisplay;
Assert( g_pVProfPanel == NULL );
g_pVProfPanel = this;
m_RootItem = -1;
m_fShowVprofHeld = false;
int x = VPROF_INDENT_X;
int y = VPROF_INDENT_Y;
int wide = videomode->GetModeStereoWidth() - x * 2;
int tall = videomode->GetModeStereoHeight() - y * 2;
SetBgColor(Color(0, 0, 0, 175));
// Initialize the top title.
#ifdef VPROF_ENABLED
SetTitle("VProf", false);
#else
SetTitle("** VProf is not enabled **", false);
#endif
SetZPos( 1002 );
CProfileTree *profileTree = new CProfileTree( this, "ProfileTree" );
m_pHierarchy = new CProfileHierarchyPanel( this, "Hierarchy" );
m_pHierarchy->SetTreeView( profileTree );
m_pHierarchy->SetNumColumns( 3 );
int treewide = wide - 780;
m_pHierarchy->SetColumnInfo( 0, "Tree", treewide );
m_pHierarchy->SetColumnInfo( 1, "Group", 120 );
m_pHierarchy->SetColumnInfo( 2, "Data", 180 );
// Treeview of the hierarchical calls
m_pHierarchy->SetBounds(X_BORDER, VPROF_TITLE_SIZE_Y, wide - X_BORDER*2, tall - Y_BORDER*2 - VPROF_TITLE_SIZE_Y);
m_pHierarchy->SetParent(this);
m_pHierarchy->SetPaintBorderEnabled( false );
m_pHierarchy->SetPaintBackgroundEnabled( false );
SETUP_PANEL( m_pHierarchy );
SETUP_PANEL( profileTree );
// Mode selection used to populate the tree view + lists
m_pVProfCategory = new ComboBox(this, "CategoryCombo", 5, false);
m_pVProfCategory->AddItem( "All Categories", NULL );
m_pVProfCategory->AddActionSignalTarget( this );
m_pVProfCategory->ActivateItem( 0 );
m_pVProfSort = new ComboBox( this, "SortCombo", 5, false );
m_pVProfSort->AddItem( "By Time", NULL );
m_pVProfSort->AddItem( "By Name", NULL );
m_pVProfSort->AddItem( "By Budget Group", NULL );
m_pVProfSort->AddActionSignalTarget( this );
m_pVProfSort->ActivateItem( 0 );
m_nLastBudgetGroupCount = 0;
m_nCurrentBudgetGroup = -1;
m_pHierarchicalView = new vgui::CheckButton( this, "HierarchicalViewSelection", "" );
m_pHierarchicalView->AddActionSignalTarget( this );
m_pHierarchicalView->SetSelected( true );
m_bHierarchicalView = true;
m_pRedoSort = new vgui::Button( this, "RedoSorting", "", this, "redosort" );
m_pVerbose = new vgui::CheckButton( this, "VerboseCheckbox", "" );
m_pVerbose->AddActionSignalTarget( this );
m_pVerbose->SetSelected( vprof_verbose.GetBool() );
// Setup the playback controls.
m_pPlaybackLabel = new vgui::Label( this, "PlaybackLabel", "" );
m_pPlaybackLabel->SetBgColor( Color( 0, 0, 0, 200 ) );
m_pPlaybackLabel->SetPaintBackgroundEnabled( true );
m_pStepForward = new vgui::Button( this, "StepForward", "", this, "StepForward" );
m_pStepBack = new vgui::Button( this, "StepBack", "", this, "StepBack" );
m_pGotoButton = new vgui::Button( this, "GotoButton", "", this, "GotoButton" );
m_pPlaybackScroll = new vgui::ScrollBar( this, "PlaybackScroll", false );
m_pPlaybackScroll->SetRange( 0, 1000 );
m_pPlaybackScroll->SetRangeWindow( 30 );
m_pPlaybackScroll->AddActionSignalTarget( this );
m_iLastPlaybackTick = -1;
LoadControlSettings("Resource\\VProfPanel.res");
SetBounds( x, y, wide, tall );
vgui::ivgui()->AddTickSignal( GetVPanel() );
}
CVProfPanel::~CVProfPanel( void )
{
Assert( g_pVProfPanel == this );
g_pVProfPanel = NULL;
}
#define DATA_FMT_STR "%-30.30s %-30.30s %-45.45s %-10.10s"
void CVProfPanel::PerformLayout()
{
BaseClass::PerformLayout();
int w, h;
GetSize( w, h );
int topoffset = 95;
int inset = 10;
m_pHierarchy->SetBounds( inset, topoffset, w - 2 * inset, h - inset - topoffset );
int treewide = w - 900 - 20;
treewide = max( treewide, 240 );
m_pHierarchy->SetColumnInfo( 0, "Tree", treewide );
m_pHierarchy->SetColumnInfo( 1, "Group", 125 );
char header[ 512 ];
Q_snprintf( header, sizeof( header ), DATA_FMT_STR,
"Frame Calls + Time + NoChild",
"Avg Calls + Time + NoChild",
"Sum Calls + Time + NoChild + Peak",
"L2Miss" );
m_pHierarchy->SetColumnInfo( 2, header, 775, CTreeViewListControl::CI_HEADER_LEFTALIGN );
}
//-----------------------------------------------------------------------------
// Scheme settings!
//-----------------------------------------------------------------------------
void CVProfPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
IBorder *border = pScheme->GetBorder( "ToolTipBorder" );
SetBorder(border);
SetBgColor(Color(0, 0, 0, 175));
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *command -
//-----------------------------------------------------------------------------
void CVProfPanel::Close()
{
UserCmd_HideVProf();
BaseClass::Close();
}
//-----------------------------------------------------------------------------
// Is it visible?
//-----------------------------------------------------------------------------
void CVProfPanel::OnTick()
{
BaseClass::OnTick();
// Did the CVProfile we're using switch behind our back?
if ( g_pVProfileForDisplay != m_pVProfile )
{
Reset();
m_pVProfile = g_pVProfileForDisplay;
bool bVisible = false;
#ifndef _XBOX
if ( VProfRecord_IsPlayingBack() )
{
bVisible = true;
m_iLastPlaybackTick = -1;
}
#endif
m_pStepForward->SetVisible( bVisible );
m_pStepBack->SetVisible( bVisible );
m_pPlaybackLabel->SetVisible( bVisible );
m_pPlaybackScroll->SetVisible( bVisible );
m_pGotoButton->SetVisible( bVisible );
}
#ifndef _XBOX
if ( VProfRecord_IsPlayingBack() )
{
// Update the playback tick.
int iCur = VProfPlayback_GetCurrentTick();
if ( iCur != m_iLastPlaybackTick )
{
char str[512];
Q_snprintf( str, sizeof( str ), "VPROF playback (tick %d, %d%%)", iCur, (int)(VProfPlayback_GetCurrentPercent() * 100) );
m_pPlaybackLabel->SetText( str );
}
}
#endif
SetVisible( m_fShowVprofHeld != 0 );
m_pRedoSort->SetVisible( !m_bHierarchicalView );
}
// 0 = By Time
// 1 = By "Text"
// 2 = By "group" then by "text"
static int g_nSortType = -1;
//-----------------------------------------------------------------------------
// Visualization changed
//-----------------------------------------------------------------------------
void CVProfPanel::OnTextChanged( KeyValues *data )
{
Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );
vgui::ComboBox *pBox = dynamic_cast<vgui::ComboBox *>( pPanel );
if( pBox == m_pVProfCategory )
{
// The -1 here is for the 'All Categories' item
m_nCurrentBudgetGroup = pBox->GetActiveItem() - 1;
// NOTE: We have to reset the tree view so that it
// is populated with only the ones we want (need to eliminate everything
// that's not appropriate)
Reset();
return;
}
if ( pBox == m_pVProfSort )
{
g_nSortType = pBox->GetActiveItem();
Reset();
return;
}
}
//-----------------------------------------------------------------------------
// Sort function for hierarchical data
//-----------------------------------------------------------------------------
bool ChildCostSortFunc(KeyValues *pNode1, KeyValues *pNode2)
{
switch ( g_nSortType )
{
default:
case 0:
case -1:
{
float flTime1 = pNode1->GetFloat( "Time", -1.0f );
float flTime2 = pNode2->GetFloat( "Time", -1.0f );
return (flTime1 > flTime2);
}
case 1:
{
const char *t1 = pNode1->GetString( "Text", "" );
const char *t2 = pNode2->GetString( "Text", "" );
if( Q_stricmp( t1, t2 ) <= 0 )
return true;
return false;
}
break;
case 2:
{
const char *g1 = pNode1->GetString( "group", "" );
const char *g2 = pNode2->GetString( "group", "" );
int val = Q_stricmp( g1, g2 );
if( val < 0 )
return true;
if ( val > 0 )
return false;
const char *t1 = pNode1->GetString( "Text", "" );
const char *t2 = pNode2->GetString( "Text", "" );
if( Q_stricmp( t1, t2 ) <= 0 )
return true;
return false;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Changes the visualization method for vprof data
//-----------------------------------------------------------------------------
void CVProfPanel::OnCheckButtonChecked(Panel *panel)
{
if ( panel == m_pHierarchicalView )
{
bool bSelected = m_pHierarchicalView->IsSelected() ? 1 : 0;
if ( bSelected != m_bHierarchicalView )
{
m_bHierarchicalView = bSelected;
m_pHierarchy->GetTree()->SetSortFunc( m_bHierarchicalView ? NULL : ChildCostSortFunc );
m_pRedoSort->SetVisible( !m_bHierarchicalView );
Reset();
}
return;
}
if ( panel == m_pVerbose )
{
vprof_verbose.SetValue( m_pVerbose->IsSelected() ? 1 : 0 );
return;
}
}
//-----------------------------------------------------------------------------
// Methods related to expand/collapse in hierarchy
//-----------------------------------------------------------------------------
void CVProfPanel::ExpandAll( void )
{
int count = m_pHierarchy->GetTree()->GetHighestItemID();
int i;
for( i = 0; i < count; i++ )
{
if( m_pHierarchy->GetTree()->IsItemIDValid( i ) )
{
m_pHierarchy->GetTree()->ExpandItem( i, true );
}
}
}
void CVProfPanel::CollapseAll( void )
{
int count = m_pHierarchy->GetTree()->GetHighestItemID();
int i;
for( i = 1; i < count; i++ )
{
if( m_pHierarchy->GetTree()->IsItemIDValid( i ) )
{
m_pHierarchy->GetTree()->ExpandItem( i, false );
}
}
}
void CVProfPanel::ExpandGroupRecursive( int nBudgetGroupID, CVProfNode *pNode )
{
if( !pNode )
{
return;
}
if( pNode->GetBudgetGroupID() == nBudgetGroupID )
{
CVProfNode *pTempNode = pNode;
while( pTempNode )
{
if( pTempNode->GetParent() )
{
int id = pTempNode->GetParent()->GetClientData();
m_pHierarchy->ExpandItem( id, true );
}
pTempNode = pTempNode->GetParent();
}
}
ExpandGroupRecursive( nBudgetGroupID, pNode->GetChild() );
ExpandGroupRecursive( nBudgetGroupID, pNode->GetSibling() );
}
void CVProfPanel::ExpandGroup( const char *pGroupName )
{
int groupID = m_pVProfile->BudgetGroupNameToBudgetGroupID( pGroupName );
ExpandGroupRecursive( groupID, m_pVProfile->GetRoot() );
}
class CVProfLabel : public Label
{
DECLARE_CLASS_SIMPLE( CVProfLabel, Label );
public:
CVProfLabel( Panel *parent, const char *panelName ) :
BaseClass( parent, panelName, "" )
{
//SetPaintBackgroundEnabled( false );
}
virtual void ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
SetFont( pScheme->GetFont( PROF_FONT ) );
SetBgColor( Color( 0, 0, 0, 255 ) );
}
};
Label *AllocateVprofLabel( const char *panelName )
{
CVProfLabel *l = new CVProfLabel( NULL, panelName );
l->SetContentAlignment( Label::a_west );
return l;
}
void CVProfPanel::AddColumns( CProfileHierarchyPanel::ColumnPanels_t& cp )
{
cp.AddColumn( 1, "group", AllocateVprofLabel( "group" ) );
cp.AddColumn( 2, "data", AllocateVprofLabel( "data" ) );
}
//-----------------------------------------------------------------------------
// Populate the tree
//-----------------------------------------------------------------------------
int CVProfPanel::UpdateVProfTreeEntry( KeyValues *pKeyValues, CVProfNode *pNode, int parent )
{
VPROF( "UpdateVProfTreeEntry" );
CFmtStrN<1024> msg;
double curTimeLessChildren = pNode->GetCurTimeLessChildren();
double avgLessChildren = ( pNode->GetTotalCalls() > 0 ) ? pNode->GetTotalTimeLessChildren() / (double)pNode->GetTotalCalls() : 0;
pKeyValues->SetString( "Text", pNode->GetName() );
pKeyValues->SetString( "group", m_pVProfile->GetBudgetGroupName( pNode->GetBudgetGroupID() ) );
CFmtStrN< 256 > frame;
CFmtStrN< 256 > avgstr;
CFmtStrN< 256 > sum;
CFmtStrN< 256 > l2miss;
frame.sprintf( "[%4d] %7.2f %7.2f", pNode->GetCurCalls(), pNode->GetCurTime(), curTimeLessChildren );
pKeyValues->SetString( "frame", msg );
if( vprof_verbose.GetBool() )
{
double avgCalls = ( m_pVProfile->NumFramesSampled() > 0 ) ? (double)pNode->GetTotalCalls() / (double)m_pVProfile->NumFramesSampled() : 0;
double avg = ( m_pVProfile->NumFramesSampled() > 0 ) ? (double)pNode->GetTotalTime() / (double)m_pVProfile->NumFramesSampled() : 0;
double avgLessChildrenVerbose = ( m_pVProfile->NumFramesSampled() > 0 ) ? (double)pNode->GetTotalTimeLessChildren() / (double)m_pVProfile->NumFramesSampled() : 0;
avgstr.sprintf( "[%6.2f] %6.3f %6.3f", avgCalls, avg, avgLessChildrenVerbose );
sum.sprintf( "[%7d] %9.2f %9.2f %8.2fp", pNode->GetTotalCalls(), pNode->GetTotalTime(), pNode->GetTotalTimeLessChildren(), pNode->GetPeakTime() );
}
if ( m_pVProfile->UsePME() )
{
l2miss.sprintf( "%5d", pNode->GetL2CacheMisses() );
}
msg.sprintf( DATA_FMT_STR,
(const char *)frame,
(const char *)avgstr,
(const char *)sum,
(const char *)l2miss );
pKeyValues->SetString( "data", msg );
pKeyValues->SetFloat( "Time", avgLessChildren );
// Add or modify a line in the hierarchy
int id = pNode->GetClientData();
if ( id == -1 )
{
CProfileHierarchyPanel::ColumnPanels_t cp;
AddColumns( cp );
id = m_pHierarchy->AddItem( pKeyValues, parent, cp ) ;
pNode->SetClientData( id );
}
else
{
VPROF( "UpdateVProfTreeEntry:Modify" );
m_pHierarchy->ModifyItem( pKeyValues, id );
}
// Apply color to the item
int r,g,b,a;
m_pVProfile->GetBudgetGroupColor( pNode->GetBudgetGroupID(), r, g, b, a );
m_pHierarchy->SetItemColors( id, Color( r, g, b, a ), Color( 0, 0, 0, 255 ) );
if( pNode->GetBudgetGroupID() == VPROF_BUDGET_GROUP_ID_UNACCOUNTED )
{
if ( curTimeLessChildren > vprof_unaccounted_limit.GetFloat() )
{
m_pHierarchy->SetItemColors( id, Color( 255, 0, 0, 255 ), Color( 0, 0, 0, 255 ) );
}
}
if ( pNode->GetCurTime() > vprof_warningmsec.GetFloat() ||
curTimeLessChildren > vprof_warningmsec.GetFloat() )
{
m_pHierarchy->SetItemColumnColors( id, 2, Color( 255, 0, 0, 255 ), Color( 63, 0, 0, 255 ) );
}
return id;
}
//-----------------------------------------------------------------------------
// Populate the tree
//-----------------------------------------------------------------------------
void CVProfPanel::FillTree( KeyValues *pKeyValues, CVProfNode *pNode, int parent )
{
#ifdef VPROF_ENABLED
bool fIsRoot = ( pNode == m_pVProfile->GetRoot() );
if ( fIsRoot )
{
if( pNode->GetChild() )
{
FillTree( pKeyValues, pNode->GetChild(), parent );
}
return;
}
int id = parent;
if (( m_nCurrentBudgetGroup < 0 ) || ( pNode->GetBudgetGroupID() == m_nCurrentBudgetGroup ))
{
id = UpdateVProfTreeEntry( pKeyValues, pNode, parent );
}
if( pNode->GetSibling() )
{
FillTree( pKeyValues, pNode->GetSibling(), parent );
}
if( pNode->GetChild() )
{
FillTree( pKeyValues, pNode->GetChild(), m_bHierarchicalView ? id : parent );
}
#endif
}
//-----------------------------------------------------------------------------
// Populates the budget group combo box
//-----------------------------------------------------------------------------
void CVProfPanel::PopulateBudgetGroupComboBox()
{
int nBudgetGroupCount = m_pVProfile->GetNumBudgetGroups();
while( m_nLastBudgetGroupCount < nBudgetGroupCount )
{
m_pVProfCategory->AddItem( m_pVProfile->GetBudgetGroupName(m_nLastBudgetGroupCount), NULL );
++m_nLastBudgetGroupCount;
}
}
//-----------------------------------------------------------------------------
// Populates the tree
//-----------------------------------------------------------------------------
void CVProfPanel::UpdateProfile( float filteredtime )
{
#ifdef VPROF_ENABLED
//ExecuteDeferredOp();
if (IsVisible())
{
PopulateBudgetGroupComboBox();
SetTitle( CFmtStr( "VProf (%s) -- %d frames sampled",
m_pVProfile->IsEnabled() ? "running" : "not running",
m_pVProfile->NumFramesSampled() ), false );
// It's important to cache bEnabled since calling pause can disable.
bool bEnabled = m_pVProfile->IsEnabled();
if( bEnabled )
{
m_pVProfile->Pause();
}
KeyValues * pVal = new KeyValues("");
if ( !m_pHierarchy->GetTree()->GetItemCount() )
{
pVal->SetString( "Text", "Call tree" );
CProfileHierarchyPanel::ColumnPanels_t cp;
AddColumns( cp );
m_RootItem = m_pHierarchy->AddItem( pVal, -1, cp );
m_pHierarchy->SetItemColors( m_RootItem, Color( 255, 255, 255, 255 ), Color( 0, 0, 0, 255 ) );
m_pHierarchy->ExpandItem( m_RootItem, true );
}
m_pHierarchy->ExpandItem( m_RootItem, true );
const char *pScope = vprof_scope.GetString();
CVProfNode *pStartNode = ( pScope[0] == 0 ) ? m_pVProfile->GetRoot() : m_pVProfile->FindNode(m_pVProfile->GetRoot(), pScope );
if ( pStartNode )
{
FillTree( pVal, pStartNode, m_RootItem );
}
pVal->deleteThis();
if( bEnabled )
{
m_pVProfile->Resume();
}
}
if ( m_pVProfile->IsEnabled() )
{
Assert( m_pVProfile->AtRoot() );
if ( GetBudgetPanel()->IsBudgetPanelShown() )
GetBudgetPanel()->SnapshotVProfHistory( filteredtime );
WriteRemoteVProfData(); // send out the vprof data to remote endpoints
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CVProfPanel::UserCmd_ShowVProf( void )
{
m_fShowVprofHeld = true;
SetVisible( true );
// This is hacky . . need to at least remember the previous value to set it back.
ConVarRef cl_mouseenable( "cl_mouseenable" );
if ( cl_mouseenable.IsValid() )
{
cl_mouseenable.SetValue( 0 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CVProfPanel::UserCmd_HideVProf( void )
{
m_fShowVprofHeld = false;
SetVisible( false );
// This is hacky . . need to at least remember the previous value to set it back.
ConVarRef cl_mouseenable( "cl_mouseenable" );
if ( cl_mouseenable.IsValid() )
{
cl_mouseenable.SetValue( 1 );
}
}
//-----------------------------------------------------------------------------
void CVProfPanel::Paint()
{
m_pVProfile->Pause();
BaseClass::Paint();
m_pVProfile->Resume();
}
void CVProfPanel::OnCommand( const char *pCommand )
{
#ifndef _XBOX
if ( !Q_stricmp( pCommand, "StepForward" ) )
{
VProfPlayback_Step();
}
else if ( !Q_stricmp( pCommand, "StepBack" ) )
{
int shouldReset = VProfPlayback_StepBack();
if ( shouldReset == 2 )
{
Reset();
}
}
else if ( !Q_stricmp( pCommand, "GotoButton" ) )
{
int shouldReset = VProfPlayback_SeekToPercent( (float)m_pPlaybackScroll->GetValue() / 1000.0 );
if ( shouldReset == 2 )
{
Reset();
}
}
else if ( !Q_stricmp( pCommand, "redosort" ) )
{
//
Assert( !m_bHierarchicalView );
Reset();
}
#endif
}
#endif
Reference in New Issue Copy Permalink