cmaterialsystemstats.cpp

hl2 source code. Do not use it illegal.

//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
//
// The copyright to the contents herein is the property of Valve, L.L.C.
// The contents may be used and/or copied only with the written permission of
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//
// $Header: $
// $NoKeywords: $
//
//=============================================================================

#include "locald3dtypes.h"
#include "CMaterialSystemStats.h"								    
#include "limits.h"														    
#include "materialsystem/IMaterialSystem.h"
#include "ShaderAPIDX8_Global.h"
#include "ShaderAPIDX8.h"
#include "IShaderUtil.h"
#include "materialsystem/MaterialSystem_Config.h"

const char *CMaterialSystemStatsDX8::s_TimedStatsNames[] =
{
	"MATERIAL_SYSTEM_STATS_VERTEX_COPY_TIME0",
	"MATERIAL_SYSTEM_STATS_RENDER_PASS_TIME",
	"MATERIAL_SYSTEM_STATS_MESH_BUILD_TIME",
	"MATERIAL_SYSTEM_STATS_AMBIENT_CUBE_TIME",
	"MATERIAL_SYSTEM_STATS_BUFFER_LOCK_TIME",
	"MATERIAL_SYSTEM_STATS_BUFFER_UNLOCK_TIME",
	"MATERIAL_SYSTEM_STATS_SWAP_TIME",
	"MATERIAL_SYSTEM_STATS_SET_RENDER_STATE",
	"MATERIAL_SYSTEM_STATS_DRAW_INDEXED_PRIMITIVE",
	"MATERIAL_SYSTEM_STATS_SET_TRANSFORM",
	"MATERIAL_SYSTEM_STATS_TRANSFORM_COPY",
	"MATERIAL_SYSTEM_STATS_UPDATE_FLUSH",
	"MATERIAL_SYSTEM_STATS_TFF",
	"MATERIAL_SYSTEM_STATS_AMBIENT_LOCK",
	"MATERIAL_SYSTEM_STATS_COMMIT_STATE_TIME",
	"MATERIAL_SYSTEM_STATS_COMMIT_TRANSFORMS_TIME",
	"MATERIAL_SYSTEM_STATS_COMMIT_LIGHTING_TIME",
	"MATERIAL_SYSTEM_STATS_VERTEX_SHADER_CONSTANT_TIME",
	"MATERIAL_SYSTEM_STATS_CLEAR_TIME",
	"MATERIAL_SYSTEM_STATS_SET_VERTEX_SHADER",
	"MATERIAL_SYSTEM_STATS_SET_PIXEL_SHADER",
	"MATERIAL_SYSTEM_STATS_DRAW_MESH",
	"MATERIAL_SYSTEM_STATS_SET_TEXTURE",
	"MATERIAL_SYSTEM_STATS_BEGIN_PASS",
	"MATERIAL_SYSTEM_STATS_UPDATE_MATRIX_TRANSFORM",
	"MATERIAL_SYSTEM_STATS_FLUSH",
	"MATERIAL_SYSTEM_STATS_FOG_MODE",
	"MATERIAL_SYSTEM_STATS_SHADEMODE",
	"MATERIAL_SYSTEM_STATS_COLOR4F",
	"MATERIAL_SYSTEM_STATS_AMBIENT_VERTEX",
	"MATERIAL_SYSTEM_STATS_COMMIT_VIEW_TIME",
	"MATERIAL_SYSTEM_STATS_COMMIT_VIEWMODEL_TIME",
	"MATERIAL_SYSTEM_STATS_TEST1",
	"MATERIAL_SYSTEM_STATS_TEST2",
	"MATERIAL_SYSTEM_STATS_TEST3",
	"MATERIAL_SYSTEM_STATS_TEST4",
	"MATERIAL_SYSTEM_STATS_TEST5",
	"MATERIAL_SYSTEM_STATS_FLUSH_HARDWARE",
	"MATERIAL_SYSTEM_STATS_READ_PIXEL_SHADER_TIME",
	"MATERIAL_SYSTEM_STATS_ASSEMBLE_PIXEL_SHADER_TIME",
	"MATERIAL_SYSTEM_STATS_CREATE_PIXEL_SHADER_TIME",
	"MATERIAL_SYSTEM_STATS_CREATE_VERTEX_SHADER_TIME",
};

const char *CMaterialSystemStatsDX8::s_CountedStatsNames[] =
{
	"MATERIAL_SYSTEM_STATS_TEXTURE_STATE",
	"MATERIAL_SYSTEM_STATS_DYNAMIC_STATE",
	"MATERIAL_SYSTEM_STATS_SHADOW_STATE",
	"MATERIAL_SYSTEM_STATS_NUM_TEXELS",
	"MATERIAL_SYSTEM_STATS_NUM_BYTES",
	"MATERIAL_SYSTEM_STATS_NUM_UNIQUE_TEXELS",
	"MATERIAL_SYSTEM_STATS_NUM_UNIQUE_BYTES",
	"MATERIAL_SYSTEM_STATS_TEXTURE_BYTES_DOWNLOADED",
	"MATERIAL_SYSTEM_STATS_TEXTURE_TEXELS_DOWNLOADED",
	"MATERIAL_SYSTEM_STATS_NUM_INDEX_PRIMITIVE_CALLS",
	"MATERIAL_SYSTEM_STATS_NUM_PRIMITIVES",
	"MATERIAL_SYSTEM_STATS_TEXTURE_UPLOADS",
	"MATERIAL_SYSTEM_STATS_NUM_UNIQUE_TEXTURES",
	"MATERIAL_SYSTEM_STATS_FILL_RATE",
	"MATERIAL_SYSTEM_STATS_NUM_BUFFER_LOCK",
	"MATERIAL_SYSTEM_STATS_TEXTURE_BYTES_ALLOCATED",
	"MATERIAL_SYSTEM_STATS_MODEL_BYTES_ALLOCATED",
	"MATERIAL_SYSTEM_STATS_TEXTURE_BYTES_NEW_THIS_FRAME",
	"MATERIAL_SYSTEM_STATS_LIGHTMAP_BYTES_ALLOCATED",
	"MATERIAL_SYSTEM_STATS_VERTEX_TRANSFORM",
	"MATERIAL_SYSTEM_STATS_NUM_PIXEL_SHADER_CREATES",
	"MATERIAL_SYSTEM_STATS_NUM_VERTEX_SHADER_CREATES",
};

const char *CMaterialSystemStatsDX8::s_StatGroupNames[] =
{
	"MATERIAL_SYSTEM_STATS_OTHER",
	"MATERIAL_SYSTEM_STATS_WORLD",
	"MATERIAL_SYSTEM_STATS_STATIC_PROPS",
	"MATERIAL_SYSTEM_STATS_TOTAL",
};

//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------

CMaterialSystemStatsDX8::CMaterialSystemStatsDX8() : 
	m_CurrentStatGroup(MATERIAL_SYSTEM_STATS_OTHER), m_InFrame( false )
{
	Assert( MATERIAL_SYSTEM_STATS_NUM_TIMED_STATS == sizeof( s_TimedStatsNames ) / sizeof( s_TimedStatsNames[0] ) );
	Assert( MATERIAL_SYSTEM_STATS_NUM_COUNTED_STATS == sizeof( s_CountedStatsNames ) / sizeof( s_CountedStatsNames[0] ) );
	Assert( MATERIAL_SYSTEM_STATS_NUM_GROUPS == sizeof( s_StatGroupNames ) / sizeof( s_StatGroupNames[0] ) );
}
	

CMaterialSystemStatsDX8::~CMaterialSystemStatsDX8()
{
}

//-----------------------------------------------------------------------------
// Reset
//-----------------------------------------------------------------------------

void CMaterialSystemStatsDX8::BeginRun()
{
	int i;
	for( i = 0; i < MATERIAL_SYSTEM_STATS_NUM_GROUPS; i++ )
	{
		int j;
		for (j = 0; j < MATERIAL_SYSTEM_STATS_NUM_TIMED_STATS; ++j)
			m_StatGroup[i].m_TotalStatTime[j] = 0.0;

		for (j = 0; j < MATERIAL_SYSTEM_STATS_NUM_COUNTED_STATS; ++j)
		{
			m_StatGroup[i].m_TotalStat[j] = 0;
			m_StatGroup[i].m_MinStatPerFrame[j] = INT_MAX;
			m_StatGroup[i].m_MaxStatPerFrame[j] = INT_MIN;
		}
	}
}

void CMaterialSystemStatsDX8::EndRun()
{
}

//-----------------------------------------------------------------------------
// Begin, end frame
//-----------------------------------------------------------------------------

void CMaterialSystemStatsDX8::BeginFrame( )
{
	// bah... performance overhead for doing stats. ick
	ShaderAPI()->FlushBufferedPrimitives();

	m_InFrame = true;

	int i;
	for( i = 0; i < MATERIAL_SYSTEM_STATS_NUM_GROUPS; i++ )
	{
		int j;
		for (j = 0; j < MATERIAL_SYSTEM_STATS_NUM_TIMED_STATS; ++j)
		{
			m_StatGroup[i].m_StatFrameTime[j] = 0.0;
		}
		for (j = 0; j < MATERIAL_SYSTEM_STATS_NUM_COUNTED_STATS; ++j)
		{
			m_StatGroup[i].m_NumStatInFrame[j] = 0;
		}
	}
}

void CMaterialSystemStatsDX8::EndFrame( )
{
	// bah... performance overhead for doing stats. ick
	ShaderAPI()->FlushBufferedPrimitives();

	// Measure the fill rate....
	if (ShaderUtil()->GetConfig().bMeasureFillRate)
	{
		ShaderAPI()->ComputeFillRate();
	}

	m_InFrame = false;

	int i;
	for( i = 0; i < MATERIAL_SYSTEM_STATS_NUM_GROUPS; i++ )
	{
		int j;
		for (j = 0; j < MATERIAL_SYSTEM_STATS_NUM_TIMED_STATS; ++j)
		{
			m_StatGroup[i].m_TotalStatTime[j] += m_StatGroup[i].m_StatFrameTime[j];
		}

		for (j = 0; j < MATERIAL_SYSTEM_STATS_NUM_COUNTED_STATS; ++j)
		{
			if( m_StatGroup[i].m_NumStatInFrame[j] < m_StatGroup[i].m_MinStatPerFrame[j] )
			{
				m_StatGroup[i].m_MinStatPerFrame[j] = m_StatGroup[i].m_NumStatInFrame[j];
			}
			if( m_StatGroup[i].m_NumStatInFrame[j] > m_StatGroup[i].m_MaxStatPerFrame[j] )
			{
				m_StatGroup[i].m_MaxStatPerFrame[j] = m_StatGroup[i].m_NumStatInFrame[j];
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Inline methods
//-----------------------------------------------------------------------------

void CMaterialSystemStatsDX8::SetStatGroup( int group )
{
	// bah... performance overhead for doing stats. ick
	// but maybe it doesn't matter, since we're switching from world to non-world
	// this likely implies a material switch anyways and a flush.
	ShaderAPI()->FlushBufferedPrimitives();
	m_CurrentStatGroup = ( MaterialSystemStatsGroup_t )group;
}

int CMaterialSystemStatsDX8::GetCurrentStatGroup( void ) const
{
	return m_CurrentStatGroup;
}

const char *CMaterialSystemStatsDX8::GetStatGroupName( int groupID ) const
{
	Assert( groupID >= 0 && groupID < MATERIAL_SYSTEM_STATS_NUM_GROUPS );
	return s_StatGroupNames[groupID];
}

int CMaterialSystemStatsDX8::GetNumStatGroups( void ) const
{
	return MATERIAL_SYSTEM_STATS_NUM_GROUPS;
}

//-----------------------------------------------------------------------------
// retuns counted stats...
//-----------------------------------------------------------------------------

int CMaterialSystemStatsDX8::CountedStatInFrame( int /*MaterialSystemCountedStatId_t*/ stat ) const
{
	return m_StatGroup[m_CurrentStatGroup].m_NumStatInFrame[stat];
}

__int64 CMaterialSystemStatsDX8::TotalCountedStat( int /*MaterialSystemCountedStatId_t*/ stat ) const
{
	return m_StatGroup[m_CurrentStatGroup].m_TotalStat[stat];
}

int CMaterialSystemStatsDX8::MinCountedStat( int /*MaterialSystemCountedStatId_t*/ stat ) const
{
	return m_StatGroup[m_CurrentStatGroup].m_MinStatPerFrame[stat];
}

int CMaterialSystemStatsDX8::MaxCountedStat( int /*MaterialSystemCountedStatId_t*/ stat ) const
{
	return m_StatGroup[m_CurrentStatGroup].m_MaxStatPerFrame[stat];
}


//-----------------------------------------------------------------------------