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.
 
 
 
 
 
 

2280 lines
73 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include "imorphinternal.h"
#include "tier0/dbg.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/MaterialSystemUtil.h"
#include "materialsystem/itexture.h"
#include "materialsystem/imesh.h"
#include "UtlSortVector.h"
#include "materialsystem_global.h"
#include "IHardwareConfigInternal.h"
#include "pixelwriter.h"
#include "itextureinternal.h"
#include "tier1/KeyValues.h"
#include "texturemanager.h"
#include "imaterialsysteminternal.h"
#include "imatrendercontextinternal.h"
#include "studio.h"
#include "tier0/vprof.h"
#include "renderparm.h"
#include "tier2/renderutils.h"
#include "bitmap/imageformat.h"
#include "materialsystem/IShader.h"
#include "imaterialinternal.h"
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
// Activate to get stats
//-----------------------------------------------------------------------------
//#define REPORT_MORPH_STATS 1
//-----------------------------------------------------------------------------
// Used to collapse quads with small gaps
//-----------------------------------------------------------------------------
#define MIN_SEGMENT_GAP_SIZE 12
//-----------------------------------------------------------------------------
// Used to compile the morph data into a vertex texture
//-----------------------------------------------------------------------------
class CVertexMorphDict
{
public:
CVertexMorphDict();
// Adds a morph to the dictionary
void AddMorph( const MorphVertexInfo_t &info );
// Sets up, cleans up the morph information
void Setup( );
void CleanUp();
// Gets at morph info
int MorphCount() const;
int GetMorphTargetId( int nMorphTargetIndex ) const;
int GetMorphVertexCount( int nMorphTargetIndex ) const;
const MorphVertexInfo_t &GetMorphVertexInfo( int nMorphTargetIndex, int nIndex ) const;
// Sorts deltas by destination vertex
void SortDeltas();
private:
// Sort method for each morph target's vertices
class CMorphVertexListLess
{
public:
bool Less( const MorphVertexInfo_t& src1, const MorphVertexInfo_t& src2, void *pCtx )
{
return src1.m_nVertexId < src2.m_nVertexId;
}
};
// A list of all vertices affecting a particular morph target
struct MorphVertexList_t
{
MorphVertexList_t() {}
MorphVertexList_t( const MorphVertexList_t& src ) : m_nMorphTargetId( src.m_nMorphTargetId ) {}
int m_nMorphTargetId;
CUtlSortVector< MorphVertexInfo_t, CMorphVertexListLess > m_MorphInfo;
};
// Sort function for the morph lists
class VertexMorphDictLess
{
public:
bool Less( const MorphVertexList_t& src1, const MorphVertexList_t& src2, void *pCtx );
};
// For each morph, store all target vertex indices
// List of all morphs affecting all vertices, used for constructing the morph only
CUtlSortVector< MorphVertexList_t, VertexMorphDictLess > m_MorphLists;
};
//-----------------------------------------------------------------------------
// Used to sort the morphs affecting a particular vertex
//-----------------------------------------------------------------------------
bool CVertexMorphDict::VertexMorphDictLess::Less( const CVertexMorphDict::MorphVertexList_t& src1, const CVertexMorphDict::MorphVertexList_t& src2, void *pCtx )
{
return src1.m_nMorphTargetId < src2.m_nMorphTargetId;
}
//-----------------------------------------------------------------------------
// Dictionary of morphs affecting a particular vertex
//-----------------------------------------------------------------------------
CVertexMorphDict::CVertexMorphDict() : m_MorphLists()
{
}
//-----------------------------------------------------------------------------
// Adds a morph to the dictionary
//-----------------------------------------------------------------------------
void CVertexMorphDict::AddMorph( const MorphVertexInfo_t &info )
{
Assert( info.m_nVertexId != 65535 );
MorphVertexList_t find;
find.m_nMorphTargetId = info.m_nMorphTargetId;
int nIndex = m_MorphLists.Find( find );
if ( nIndex == m_MorphLists.InvalidIndex() )
{
m_MorphLists.Insert( find );
nIndex = m_MorphLists.Find( find );
}
m_MorphLists[nIndex].m_MorphInfo.InsertNoSort( info );
}
//-----------------------------------------------------------------------------
// Sets up, cleans up the morph information
//-----------------------------------------------------------------------------
void CVertexMorphDict::Setup( )
{
m_MorphLists.Purge();
}
void CVertexMorphDict::CleanUp( )
{
}
//-----------------------------------------------------------------------------
// Gets at the dictionary elemenst
//-----------------------------------------------------------------------------
int CVertexMorphDict::MorphCount() const
{
return m_MorphLists.Count();
}
int CVertexMorphDict::GetMorphTargetId( int i ) const
{
if ( i >= m_MorphLists.Count() )
return -1;
return m_MorphLists[i].m_nMorphTargetId;
}
int CVertexMorphDict::GetMorphVertexCount( int nMorphTarget ) const
{
return m_MorphLists[nMorphTarget].m_MorphInfo.Count();
}
const MorphVertexInfo_t &CVertexMorphDict::GetMorphVertexInfo( int nMorphTarget, int j ) const
{
return m_MorphLists[nMorphTarget].m_MorphInfo[j];
}
//-----------------------------------------------------------------------------
// Sorts deltas by destination vertex
//-----------------------------------------------------------------------------
void CVertexMorphDict::SortDeltas()
{
int nMorphTargetCount = m_MorphLists.Count();
for ( int i = 0; i < nMorphTargetCount; ++i )
{
m_MorphLists[i].m_MorphInfo.RedoSort();
}
}
//-----------------------------------------------------------------------------
//
// Morph data class
//
//-----------------------------------------------------------------------------
class CMorph : public IMorphInternal, public ITextureRegenerator
{
public:
// Constructor, destructor
CMorph();
~CMorph();
// Inherited from IMorph
virtual void Lock( float flFloatToFixedScale );
virtual void AddMorph( const MorphVertexInfo_t &info );
virtual void Unlock( );
// Inherited from IMorphInternal
virtual void Init( MorphFormat_t format, const char *pDebugName );
virtual void Bind( IMorphMgrRenderContext *pRenderContext );
virtual MorphFormat_t GetMorphFormat() const;
// Other public methods
bool RenderMorphWeights( IMatRenderContext *pRenderContext, int nRenderId, int nWeightCount, const MorphWeight_t* pWeights );
void AccumulateMorph( int nRenderId );
private:
// A list of all morphs affecting a particular vertex
// Assume that consecutive morphs are stored under each other in V coordinates
// both in the src texture and destination texture (which is the morph accumulation texture).
struct MorphSegment_t
{
unsigned int m_nFirstSrc;
unsigned short m_nFirstDest;
unsigned short m_nCount;
};
struct MorphQuad_t
{
unsigned int m_nFirstSrc;
unsigned short m_nFirstDest;
unsigned short m_nCount;
unsigned short m_nQuadIndex;
};
enum MorphTextureId_t
{
MORPH_TEXTURE_POS_NORMAL_DELTA = 0,
MORPH_TEXTURE_SPEED_SIDE_MAP,
MORPH_TEXTURE_COUNT
};
typedef void (CMorph::*MorphPixelWriter_t)( CPixelWriter &pixelWriter, int x, int y, const MorphVertexInfo_t &info );
typedef CUtlVector< MorphSegment_t > MorphSegmentList_t;
typedef CUtlVector< MorphQuad_t > MorphQuadList_t;
private:
// Inherited from ITextureRegenerator
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect );
virtual void Release() {}
// Packs all morph data in the dictionary into a vertex texture layout
void PackMorphData( );
// Builds the list of segments to render, returns total # of src texels to read from
void BuildSegmentList( CUtlVector< MorphSegmentList_t > &morphSegments );
// Builds the list of quads to render
void BuildQuadList( const CUtlVector< MorphSegmentList_t > &morphSegments );
// Computes the vertex texture width
void ComputeTextureDimensions( const CUtlVector< MorphSegmentList_t > &morphSegments );
// Writes a morph delta into the texture
void WriteDeltaPositionNormalToTexture( CPixelWriter &pixelWriter, int x, int y, const MorphVertexInfo_t &info );
void WriteSideSpeedToTexture( CPixelWriter &pixelWriter, int x, int y, const MorphVertexInfo_t &info );
// Computes the morph target 4tuple count
int Get4TupleCount( MorphFormat_t format ) const;
// Cleans up vertex textures
void CleanUp( );
// Is the morph locked?
bool IsLocked() const;
// Creates a material for use to do the morph accumulation
void CreateAccumulatorMaterial( int nMaterialIndex );
// Renders to the morph accumulator texture
void RenderMorphQuads( IMatRenderContext *pRenderContext, int nRenderId, int nTotalQuadCount, int nWeightCount, int *pWeightLookup, const MorphWeight_t* pWeights );
// Displays static morph data statistics
void DisplayMorphStats();
// Dynamic stat data
void ClearMorphStats();
void AccumulateMorphStats( int nActiveMorphCount, int nQuadsRendered, int nTexelsRendered );
void ReportMorphStats( );
void HandleMorphStats( int nActiveMorphCount, int nQuadsRendered, int nTexelsRendered );
// Computes morph texture size in bytes
int ComputeMorphTextureSizeInBytes( ) const;
// Counts the total number of vertices to place in the static mesh
int CountStaticMeshVertices() const;
// Determines mesh vertex format
VertexFormat_t ComputeVertexFormat( IMaterial * pMaterial ) const;
// Builds the list of quads to render
void CreateStaticMesh();
// Builds a list of non-zero morph targets
int BuildNonZeroMorphList( int *pWeightIndices, int nWeightCount, const MorphWeight_t* pWeights );
// Determines the total number of deltas
int DetermineTotalDeltaCount( const CUtlVector< MorphSegmentList_t > &morphSegments ) const;
// Binds the morph weight texture
void BindMorphWeight( int nRenderId );
private:
// Used when constructing the morph targets
CVertexMorphDict m_MorphDict;
bool m_bLocked;
// The morph format
MorphFormat_t m_Format;
// The compiled vertex textures
ITextureInternal *m_pMorphTexture[MORPH_TEXTURE_COUNT];
// The compiled vertex streams
IMesh* m_pMorphBuffer;
// Describes all morph line segments required to draw a particular morph
CUtlVector< MorphQuadList_t > m_MorphQuads;
CUtlVector< int > m_MorphTargetIdToQuadIndex;
// Caches off the morph weights when in the middle of performing morph accumulation
int m_nMaxMorphTargetCount;
MorphWeight_t *m_pRenderMorphWeight;
CMaterialReference m_MorphAccumulationMaterial;
// Float->fixed scale
float m_flFloatToFixedScale;
// Morph input texture size
int m_nTextureWidth;
int m_nTextureHeight;
#ifdef _DEBUG
CUtlString m_pDebugName;
#endif
// Used to unique-ify morph texture names
static int s_nUniqueId;
};
//-----------------------------------------------------------------------------
// Render context for morphing. Only is used to determine
// where in the morph accumulator to put the texture.
//-----------------------------------------------------------------------------
class CMorphMgrRenderContext : public IMorphMgrRenderContext
{
public:
enum UnnamedEnumsAreNotLegal
{
MAX_MODEL_MORPHS = 4,
};
CMorphMgrRenderContext();
int GetRenderId( CMorph* pMorph );
public:
int m_nMorphCount;
CMorph *m_pMorphsToAccumulate[MAX_MODEL_MORPHS];
#ifdef DBGFLAG_ASSERT
bool m_bInMorphAccumulation;
#endif
};
//-----------------------------------------------------------------------------
// Morph manager class
//-----------------------------------------------------------------------------
class CMorphMgr : public IMorphMgr
{
public:
CMorphMgr();
// Methods of IMorphMgr
virtual bool ShouldAllocateScratchTextures();
virtual void AllocateScratchTextures();
virtual void FreeScratchTextures();
virtual void AllocateMaterials();
virtual void FreeMaterials();
virtual ITextureInternal *MorphAccumulator();
virtual ITextureInternal *MorphWeights();
virtual IMorphInternal *CreateMorph();
virtual void DestroyMorph( IMorphInternal *pMorphData );
virtual int MaxHWMorphBatchCount() const;
virtual void BeginMorphAccumulation( IMorphMgrRenderContext *pIRenderContext );
virtual void EndMorphAccumulation( IMorphMgrRenderContext *pIRenderContext );
virtual void AccumulateMorph( IMorphMgrRenderContext *pIRenderContext, IMorph* pMorph, int nMorphCount, const MorphWeight_t* pWeights );
virtual void AdvanceFrame();
virtual bool GetMorphAccumulatorTexCoord( IMorphMgrRenderContext *pRenderContext, Vector2D *pTexCoord, IMorph *pMorph, int nVertex );
virtual IMorphMgrRenderContext *AllocateRenderContext();
virtual void FreeRenderContext( IMorphMgrRenderContext *pRenderContext );
// Other public methods
public:
// Computes texel offsets for the upper corner of the morph accumulator for a particular block
void ComputeAccumulatorSubrect( int *pXOffset, int *pYOffset, int *pWidth, int *pHeight, int nMorphAccumBlockId );
void GetAccumulatorSubrectDimensions( int *pWidth, int *pHeight );
int GetAccumulator4TupleCount() const;
// Computes texel offsets for the upper corner of the morph weight texture for a particular block
void ComputeWeightSubrect( int *pXOffset, int *pYOffset, int *pWidth, int *pHeight, int nMorphAccumBlockId );
// Used to compute stats of memory used
void RegisterMorphSizeInBytes( int nSizeInBytes );
int GetTotalMemoryUsage() const;
// Are we using the constant register method?
bool IsUsingConstantRegisters() const { return m_bUsingConstantRegisters; }
private:
// Displays 32bit float texture data
void Display32FTextureData( float *pBuf, int nTexelID, int *pSubRect, ITexture *pTexture, int n4TupleCount );
// A debugging utility to display the morph accumulator
void DebugMorphAccumulator( IMatRenderContext *pRenderContext );
// A debugging utility to display the morph weights
void DebugMorphWeights( IMatRenderContext *pRenderContext );
// Draws the morph accumulator + morph weights
void DrawMorphTempTexture( IMatRenderContext *pRenderContext, IMaterial *pMaterial, ITexture *pTexture );
private:
enum
{
MAX_MORPH_ACCUMULATOR_VERTICES = 32768,
MORPH_ACCUMULATOR_4TUPLES = 2, // 1 for pos + wrinkle, 1 for normal
};
int m_nAccumulatorWidth;
int m_nAccumulatorHeight;
int m_nSubrectVerticalCount;
int m_nWeightWidth;
int m_nWeightHeight;
int m_nFrameCount;
int m_nTotalMorphSizeInBytes;
IMaterial *m_pPrevMaterial;
void *m_pPrevProxy;
int m_nPrevBoneCount;
MaterialHeightClipMode_t m_nPrevClipMode;
bool m_bPrevClippingEnabled;
bool m_bUsingConstantRegisters;
bool m_bFlashlightMode;
ITextureInternal *m_pMorphAccumTexture;
ITextureInternal *m_pMorphWeightTexture;
IMaterial *m_pVisualizeMorphAccum;
IMaterial *m_pVisualizeMorphWeight;
IMaterial *m_pRenderMorphWeight;
};
//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
static CMorphMgr s_MorphMgr;
IMorphMgr *g_pMorphMgr = &s_MorphMgr;
//-----------------------------------------------------------------------------
// Globals
//-----------------------------------------------------------------------------
int CMorph::s_nUniqueId = 0;
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CMorph::CMorph()
{
memset( m_pMorphTexture, 0, sizeof(m_pMorphTexture) );
m_pMorphBuffer = NULL;
m_nTextureWidth = 0;
m_nTextureHeight = 0;
m_bLocked = false;
m_Format = 0;
m_flFloatToFixedScale = 1.0f;
m_pRenderMorphWeight = 0;
m_nMaxMorphTargetCount = 0;
}
CMorph::~CMorph()
{
CleanUp();
}
//-----------------------------------------------------------------------------
// Initialization
//-----------------------------------------------------------------------------
void CMorph::Init( MorphFormat_t format, const char *pDebugName )
{
m_Format = format;
#ifdef _DEBUG
m_pDebugName = pDebugName;
#endif
}
//-----------------------------------------------------------------------------
// Returns the morph format
//-----------------------------------------------------------------------------
MorphFormat_t CMorph::GetMorphFormat() const
{
return m_Format;
}
//-----------------------------------------------------------------------------
// Binds morph accumulator, morph weights
//-----------------------------------------------------------------------------
void CMorph::Bind( IMorphMgrRenderContext *pIRenderContext )
{
CMorphMgrRenderContext *pMorphRenderContext = static_cast< CMorphMgrRenderContext* >( pIRenderContext );
int nRenderId = pMorphRenderContext->GetRenderId( this );
if ( nRenderId < 0 )
return;
int nXOffset, nYOffset, nWidth, nHeight;
s_MorphMgr.ComputeAccumulatorSubrect( &nXOffset, &nYOffset, &nWidth, &nHeight, nRenderId );
g_pShaderAPI->SetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_4TUPLE_COUNT, s_MorphMgr.GetAccumulator4TupleCount() );
g_pShaderAPI->SetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_X_OFFSET, nXOffset );
g_pShaderAPI->SetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_Y_OFFSET, nYOffset );
g_pShaderAPI->SetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_SUBRECT_WIDTH, nWidth );
g_pShaderAPI->SetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_SUBRECT_HEIGHT, nHeight );
}
void CMorph::BindMorphWeight( int nRenderId )
{
int nXOffset, nYOffset, nWidth, nHeight;
s_MorphMgr.ComputeWeightSubrect( &nXOffset, &nYOffset, &nWidth, &nHeight, nRenderId );
g_pShaderAPI->SetIntRenderingParameter( INT_RENDERPARM_MORPH_WEIGHT_X_OFFSET, nXOffset );
g_pShaderAPI->SetIntRenderingParameter( INT_RENDERPARM_MORPH_WEIGHT_Y_OFFSET, nYOffset );
g_pShaderAPI->SetIntRenderingParameter( INT_RENDERPARM_MORPH_WEIGHT_SUBRECT_WIDTH, nWidth );
g_pShaderAPI->SetIntRenderingParameter( INT_RENDERPARM_MORPH_WEIGHT_SUBRECT_HEIGHT, nHeight );
}
//-----------------------------------------------------------------------------
// Computes morph texture size in bytes
//-----------------------------------------------------------------------------
int CMorph::ComputeMorphTextureSizeInBytes( ) const
{
int nSize = 0;
if ( m_pMorphTexture[MORPH_TEXTURE_POS_NORMAL_DELTA] )
{
int nTotal4Tuples = Get4TupleCount( m_Format );
nSize += m_nTextureWidth * m_nTextureHeight * nTotal4Tuples * ImageLoader::SizeInBytes( IMAGE_FORMAT_RGBA16161616 );
}
if ( m_pMorphTexture[MORPH_TEXTURE_SPEED_SIDE_MAP] )
{
nSize += m_nTextureWidth * m_nTextureHeight * ImageLoader::SizeInBytes( IMAGE_FORMAT_RGBA8888 );
}
// NOTE: Vertex size here is kind of a hack, but whatever.
int nVertexCount = CountStaticMeshVertices();
nSize += nVertexCount * 5 * sizeof(float);
return nSize;
}
//-----------------------------------------------------------------------------
// Cleans up vertex textures
//-----------------------------------------------------------------------------
void CMorph::CleanUp( )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
int nMorphTextureSize = ComputeMorphTextureSizeInBytes();
s_MorphMgr.RegisterMorphSizeInBytes( -nMorphTextureSize );
IMaterial *pMat = m_MorphAccumulationMaterial;
m_MorphAccumulationMaterial.Shutdown();
if ( pMat )
{
pMat->DeleteIfUnreferenced();
}
if ( m_pMorphBuffer )
{
pRenderContext->DestroyStaticMesh( m_pMorphBuffer );
m_pMorphBuffer = NULL;
}
for ( int i = 0; i < MORPH_TEXTURE_COUNT; ++i )
{
if ( m_pMorphTexture[i] )
{
m_pMorphTexture[i]->SetTextureRegenerator( NULL );
m_pMorphTexture[i]->DecrementReferenceCount( );
m_pMorphTexture[i]->DeleteIfUnreferenced();
m_pMorphTexture[i] = NULL;
}
}
if ( m_pRenderMorphWeight )
{
delete[] m_pRenderMorphWeight;
m_pRenderMorphWeight = NULL;
}
m_nMaxMorphTargetCount = 0;
}
//-----------------------------------------------------------------------------
// Is the morph locked?
//-----------------------------------------------------------------------------
bool CMorph::IsLocked() const
{
return m_bLocked;
}
//-----------------------------------------------------------------------------
// Locks the morph data
//-----------------------------------------------------------------------------
void CMorph::Lock( float flFloatToFixedScale )
{
Assert( !IsLocked() );
m_bLocked = true;
CleanUp();
m_flFloatToFixedScale = flFloatToFixedScale;
m_MorphQuads.Purge();
m_MorphTargetIdToQuadIndex.RemoveAll();
m_MorphDict.Setup( );
}
//-----------------------------------------------------------------------------
// Adds morph data to the morph dictionary
//-----------------------------------------------------------------------------
void CMorph::AddMorph( const MorphVertexInfo_t &info )
{
Assert( IsLocked() );
m_MorphDict.AddMorph( info );
}
//-----------------------------------------------------------------------------
// Unlocks the morph data, builds the vertex textures
//-----------------------------------------------------------------------------
void CMorph::Unlock( )
{
Assert( IsLocked() );
// Sort the deltas by destination vertex
m_MorphDict.SortDeltas();
// Now lay out morph data as if it were in a vertex texture
PackMorphData( );
// Free up temporary memory used in building
m_MorphDict.CleanUp();
m_bLocked = false;
// Gather stats
int nMorphTextureSize = ComputeMorphTextureSizeInBytes();
s_MorphMgr.RegisterMorphSizeInBytes( nMorphTextureSize );
}
//-----------------------------------------------------------------------------
// Creates a material for use to do the morph accumulation
//-----------------------------------------------------------------------------
void CMorph::CreateAccumulatorMaterial( int nMaterialIndex )
{
// NOTE: Delta scale is a little tricky. The numbers are store in fixed-point 16 bit.
// The pixel shader will interpret 65536 as 1.0, and 0 as 0.0. In the pixel shader,
// we will read the delta, multiply it by 2, and subtract 1 to get a -1 to 1 range.
// The float to fixed scale is applied prior to writing it in (delta * scale + 32768).
// Therefore the max representable positive value =
// 65536 = max positive delta * scale + 32768
// max positive delta = 32768 / scale
// This is what we will multiply our -1 to 1 values by in the pixel shader.
char pTemp[256];
KeyValues *pVMTKeyValues = new KeyValues( "MorphAccumulate" );
pVMTKeyValues->SetInt( "$nocull", 1 );
pVMTKeyValues->SetFloat( "$deltascale", ( m_flFloatToFixedScale != 0.0f ) ? 32768.0f / m_flFloatToFixedScale : 1.0f );
if ( m_pMorphTexture[MORPH_TEXTURE_POS_NORMAL_DELTA] )
{
pVMTKeyValues->SetString( "$delta", m_pMorphTexture[MORPH_TEXTURE_POS_NORMAL_DELTA]->GetName() );
}
if ( m_pMorphTexture[MORPH_TEXTURE_SPEED_SIDE_MAP] )
{
pVMTKeyValues->SetString( "$sidespeed", m_pMorphTexture[MORPH_TEXTURE_SPEED_SIDE_MAP]->GetName() );
}
Q_snprintf( pTemp, sizeof(pTemp), "[%d %d %d]", m_nTextureWidth, m_nTextureHeight, Get4TupleCount(m_Format) );
pVMTKeyValues->SetString( "$dimensions", pTemp );
Q_snprintf( pTemp, sizeof(pTemp), "___AccumulateMorph%d.vmt", nMaterialIndex );
m_MorphAccumulationMaterial.Init( pTemp, pVMTKeyValues );
}
//-----------------------------------------------------------------------------
// Computes the morph target field count
//-----------------------------------------------------------------------------
int CMorph::Get4TupleCount( MorphFormat_t format ) const
{
int nSize = 0;
if ( format & ( MORPH_POSITION | MORPH_WRINKLE ) )
{
++nSize;
}
if ( format & MORPH_NORMAL )
{
++nSize;
}
return nSize;
}
//-----------------------------------------------------------------------------
// Determines the total number of deltas
//-----------------------------------------------------------------------------
int CMorph::DetermineTotalDeltaCount( const CUtlVector< MorphSegmentList_t > &morphSegments ) const
{
int nDeltaCount = 0;
int nMorphCount = morphSegments.Count();
for ( int i = 0; i < nMorphCount; ++i )
{
const MorphSegmentList_t& list = morphSegments[i];
int nSegmentCount = list.Count();
for ( int j = 0; j < nSegmentCount; ++j )
{
nDeltaCount += list[j].m_nCount;
}
}
return nDeltaCount;
}
//-----------------------------------------------------------------------------
// Computes the texture width
//-----------------------------------------------------------------------------
void CMorph::ComputeTextureDimensions( const CUtlVector< MorphSegmentList_t > &morphSegments )
{
int nTotalDeltas = DetermineTotalDeltaCount( morphSegments );
m_nTextureHeight = ceil( sqrt( (float)nTotalDeltas ) );
// Round the dimension up to a multiple of 4
m_nTextureHeight = ( m_nTextureHeight + 3 ) & ( ~0x3 );
m_nTextureWidth = ( m_nTextureHeight != 0 ) ? ( nTotalDeltas + ( m_nTextureHeight - 1 ) ) / m_nTextureHeight : 0;
m_nTextureWidth = ( m_nTextureWidth + 3 ) & ( ~0x3 );
int nTotal4Tuples = Get4TupleCount( m_Format );
// Make sure it obeys bounds
int nMaxTextureWidth = HardwareConfig()->MaxTextureWidth();
int nMaxTextureHeight = HardwareConfig()->MaxTextureHeight();
while( m_nTextureWidth * nTotal4Tuples > nMaxTextureWidth )
{
m_nTextureWidth >>= 1;
m_nTextureHeight <<= 1;
if ( m_nTextureHeight > nMaxTextureHeight )
{
Warning( "Morph texture is too big!!! Make brian add support for morphs having multiple textures.\n" );
Assert( 0 );
m_nTextureHeight = nMaxTextureHeight;
break;
}
}
}
//-----------------------------------------------------------------------------
// Displays morph data statistics
//-----------------------------------------------------------------------------
void CMorph::DisplayMorphStats()
{
ITexture *pDest = g_pMorphMgr->MorphAccumulator( );
int nDestTextureHeight = pDest->GetActualHeight();
#ifdef _DEBUG
Msg( "Morph %s:\n", m_pDebugName.Get() );
#else
Msg( "Morph :\n" );
#endif
int nMorphCount = m_MorphQuads.Count();
Msg( "\tMorph Target Count : %d\n", nMorphCount );
int nTotalQuadCount = 0;
int nTotalVertexCount = 0;
CUtlVector<int> quadHisto;
CUtlVector<int> vertexHisto;
CUtlVector<int> gapSizeHisto;
for ( int i = 0; i < nMorphCount; ++i )
{
MorphQuadList_t &list = m_MorphQuads[i];
int nQuadCount = list.Count();
int nVertexCount = 0;
for ( int j = 0; j < nQuadCount; ++j )
{
nVertexCount += list[j].m_nCount;
if ( j != 0 )
{
// Filter out src gaps + wraparound gaps
if ( ( list[j].m_nFirstDest / nDestTextureHeight == list[j-1].m_nFirstDest / nDestTextureHeight ) &&
( list[j].m_nFirstSrc / m_nTextureHeight == list[j-1].m_nFirstSrc / m_nTextureHeight ) )
{
int nGapSize = list[j].m_nFirstDest - ( list[j-1].m_nFirstDest + list[j-1].m_nCount );
while ( nGapSize >= gapSizeHisto.Count() )
{
gapSizeHisto.AddToTail( 0 );
}
gapSizeHisto[nGapSize] += 1;
}
}
}
while ( nQuadCount >= quadHisto.Count() )
{
quadHisto.AddToTail( 0 );
}
while ( nVertexCount >= vertexHisto.Count() )
{
vertexHisto.AddToTail( 0 );
}
quadHisto[nQuadCount]+=1;
vertexHisto[nVertexCount]+=1;
nTotalQuadCount += nQuadCount;
nTotalVertexCount += nVertexCount;
}
Msg( "\tAverage # of vertices per target: %d\n", nTotalVertexCount / nMorphCount );
Msg( "\tAverage # of quad draws per target: %d\n", nTotalQuadCount / nMorphCount );
Msg( "\tQuad Count Histogram :\n\t\t" );
for ( int i = 0; i < quadHisto.Count(); ++i )
{
if ( quadHisto[i] == 0 )
continue;
Msg( "[%d : %d] ", i, quadHisto[i] );
}
Msg( "\n\tVertex Count Histogram :\n\t\t" );
for ( int i = 0; i < vertexHisto.Count(); ++i )
{
if ( vertexHisto[i] == 0 )
continue;
Msg( "[%d : %d] ", i, vertexHisto[i] );
}
Msg( "\n\tGap size Count Histogram :\n\t\t" );
for ( int i = 0; i < gapSizeHisto.Count(); ++i )
{
if ( gapSizeHisto[i] == 0 )
continue;
Msg( "[%d : %d] ", i, gapSizeHisto[i] );
}
Msg( "\n" );
}
//-----------------------------------------------------------------------------
// Packs all morph data in the dictionary into a vertex texture layout
//-----------------------------------------------------------------------------
void CMorph::PackMorphData( )
{
CUtlVector< MorphSegmentList_t > morphSegments;
BuildSegmentList( morphSegments );
ComputeTextureDimensions( morphSegments );
BuildQuadList( morphSegments );
if ( m_nTextureWidth == 0 || m_nTextureHeight == 0 )
return;
char pTemp[512];
if ( m_Format & ( MORPH_POSITION | MORPH_WRINKLE | MORPH_NORMAL ) )
{
Q_snprintf( pTemp, sizeof(pTemp), "__morphtarget[%d]: pos/norm", s_nUniqueId );
int nTotal4Tuples = Get4TupleCount( m_Format );
ITexture *pTexture = g_pMaterialSystem->CreateProceduralTexture( pTemp, TEXTURE_GROUP_MORPH_TARGETS,
m_nTextureWidth * nTotal4Tuples, m_nTextureHeight, IMAGE_FORMAT_RGBA16161616,
TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_NOLOD | TEXTUREFLAGS_NODEBUGOVERRIDE |
TEXTUREFLAGS_SINGLECOPY | TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_POINTSAMPLE );
m_pMorphTexture[MORPH_TEXTURE_POS_NORMAL_DELTA] = static_cast<ITextureInternal*>( pTexture );
}
if ( m_Format & ( MORPH_SIDE | MORPH_SPEED ) )
{
Q_snprintf( pTemp, sizeof(pTemp), "__morphtarget[%d]: side/speed", s_nUniqueId );
ITexture *pTexture = g_pMaterialSystem->CreateProceduralTexture( pTemp, TEXTURE_GROUP_MORPH_TARGETS,
m_nTextureWidth, m_nTextureHeight, IMAGE_FORMAT_RGBA8888,
TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_NOLOD | TEXTUREFLAGS_NODEBUGOVERRIDE |
TEXTUREFLAGS_SINGLECOPY | TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_POINTSAMPLE );
m_pMorphTexture[MORPH_TEXTURE_SPEED_SIDE_MAP] = static_cast<ITextureInternal*>( pTexture );
}
for ( int i = 0; i < MORPH_TEXTURE_COUNT; ++i )
{
if ( m_pMorphTexture[i] )
{
m_pMorphTexture[i]->SetTextureRegenerator( this );
m_pMorphTexture[i]->Download();
}
}
CreateAccumulatorMaterial( s_nUniqueId );
++s_nUniqueId;
CreateStaticMesh();
#ifdef REPORT_MORPH_STATS
DisplayMorphStats( );
#endif
}
//-----------------------------------------------------------------------------
// Writes a morph delta into the texture
//-----------------------------------------------------------------------------
void CMorph::WriteDeltaPositionNormalToTexture( CPixelWriter &pixelWriter, int x, int y, const MorphVertexInfo_t &info )
{
// NOTE: 0 = -max range, 32767 = 0, 65534, 65535 = maxrange.
// This way we can encode +/- maxrange and 0 exactly
Assert ( m_Format & ( MORPH_POSITION | MORPH_WRINKLE | MORPH_NORMAL ) );
int n4TupleCount = Get4TupleCount( m_Format );
pixelWriter.Seek( x*n4TupleCount, y );
// NOTE: int cast is where it is to force round-to-zero prior to offset
if ( m_Format & ( MORPH_POSITION | MORPH_WRINKLE ) )
{
int r = 32767, g = 32767, b = 32767, a = 32767;
if ( m_Format & MORPH_POSITION )
{
r = (int)( info.m_PositionDelta.x * m_flFloatToFixedScale ) + 32767;
g = (int)( info.m_PositionDelta.y * m_flFloatToFixedScale ) + 32767;
b = (int)( info.m_PositionDelta.z * m_flFloatToFixedScale ) + 32767;
r = clamp( r, 0, 65534 );
g = clamp( g, 0, 65534 );
b = clamp( b, 0, 65534 );
}
if ( m_Format & MORPH_WRINKLE )
{
a = (int)( info.m_flWrinkleDelta * m_flFloatToFixedScale ) + 32767;
a = clamp( a, 0, 65534 );
}
pixelWriter.WritePixel( r, g, b, a );
}
if ( m_Format & MORPH_NORMAL )
{
int r = 32767, g = 32767, b = 32767, a = 32767;
r = (int)( info.m_NormalDelta.x * m_flFloatToFixedScale ) + 32767;
g = (int)( info.m_NormalDelta.y * m_flFloatToFixedScale ) + 32767;
b = (int)( info.m_NormalDelta.z * m_flFloatToFixedScale ) + 32767;
r = clamp( r, 0, 65534 );
g = clamp( g, 0, 65534 );
b = clamp( b, 0, 65534 );
pixelWriter.WritePixel( r, g, b, a );
}
}
void CMorph::WriteSideSpeedToTexture( CPixelWriter &pixelWriter, int x, int y, const MorphVertexInfo_t &info )
{
Assert ( m_Format & ( MORPH_SPEED | MORPH_SIDE ) );
// Speed + size go from 0 to 1.
int r = 0, g = 0, b = 0, a = 0;
if ( m_Format & MORPH_SIDE )
{
r = info.m_flSide * 255;
}
if ( m_Format & MORPH_SPEED )
{
g = info.m_flSpeed * 255;
}
r = clamp( r, 0, 255 );
g = clamp( g, 0, 255 );
pixelWriter.Seek( x, y );
pixelWriter.WritePixel( r, g, b, a );
}
//-----------------------------------------------------------------------------
// Builds the list of segments to render
//-----------------------------------------------------------------------------
void CMorph::BuildSegmentList( CUtlVector< MorphSegmentList_t > &morphSegments )
{
// Find the dimensions of the destination texture
int nDestTextureWidth, nDestTextureHeight;
s_MorphMgr.GetAccumulatorSubrectDimensions( &nDestTextureWidth, &nDestTextureHeight );
// Prepares the morph segments array
m_nMaxMorphTargetCount = 0;
int nMorphTargetCount = m_MorphDict.MorphCount();
for ( int i = 0; i < nMorphTargetCount; ++i )
{
if ( m_nMaxMorphTargetCount <= m_MorphDict.GetMorphTargetId(i) )
{
m_nMaxMorphTargetCount = m_MorphDict.GetMorphTargetId(i) + 1;
}
}
// Allocate space to cache off the morph weights when in the middle of performing morph accumulation
Assert( !m_pRenderMorphWeight );
m_pRenderMorphWeight = new MorphWeight_t[ m_nMaxMorphTargetCount ];
Assert( m_nMaxMorphTargetCount < 1024 ); // This algorithm of storing a full array is bogus if this isn't true
m_MorphTargetIdToQuadIndex.SetCount( m_nMaxMorphTargetCount );
memset( m_MorphTargetIdToQuadIndex.Base(), 0xFF, m_nMaxMorphTargetCount * sizeof(int) );
// Builds the segment list
int nSrcIndex = 0;
for ( int i = 0; i < nMorphTargetCount; ++i )
{
int nMorphTargetId = m_MorphDict.GetMorphTargetId( i );
m_MorphTargetIdToQuadIndex[nMorphTargetId] = i;
int nSegmentIndex = morphSegments.AddToTail();
MorphSegmentList_t &list = morphSegments[nSegmentIndex];
Assert( nSegmentIndex == i );
MorphSegment_t segment;
segment.m_nCount = 0;
int nVertexCount = m_MorphDict.GetMorphVertexCount( i );
int nLastDestIndex = -1;
for ( int j = 0; j < nVertexCount; ++j )
{
const MorphVertexInfo_t &info = m_MorphDict.GetMorphVertexInfo( i, j );
// Check for segment break conditions
if ( segment.m_nCount )
{
// Vertical overflow, non-contiguous destination verts, or contiguous dest
// verts which happen to lie in different columns are the break conditions
if ( ( nLastDestIndex < 0 ) || ( info.m_nVertexId > nLastDestIndex + MIN_SEGMENT_GAP_SIZE ) ||
( info.m_nVertexId / nDestTextureHeight != nLastDestIndex / nDestTextureHeight ) )
{
list.AddToTail( segment );
nLastDestIndex = -1;
}
}
// Start new segment, or append to existing segment
if ( nLastDestIndex < 0 )
{
segment.m_nFirstSrc = nSrcIndex;
segment.m_nFirstDest = info.m_nVertexId;
segment.m_nCount = 1;
++nSrcIndex;
}
else
{
int nSegmentCount = info.m_nVertexId - nLastDestIndex;
segment.m_nCount += nSegmentCount;
nSrcIndex += nSegmentCount;
}
nLastDestIndex = info.m_nVertexId;
}
// Add any trailing segment
if ( segment.m_nCount )
{
list.AddToTail( segment );
}
}
}
//-----------------------------------------------------------------------------
// Builds the list of quads to render
//-----------------------------------------------------------------------------
void CMorph::BuildQuadList( const CUtlVector< MorphSegmentList_t > &morphSegments )
{
m_MorphQuads.RemoveAll();
int nQuadIndex = 0;
int nMorphCount = morphSegments.Count();
for ( int i = 0; i < nMorphCount; ++i )
{
int k = m_MorphQuads.AddToTail();
MorphQuadList_t &quadList = m_MorphQuads[k];
const MorphSegmentList_t& segmentList = morphSegments[i];
int nSegmentCount = segmentList.Count();
for ( int j = 0; j < nSegmentCount; ++j )
{
const MorphSegment_t &segment = segmentList[j];
int nSrc = segment.m_nFirstSrc;
int nDest = segment.m_nFirstDest;
int nTotalCount = segment.m_nCount;
do
{
int sx = nSrc / m_nTextureHeight;
int sy = nSrc - sx * m_nTextureHeight;
int nMaxCount = m_nTextureHeight - sy;
int nCount = min( nMaxCount, nTotalCount );
nTotalCount -= nCount;
int l = quadList.AddToTail();
MorphQuad_t &quad = quadList[l];
quad.m_nQuadIndex = nQuadIndex++;
quad.m_nCount = nCount;
quad.m_nFirstSrc = nSrc;
quad.m_nFirstDest = nDest;
nSrc += nCount;
nDest += nCount;
} while ( nTotalCount > 0 );
}
}
}
//-----------------------------------------------------------------------------
// Counts the total number of vertices to place in the static mesh
//-----------------------------------------------------------------------------
int CMorph::CountStaticMeshVertices() const
{
// FIXME: I'm doing the simple thing here of 4 verts per segment.
// I believe I should be able to share any edge that isn't on the edges of the texture
// so I should be able to get down to nearly 2 (or is it 1?) verts per segment.
int nVertexCount = 0;
int nMorphCount = m_MorphQuads.Count();
for ( int i = 0; i < nMorphCount; ++i )
{
const MorphQuadList_t& quadList = m_MorphQuads[i];
nVertexCount += quadList.Count() * 4;
}
return nVertexCount;
}
//-----------------------------------------------------------------------------
// Determines mesh vertex format
//-----------------------------------------------------------------------------
VertexFormat_t CMorph::ComputeVertexFormat( IMaterial * pMaterial ) const
{
// We believe this material's vertex format is reliable (unlike many others as of June 07)
VertexFormat_t vertexFormat = pMaterial->GetVertexFormat();
// UNDONE: optimize the vertex format to compress or remove elements where possible
vertexFormat &= ~VERTEX_FORMAT_COMPRESSED;
return vertexFormat;
}
//-----------------------------------------------------------------------------
// Builds the list of segments to render
//-----------------------------------------------------------------------------
void CMorph::CreateStaticMesh()
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
m_MorphAccumulationMaterial->Refresh();
VertexFormat_t vertexFormat = ComputeVertexFormat( m_MorphAccumulationMaterial );
m_pMorphBuffer = pRenderContext->CreateStaticMesh( vertexFormat, TEXTURE_GROUP_MORPH_TARGETS, m_MorphAccumulationMaterial );
int nVertexCount = CountStaticMeshVertices();
if ( nVertexCount >= 65535 )
{
Warning( "Too many morph vertices! Call brian\n" );
}
Assert( nVertexCount < 65535 );
int n4TupleCount = Get4TupleCount( m_Format );
float flOOTexWidth = 1.0f / ( n4TupleCount * m_nTextureWidth );
float flOOTexHeight = 1.0f / m_nTextureHeight;
int nDestTextureWidth, nDestTextureHeight;
s_MorphMgr.GetAccumulatorSubrectDimensions( &nDestTextureWidth, &nDestTextureHeight );
float flOODestWidth = 1.0f / nDestTextureWidth;
float flOODestHeight = 1.0f / nDestTextureHeight;
// NOTE: zero index count implies no index buffer
CMeshBuilder meshBuilder;
meshBuilder.Begin( m_pMorphBuffer, MATERIAL_TRIANGLES, nVertexCount, 0 );
int nMorphCount = m_MorphQuads.Count();
for ( int i = 0; i < nMorphCount; ++i )
{
MorphQuadList_t& quadList = m_MorphQuads[i];
int nQuadCount = quadList.Count();
for ( int j = 0; j < nQuadCount; ++j )
{
MorphQuad_t &quad = quadList[j];
int sx = quad.m_nFirstSrc / m_nTextureHeight;
int sy = quad.m_nFirstSrc - sx * m_nTextureHeight;
int dx = quad.m_nFirstDest / nDestTextureHeight;
int dy = quad.m_nFirstDest - dx * nDestTextureHeight;
sx *= n4TupleCount; dx *= n4TupleCount;
meshBuilder.TexCoord4f( 0, sx * flOOTexWidth, sy * flOOTexHeight,
( dx - 0.5f ) * flOODestWidth, ( dy - 0.5f ) * flOODestHeight ); // Stores the source to read from
meshBuilder.TexCoord1f( 1, i );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord4f( 0, sx * flOOTexWidth, ( sy + quad.m_nCount ) * flOOTexHeight,
( dx - 0.5f ) * flOODestWidth, ( dy + quad.m_nCount - 0.5f ) * flOODestHeight ); // Stores the source to read from
meshBuilder.TexCoord1f( 1, i );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord4f( 0, (sx + n4TupleCount) * flOOTexWidth, ( sy + quad.m_nCount ) * flOOTexHeight,
( dx + n4TupleCount - 0.5f ) * flOODestWidth, ( dy + quad.m_nCount - 0.5f ) * flOODestHeight ); // Stores the source to read from
meshBuilder.TexCoord1f( 1, i );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord4f( 0, (sx + n4TupleCount) * flOOTexWidth, sy * flOOTexHeight,
( dx + n4TupleCount - 0.5f ) * flOODestWidth, ( dy - 0.5f ) * flOODestHeight ); // Stores the source to read from
meshBuilder.TexCoord1f( 1, i );
meshBuilder.AdvanceVertex();
}
}
meshBuilder.End();
}
//-----------------------------------------------------------------------------
// Inherited from ITextureRegenerator
//-----------------------------------------------------------------------------
void CMorph::RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect )
{
Assert( pVTFTexture->FrameCount() == 1 && pVTFTexture->FaceCount() == 1 );
Assert( pVTFTexture->Height() == m_nTextureHeight );
int nTextureType;
for ( nTextureType = 0; nTextureType < MORPH_TEXTURE_COUNT; ++nTextureType )
{
if ( pTexture == m_pMorphTexture[nTextureType] )
break;
}
Assert( nTextureType < MORPH_TEXTURE_COUNT );
MorphPixelWriter_t pWriteFuncs[MORPH_TEXTURE_COUNT] =
{
&CMorph::WriteDeltaPositionNormalToTexture,
&CMorph::WriteSideSpeedToTexture,
};
MorphPixelWriter_t writeFunc = pWriteFuncs[nTextureType];
CPixelWriter pixelWriter;
pixelWriter.SetPixelMemory( pVTFTexture->Format(), pVTFTexture->ImageData(), pVTFTexture->RowSizeInBytes( 0 ) );
// Clear the buffer
MorphVertexInfo_t zeroDelta;
zeroDelta.m_PositionDelta.Init();
zeroDelta.m_NormalDelta.Init();
zeroDelta.m_flWrinkleDelta = 0.0f;
zeroDelta.m_flSpeed = 1.0f;
zeroDelta.m_flSide = 0.5f;
int nWidth = pVTFTexture->Width() / Get4TupleCount( m_Format );
int nHeight = pVTFTexture->Height();
for ( int i = 0; i < nHeight; ++i )
{
for ( int j = 0; j < nWidth; ++j )
{
(this->*writeFunc)( pixelWriter, j, i, zeroDelta );
}
}
int nQuadListCount = m_MorphQuads.Count();
for ( int i = 0; i < nQuadListCount; ++i )
{
MorphQuadList_t &quadList = m_MorphQuads[i];
int nQuadCount = quadList.Count();
int nVertIndex = 0;
for ( int j = 0; j < nQuadCount; ++j )
{
MorphQuad_t &quad = quadList[j];
int sx = quad.m_nFirstSrc / m_nTextureHeight;
int sy = quad.m_nFirstSrc - sx * m_nTextureHeight;
int nDest = quad.m_nFirstDest;
for ( int k = 0; k < quad.m_nCount; ++k )
{
const MorphVertexInfo_t &info = m_MorphDict.GetMorphVertexInfo( i, nVertIndex );
if ( info.m_nVertexId > nDest )
{
(this->*writeFunc)( pixelWriter, sx, sy+k, zeroDelta );
}
else
{
(this->*writeFunc)( pixelWriter, sx, sy+k, info );
++nVertIndex;
}
++nDest;
}
}
}
}
//-----------------------------------------------------------------------------
// Deals with morph stats
//-----------------------------------------------------------------------------
static ConVar mat_morphstats( "mat_morphstats", "0", FCVAR_CHEAT );
static CUtlVector<int> s_ActiveMorphHisto;
static CUtlVector<int> s_RenderedQuadHisto;
static CUtlVector<int> s_RenderedTexelHisto;
static int s_nStatFrameCount = 0;
static int s_nStatMorphCount = 0;
static int s_nTotalMorphCount = 0;
static int s_nTotalQuadCount = 0;
static int s_nTotalTexelCount = 0;
void CMorph::ClearMorphStats()
{
s_ActiveMorphHisto.Purge();
s_RenderedQuadHisto.Purge();
s_RenderedTexelHisto.Purge();
s_nStatFrameCount = 0;
s_nTotalMorphCount = 0;
s_nTotalQuadCount = 0;
s_nTotalTexelCount = 0;
}
void CMorph::AccumulateMorphStats( int nActiveMorphCount, int nQuadsRendered, int nTexelsRendered )
{
while ( nActiveMorphCount >= s_ActiveMorphHisto.Count() )
{
s_ActiveMorphHisto.AddToTail( 0 );
}
while ( nQuadsRendered >= s_RenderedQuadHisto.Count() )
{
s_RenderedQuadHisto.AddToTail( 0 );
}
while ( nTexelsRendered >= s_RenderedTexelHisto.Count() )
{
s_RenderedTexelHisto.AddToTail( 0 );
}
s_ActiveMorphHisto[nActiveMorphCount] += 1;
s_RenderedQuadHisto[nQuadsRendered] += 1;
s_RenderedTexelHisto[nTexelsRendered] += 1;
s_nStatMorphCount++;
s_nTotalMorphCount += nActiveMorphCount;
s_nTotalQuadCount += nQuadsRendered;
s_nTotalTexelCount += nTexelsRendered;
}
void CMorph::ReportMorphStats( )
{
Msg( "Morph stats:\n" );
if ( s_nStatMorphCount == 0 )
{
Msg( "\tNo morphing done\n" );
return;
}
Msg( "\tAverage # of active morph targets per mesh group: %d\n", s_nTotalMorphCount / s_nStatMorphCount );
Msg( "\tAverage # of actual quad draws per morph: %d\n", s_nTotalQuadCount / s_nStatMorphCount );
Msg( "\tAverage # of actual rendered texels per morph: %d\n", s_nTotalTexelCount / s_nStatMorphCount );
Msg( "\tRendered Quad Count Histogram :\n\t\t" );
for ( int i = 0; i < s_RenderedQuadHisto.Count(); ++i )
{
if ( s_RenderedQuadHisto[i] == 0 )
continue;
Msg( "[%d : %d] ", i, s_RenderedQuadHisto[i] );
}
Msg( "\n\tRendered Texel Count Histogram :\n\t\t" );
for ( int i = 0; i < s_RenderedTexelHisto.Count(); ++i )
{
if ( s_RenderedTexelHisto[i] == 0 )
continue;
Msg( "[%d : %d] ", i, s_RenderedTexelHisto[i] );
}
Msg( "\n\tActive morph target Count Histogram :\n\t\t" );
for ( int i = 0; i < s_ActiveMorphHisto.Count(); ++i )
{
if ( s_ActiveMorphHisto[i] == 0 )
continue;
Msg( "[%d : %d] ", i, s_ActiveMorphHisto[i] );
}
Msg( "\n" );
}
void CMorph::HandleMorphStats( int nActiveMorphCount, int nQuadsRendered, int nTexelsRendered )
{
static bool s_bLastMorphStats = false;
bool bDoStats = mat_morphstats.GetInt() != 0;
if ( bDoStats )
{
if ( !s_bLastMorphStats )
{
ClearMorphStats();
}
AccumulateMorphStats( nActiveMorphCount, nQuadsRendered, nTexelsRendered );
}
else
{
if ( s_bLastMorphStats )
{
ReportMorphStats();
ClearMorphStats();
}
}
s_bLastMorphStats = bDoStats;
}
//-----------------------------------------------------------------------------
// Renders to the morph accumulator texture
//-----------------------------------------------------------------------------
void CMorph::RenderMorphQuads( IMatRenderContext *pRenderContext, int nRenderId, int nTotalQuadCount, int nWeightCount, int *pWeightLookup, const MorphWeight_t* pWeights )
{
if ( s_MorphMgr.IsUsingConstantRegisters() )
{
pRenderContext->SetFlexWeights( 0, m_nMaxMorphTargetCount, m_pRenderMorphWeight );
}
else
{
BindMorphWeight( nRenderId );
}
int nXOffset, nYOffset, nWidth, nHeight;
s_MorphMgr.ComputeAccumulatorSubrect( &nXOffset, &nYOffset, &nWidth, &nHeight, nRenderId );
pRenderContext->Viewport( nXOffset, nYOffset, nWidth, nHeight );
CMeshBuilder meshBuilder;
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, m_pMorphBuffer );
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, 0, nTotalQuadCount * 6 );
#ifdef REPORT_MORPH_STATS
int nTexelsRendered = 0;
#endif
for ( int i = 0; i < nWeightCount; ++i )
{
int nMorphIndex = m_MorphTargetIdToQuadIndex[ pWeightLookup[i] ];
if ( nMorphIndex < 0 )
continue;
const MorphQuadList_t& quadList = m_MorphQuads[nMorphIndex];
int nQuadCount = quadList.Count();
for ( int j = 0; j < nQuadCount; ++j )
{
const MorphQuad_t &quad = quadList[j];
#ifdef _DEBUG
static int s_nMinDest = -1, s_nMaxDest = -1;
if ( s_nMinDest >= 0 && quad.m_nFirstDest + quad.m_nCount <= s_nMinDest )
continue;
if ( s_nMaxDest >= 0 && quad.m_nFirstDest > s_nMaxDest )
continue;
#endif
#ifdef REPORT_MORPH_STATS
nTexelsRendered += n4TupleCount * quad.m_nCount;
#endif
int nBaseIndex = quad.m_nQuadIndex * 4;
meshBuilder.FastIndex( nBaseIndex );
meshBuilder.FastIndex( nBaseIndex+1 );
meshBuilder.FastIndex( nBaseIndex+2 );
meshBuilder.FastIndex( nBaseIndex );
meshBuilder.FastIndex( nBaseIndex+2 );
meshBuilder.FastIndex( nBaseIndex+3 );
}
}
meshBuilder.End();
pMesh->Draw();
#ifdef REPORT_MORPH_STATS
HandleMorphStats( nWeightCount, nTotalQuadCount, nTexelsRendered );
#endif
}
//-----------------------------------------------------------------------------
// Should a morph weight be treated as zero
//-----------------------------------------------------------------------------
static inline bool IsMorphWeightZero( const MorphWeight_t &weight )
{
return ( FloatMakePositive( weight.m_pWeight[MORPH_WEIGHT] ) < 0.001 &&
FloatMakePositive( weight.m_pWeight[MORPH_WEIGHT_LAGGED] ) < 0.001 &&
FloatMakePositive( weight.m_pWeight[MORPH_WEIGHT_STEREO] ) < 0.001 &&
FloatMakePositive( weight.m_pWeight[MORPH_WEIGHT_STEREO_LAGGED] ) < 0.001 );
}
//-----------------------------------------------------------------------------
// Builds a list of non-zero morph targets
//-----------------------------------------------------------------------------
int CMorph::BuildNonZeroMorphList( int *pWeightIndices, int nWeightCount, const MorphWeight_t* pWeights )
{
int nWeightIndexCount = 0;
for ( int i = 0; i < m_nMaxMorphTargetCount; ++i )
{
const MorphWeight_t& weight = pWeights[i];
// Don't bother with weights that aren't represented in the morph
if ( m_MorphTargetIdToQuadIndex[i] < 0 )
continue;
// Don't bother with small weights
if ( IsMorphWeightZero( weight ) )
continue;
pWeightIndices[nWeightIndexCount++] = i;
}
return nWeightIndexCount;
}
//-----------------------------------------------------------------------------
// Renders to the morph weight texture
//-----------------------------------------------------------------------------
bool CMorph::RenderMorphWeights( IMatRenderContext *pRenderContext, int nRenderId, int nWeightCount, const MorphWeight_t* pWeights )
{
VPROF_BUDGET( "CMorph::RenderMorphWeights", _T("HW Morphing") );
if ( m_nMaxMorphTargetCount == 0 )
return false;
// Cache off the weights, we need them when we accumulate the morphs later.
int nCountToCopy = min( nWeightCount, m_nMaxMorphTargetCount );
memcpy( m_pRenderMorphWeight, pWeights, nCountToCopy * sizeof(MorphWeight_t) );
int nCountToClear = m_nMaxMorphTargetCount - nWeightCount;
if ( nCountToClear > 0 )
{
memset( &m_pRenderMorphWeight[nCountToCopy], 0, nCountToClear * sizeof(MorphWeight_t) );
}
int *pWeightIndices = (int*)_alloca( nCountToCopy * sizeof(int) );
int nIndexCount = BuildNonZeroMorphList( pWeightIndices, nCountToCopy, pWeights );
if ( nIndexCount == 0 )
return false;
if ( s_MorphMgr.IsUsingConstantRegisters() )
return true;
int x, y, w, h;
s_MorphMgr.ComputeWeightSubrect( &x, &y, &w, &h, nRenderId );
ITexture *pMorphWeightTexture = s_MorphMgr.MorphWeights();
int nWidth = pMorphWeightTexture->GetActualWidth();
int nHeight = pMorphWeightTexture->GetActualHeight();
float flOOWidth = ( nWidth != 0 ) ? 1.0f / nWidth : 1.0f;
float flOOHeight = ( nHeight != 0 ) ? 1.0f / nHeight : 1.0f;
// Render the weights into the morph weight texture
CMeshBuilder meshBuilder;
IMesh *pMesh = pRenderContext->GetDynamicMesh( );
meshBuilder.Begin( pMesh, MATERIAL_POINTS, nCountToCopy );
for ( int i = 0; i < nIndexCount; ++i )
{
int nMorphId = pWeightIndices[i];
const MorphWeight_t& weight = pWeights[ nMorphId ];
int nLocalX = nMorphId / h;
int nLocalY = nMorphId - nLocalX * h;
meshBuilder.TexCoord2f( 0, ( nLocalX + x ) * flOOWidth, ( nLocalY + y ) * flOOHeight );
meshBuilder.TexCoord4fv( 1, weight.m_pWeight );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
return true;
}
//-----------------------------------------------------------------------------
// This will generate an accumulated morph target based on the passed-in weights
//-----------------------------------------------------------------------------
void CMorph::AccumulateMorph( int nRenderId )
{
VPROF_BUDGET( "CMorph::AccumulateMorph", _T("HW Morphing") );
// Build a non-zero weight list and a total quad count
int *pTargets = (int*)_alloca( m_nMaxMorphTargetCount * sizeof(int) );
int nTargetCount = BuildNonZeroMorphList( pTargets, m_nMaxMorphTargetCount, m_pRenderMorphWeight );
// Count the total number of quads to draw
int nTotalQuadCount = 0;
for ( int i = 0; i < nTargetCount; ++i )
{
int nMorphIndex = m_MorphTargetIdToQuadIndex[ pTargets[i] ];
if ( nMorphIndex < 0 )
continue;
const MorphQuadList_t& quadList = m_MorphQuads[ nMorphIndex ];
nTotalQuadCount += quadList.Count();
}
// Clear the morph accumulator
// FIXME: Can I avoid even changing the render target if I know the last time
// the morph accumulator was used that it was also cleared to black? Yes, but
// I need to deal with alt-tab.
bool bRenderQuads = ( nTotalQuadCount != 0 ) && ( m_nTextureWidth != 0 ) && ( m_nTextureHeight != 0 );
if ( !bRenderQuads )
return;
// Next, iterate over all non-zero morphs and add them in.
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->Bind( m_MorphAccumulationMaterial );
RenderMorphQuads( pRenderContext, nRenderId, nTotalQuadCount, nTargetCount, pTargets, m_pRenderMorphWeight );
}
//-----------------------------------------------------------------------------
//
// Morph mgr render context
//
//-----------------------------------------------------------------------------
CMorphMgrRenderContext::CMorphMgrRenderContext()
{
m_nMorphCount = 0;
#ifdef DBGFLAG_ASSERT
m_bInMorphAccumulation = false;
#endif
}
int CMorphMgrRenderContext::GetRenderId( CMorph* pMorph )
{
// FIXME: This could be done without all these comparisons, at the cost of memory + complexity.
// NOTE: m_nMorphCount <= 4.
for ( int i = 0; i < m_nMorphCount; ++i )
{
if ( m_pMorphsToAccumulate[i] == pMorph )
return i;
}
return -1;
}
//-----------------------------------------------------------------------------
//
// Morph manager implementation starts here
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CMorphMgr::CMorphMgr()
{
m_pMorphAccumTexture = NULL;
m_pMorphWeightTexture = NULL;
m_pVisualizeMorphAccum = NULL;
m_pVisualizeMorphWeight = NULL;
m_pRenderMorphWeight = NULL;
m_nFrameCount = 0;
m_nTotalMorphSizeInBytes = 0;
m_bUsingConstantRegisters = false;
}
//-----------------------------------------------------------------------------
// Should we allocate textures?
//-----------------------------------------------------------------------------
bool CMorphMgr::ShouldAllocateScratchTextures()
{
return g_pMaterialSystemHardwareConfig->HasFastVertexTextures();
}
//-----------------------------------------------------------------------------
// Allocates scratch textures used in hw morphing
//-----------------------------------------------------------------------------
void CMorphMgr::AllocateScratchTextures()
{
// Debug using 32323232F because we can read that back reasonably.
#ifdef _DEBUG
ImageFormat fmt = IMAGE_FORMAT_RGBA32323232F;
#else
ImageFormat fmt = IMAGE_FORMAT_RGBA16161616F;
#endif
// NOTE: I'm not writing code to compute an appropriate width and height
// given a MAX_MORPH_ACCUMULATOR_VERTICES and MORPH_ACCUMULATOR_4TUPLES
// because this will rarely change. Just hard code it to something that will fit it.
m_nAccumulatorWidth = 256;
m_nAccumulatorHeight = 256;
Assert( m_nAccumulatorWidth * m_nAccumulatorHeight == MAX_MORPH_ACCUMULATOR_VERTICES * MORPH_ACCUMULATOR_4TUPLES );
Assert( IsPowerOfTwo( CMorphMgrRenderContext::MAX_MODEL_MORPHS ) );
int nMultFactor = sqrt( (float)CMorphMgrRenderContext::MAX_MODEL_MORPHS );
m_nSubrectVerticalCount = nMultFactor;
m_pMorphAccumTexture = TextureManager()->CreateRenderTargetTexture( "_rt_MorphAccumulator",
m_nAccumulatorWidth * nMultFactor, m_nAccumulatorHeight * nMultFactor,
RT_SIZE_OFFSCREEN, fmt, RENDER_TARGET_NO_DEPTH,
TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_NOLOD | TEXTUREFLAGS_NODEBUGOVERRIDE |
TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_POINTSAMPLE | TEXTUREFLAGS_VERTEXTEXTURE,
0 );
m_pMorphAccumTexture->IncrementReferenceCount();
int nDim = (int)sqrt( (float)MAXSTUDIOFLEXDESC );
while( nDim * nDim < MAXSTUDIOFLEXDESC )
{
++nDim;
}
m_nWeightWidth = m_nWeightHeight = nDim;
// FIXME: Re-enable if NVidia gets a fast implementation using more shader constants
m_bUsingConstantRegisters = false; //( g_pMaterialSystemHardwareConfig->NumVertexShaderConstants() >= VERTEX_SHADER_FLEX_WEIGHTS + VERTEX_SHADER_MAX_FLEX_WEIGHT_COUNT );
if ( !m_bUsingConstantRegisters )
{
m_pMorphWeightTexture = TextureManager()->CreateRenderTargetTexture( "_rt_MorphWeight",
m_nWeightWidth * nMultFactor, m_nWeightHeight * nMultFactor,
RT_SIZE_OFFSCREEN, fmt, RENDER_TARGET_NO_DEPTH,
TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_NOLOD | TEXTUREFLAGS_NODEBUGOVERRIDE |
TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_POINTSAMPLE,
0 );
m_pMorphWeightTexture->IncrementReferenceCount();
}
}
void CMorphMgr::FreeScratchTextures()
{
if ( m_pMorphAccumTexture )
{
m_pMorphAccumTexture->DecrementReferenceCount();
m_pMorphAccumTexture->DeleteIfUnreferenced();
m_pMorphAccumTexture = NULL;
}
if ( m_pMorphWeightTexture )
{
m_pMorphWeightTexture->DecrementReferenceCount();
m_pMorphWeightTexture->DeleteIfUnreferenced();
m_pMorphWeightTexture = NULL;
}
}
//-----------------------------------------------------------------------------
// Allocates, frees materials used in hw morphing
//-----------------------------------------------------------------------------
void CMorphMgr::AllocateMaterials()
{
KeyValues *pVMTKeyValues = new KeyValues( "debugmorphaccumulator" );
pVMTKeyValues->SetString( "$basetexture", "_rt_MorphAccumulator" );
pVMTKeyValues->SetString( "$nocull", "1" );
pVMTKeyValues->SetString( "$ignorez", "1" );
m_pVisualizeMorphAccum = g_pMaterialSystem->CreateMaterial( "___visualizeMorphAccum.vmt", pVMTKeyValues );
if ( !m_bUsingConstantRegisters )
{
pVMTKeyValues = new KeyValues( "morphweight" );
pVMTKeyValues->SetString( "$model", "0" );
pVMTKeyValues->SetString( "$nocull", "1" );
pVMTKeyValues->SetString( "$ignorez", "1" );
m_pRenderMorphWeight = g_pMaterialSystem->CreateMaterial( "___morphweight.vmt", pVMTKeyValues );
pVMTKeyValues = new KeyValues( "debugmorphaccumulator" );
pVMTKeyValues->SetString( "$basetexture", "_rt_MorphWeight" );
pVMTKeyValues->SetString( "$nocull", "1" );
pVMTKeyValues->SetString( "$ignorez", "1" );
m_pVisualizeMorphWeight = g_pMaterialSystem->CreateMaterial( "___visualizeMorphWeight.vmt", pVMTKeyValues );
}
}
void CMorphMgr::FreeMaterials()
{
if ( m_pVisualizeMorphAccum )
{
m_pVisualizeMorphAccum->DecrementReferenceCount();
m_pVisualizeMorphAccum->DeleteIfUnreferenced();
m_pVisualizeMorphAccum = NULL;
}
if ( m_pVisualizeMorphWeight )
{
m_pVisualizeMorphWeight->DecrementReferenceCount();
m_pVisualizeMorphWeight->DeleteIfUnreferenced();
m_pVisualizeMorphWeight = NULL;
}
if ( m_pRenderMorphWeight )
{
m_pRenderMorphWeight->DecrementReferenceCount();
m_pRenderMorphWeight->DeleteIfUnreferenced();
m_pRenderMorphWeight = NULL;
}
}
//-----------------------------------------------------------------------------
// Morph render context
//-----------------------------------------------------------------------------
IMorphMgrRenderContext *CMorphMgr::AllocateRenderContext()
{
return new CMorphMgrRenderContext;
}
void CMorphMgr::FreeRenderContext( IMorphMgrRenderContext *pRenderContext )
{
delete static_cast< CMorphMgrRenderContext* >( pRenderContext );
}
//-----------------------------------------------------------------------------
// Returns the morph accumulation texture
//-----------------------------------------------------------------------------
ITextureInternal *CMorphMgr::MorphAccumulator()
{
return m_pMorphAccumTexture;
}
ITextureInternal *CMorphMgr::MorphWeights()
{
return m_pMorphWeightTexture;
}
//-----------------------------------------------------------------------------
// Class factory
//-----------------------------------------------------------------------------
IMorphInternal *CMorphMgr::CreateMorph()
{
return new CMorph;
}
void CMorphMgr::DestroyMorph( IMorphInternal *pMorphData )
{
if ( pMorphData )
{
delete static_cast< CMorph*>( pMorphData );
}
}
//-----------------------------------------------------------------------------
// Advances the frame (for debugging)
//-----------------------------------------------------------------------------
void CMorphMgr::AdvanceFrame()
{
++m_nFrameCount;
}
//-----------------------------------------------------------------------------
// Computes texel offsets for the upper corner of the morph weight texture for a particular block
//-----------------------------------------------------------------------------
void CMorphMgr::ComputeWeightSubrect( int *pXOffset, int *pYOffset, int *pWidth, int *pHeight, int nMorphAccumBlockId )
{
*pXOffset = nMorphAccumBlockId / m_nSubrectVerticalCount;
*pYOffset = nMorphAccumBlockId - m_nSubrectVerticalCount * (*pXOffset);
*pXOffset *= m_nWeightWidth;
*pYOffset *= m_nWeightHeight;
*pWidth = m_nWeightWidth;
*pHeight = m_nWeightHeight;
}
//-----------------------------------------------------------------------------
// Computes texel offsets for the upper corner of the morph accumulator for a particular block
//-----------------------------------------------------------------------------
void CMorphMgr::ComputeAccumulatorSubrect( int *pXOffset, int *pYOffset, int *pWidth, int *pHeight, int nMorphAccumBlockId )
{
*pXOffset = nMorphAccumBlockId / m_nSubrectVerticalCount;
*pYOffset = nMorphAccumBlockId - m_nSubrectVerticalCount * (*pXOffset);
*pXOffset *= m_nAccumulatorWidth;
*pYOffset *= m_nAccumulatorHeight;
*pWidth = m_nAccumulatorWidth;
*pHeight = m_nAccumulatorHeight;
}
void CMorphMgr::GetAccumulatorSubrectDimensions( int *pWidth, int *pHeight )
{
*pWidth = m_nAccumulatorWidth;
*pHeight = m_nAccumulatorHeight;
}
int CMorphMgr::GetAccumulator4TupleCount() const
{
return MORPH_ACCUMULATOR_4TUPLES;
}
//-----------------------------------------------------------------------------
// Used to compute stats of memory used
//-----------------------------------------------------------------------------
CON_COMMAND_F( mat_reporthwmorphmemory, "Reports the amount of size in bytes taken up by hardware morph textures.", FCVAR_CHEAT )
{
ConMsg( "Total HW Morph memory used: %dk\n", s_MorphMgr.GetTotalMemoryUsage() /1024 );
}
void CMorphMgr::RegisterMorphSizeInBytes( int nSizeInBytes )
{
m_nTotalMorphSizeInBytes += nSizeInBytes;
Assert( m_nTotalMorphSizeInBytes >= 0 );
}
int CMorphMgr::GetTotalMemoryUsage() const
{
int nSize = 0;
if ( m_pMorphAccumTexture )
{
nSize += m_pMorphAccumTexture->GetActualWidth() * m_pMorphAccumTexture->GetActualHeight() *
ImageLoader::SizeInBytes( m_pMorphAccumTexture->GetImageFormat() );
}
if ( m_pMorphWeightTexture )
{
nSize += m_pMorphWeightTexture->GetActualWidth() * m_pMorphWeightTexture->GetActualHeight() *
ImageLoader::SizeInBytes( m_pMorphWeightTexture->GetImageFormat() );
}
nSize += m_nTotalMorphSizeInBytes;
return nSize;
}
//-----------------------------------------------------------------------------
// Displays 32bit float texture data
//-----------------------------------------------------------------------------
void CMorphMgr::Display32FTextureData( float *pBuf, int nTexelID, int *pSubRect, ITexture *pTexture, int n4TupleCount )
{
int nColumn = nTexelID / pSubRect[3];
int nRow = nTexelID - nColumn * pSubRect[3];
nColumn *= n4TupleCount;
nColumn += pSubRect[0];
nRow += pSubRect[1];
Msg( "[%d] : ", nTexelID );
for ( int i = 0; i < n4TupleCount; ++i )
{
float *pBase = &pBuf[ (nRow * pTexture->GetActualWidth() + nColumn + i ) * 4 ];
Msg( "[ %.4f %.4f %.4f %.4f ] ", pBase[0], pBase[1], pBase[2], pBase[3] );
}
Msg( "\n" );
}
//-----------------------------------------------------------------------------
// A debugging utility to display the morph accumulator
//-----------------------------------------------------------------------------
void CMorphMgr::DebugMorphAccumulator( IMatRenderContext *pRenderContext )
{
static bool s_bDebug = false;
if ( !s_bDebug )
return;
ITexture *pDest = g_pMorphMgr->MorphAccumulator( );
if ( pDest->GetImageFormat() != IMAGE_FORMAT_RGBA32323232F )
return;
int nDestWidth = pDest->GetActualWidth();
int nDestHeight = pDest->GetActualHeight();
float* pBuf = (float*)malloc( nDestWidth * nDestHeight * 4 * sizeof(float) );
pRenderContext->ReadPixels( 0, 0, nDestWidth, nDestHeight, (unsigned char*)pBuf, IMAGE_FORMAT_RGBA32323232F );
Msg( "Morph Accumulator:\n" );
static int s_nMinDisplay = 0;
static int s_nMaxDisplay = -1;
static int s_nMorphIndex = 0;
int pSubRect[4];
ComputeAccumulatorSubrect( &pSubRect[0], &pSubRect[1], &pSubRect[2], &pSubRect[3], s_nMorphIndex );
if ( s_nMaxDisplay < 0 )
{
Display32FTextureData( pBuf, s_nMinDisplay, pSubRect, pDest, MORPH_ACCUMULATOR_4TUPLES );
}
else
{
for ( int i = s_nMinDisplay; i <= s_nMaxDisplay; ++i )
{
Display32FTextureData( pBuf, i, pSubRect, pDest, MORPH_ACCUMULATOR_4TUPLES );
}
}
free( pBuf );
}
//-----------------------------------------------------------------------------
// A debugging utility to display the morph weights
//-----------------------------------------------------------------------------
void CMorphMgr::DebugMorphWeights( IMatRenderContext *pRenderContext )
{
static bool s_bDebug = false;
if ( !s_bDebug )
return;
ITexture *pTexture = MorphWeights();
int nWidth = pTexture->GetActualWidth();
int nHeight = pTexture->GetActualHeight();
if ( pTexture->GetImageFormat() != IMAGE_FORMAT_RGBA32323232F )
return;
pRenderContext->Flush();
float* pBuf = (float*)malloc( nWidth * nHeight * 4 * sizeof(float) );
pRenderContext->ReadPixels( 0, 0, nWidth, nHeight, (unsigned char*)pBuf, IMAGE_FORMAT_RGBA32323232F );
Msg( "Morph Weights:\n" );
static int s_nMinDisplay = 0;
static int s_nMaxDisplay = -1;
static int s_nMorphIndex = 0;
int pSubRect[4];
ComputeWeightSubrect( &pSubRect[0], &pSubRect[1], &pSubRect[2], &pSubRect[3], s_nMorphIndex );
if ( s_nMaxDisplay < 0 )
{
Display32FTextureData( pBuf, s_nMinDisplay, pSubRect, pTexture, 1 );
}
else
{
for ( int i = s_nMinDisplay; i <= s_nMaxDisplay; ++i )
{
Display32FTextureData( pBuf, i, pSubRect, pTexture, 1 );
}
}
free( pBuf );
}
//-----------------------------------------------------------------------------
// Draws the morph accumulator
//-----------------------------------------------------------------------------
#ifdef _DEBUG
ConVar mat_drawmorphaccumulator( "mat_drawmorphaccumulator", "0", FCVAR_CHEAT );
ConVar mat_drawmorphweights( "mat_drawmorphweights", "0", FCVAR_CHEAT );
#endif
void CMorphMgr::DrawMorphTempTexture( IMatRenderContext *pRenderContext, IMaterial *pMaterial, ITexture *pTexture )
{
pMaterial = ((IMaterialInternal *)pMaterial)->GetRealTimeVersion(); //always work with the real time version of materials internally.
static int s_nLastFrameCount = -1;
static int s_nX = 0, s_nY = 0;
if ( s_nLastFrameCount != m_nFrameCount )
{
s_nX = 0; s_nY = 0;
s_nLastFrameCount = m_nFrameCount;
}
pRenderContext->Flush();
int nWidth = pTexture->GetActualWidth();
int nHeight = pTexture->GetActualHeight();
::DrawScreenSpaceRectangle( pMaterial, s_nX, s_nY, nWidth, nHeight,
0, 0, nWidth-1, nHeight-1, nWidth, nHeight );
s_nX += nWidth;
if ( s_nX > 1024 )
{
s_nX = 0;
s_nY += nHeight;
}
pRenderContext->Flush();
}
//-----------------------------------------------------------------------------
// Starts, ends morph accumulation.
//-----------------------------------------------------------------------------
int CMorphMgr::MaxHWMorphBatchCount() const
{
return CMorphMgrRenderContext::MAX_MODEL_MORPHS;
}
//-----------------------------------------------------------------------------
// Returns the texcoord associated with a morph
//-----------------------------------------------------------------------------
bool CMorphMgr::GetMorphAccumulatorTexCoord( IMorphMgrRenderContext *pRenderContext, Vector2D *pTexCoord, IMorph *pMorph, int nVertex )
{
CMorphMgrRenderContext *pMorphRenderContext = static_cast< CMorphMgrRenderContext* >( pRenderContext );
int nRenderId = pMorphRenderContext->GetRenderId( static_cast<CMorph*>( pMorph ) );
if ( nRenderId < 0 )
{
pTexCoord->Init();
return false;
}
int nWidth = m_pMorphAccumTexture->GetActualWidth();
int nHeight = m_pMorphAccumTexture->GetActualHeight();
if ( !nWidth || !nHeight )
{
pTexCoord->Init();
return false;
}
float flOOWidth = ( nWidth != 0 ) ? 1.0f / nWidth : 1.0f;
float flOOHeight = ( nHeight != 0 ) ? 1.0f / nHeight : 1.0f;
int x, y, w, h;
ComputeAccumulatorSubrect( &x, &y, &w, &h, nRenderId );
int nColumn = nVertex / h;
int nRow = nVertex - h * nColumn;
nColumn *= MORPH_ACCUMULATOR_4TUPLES;
pTexCoord->x = ( x + nColumn + 0.5f ) * flOOWidth;
pTexCoord->y = ( y + nRow + 0.5f ) * flOOHeight;
Assert( IsFinite( pTexCoord->x ) && IsFinite( pTexCoord->y ) );
return true;
}
//-----------------------------------------------------------------------------
// Starts, ends morph accumulation.
//-----------------------------------------------------------------------------
void CMorphMgr::BeginMorphAccumulation( IMorphMgrRenderContext *pIRenderContext )
{
VPROF_BUDGET( "CMorph::BeginMorphAccumulation", _T("HW Morphing") );
// Set up the render context
CMorphMgrRenderContext *pMorphRenderContext = static_cast< CMorphMgrRenderContext* >( pIRenderContext );
Assert( !pMorphRenderContext->m_bInMorphAccumulation );
pMorphRenderContext->m_nMorphCount = 0;
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
IMatRenderContextInternal *pRenderContextInternal = static_cast<IMatRenderContextInternal*>( (IMatRenderContext*)pRenderContext );
// Cache off the current material and other render state
// NOTE: We always have to do this because pushing the morph accumulator
// may cause it to be unbound; therefore we must force a rebind of the material.
m_pPrevMaterial = pRenderContextInternal->GetCurrentMaterial();
m_pPrevProxy = pRenderContextInternal->GetCurrentProxy();
m_nPrevBoneCount = pRenderContextInternal->GetCurrentNumBones();
m_nPrevClipMode = pRenderContext->GetHeightClipMode( );
m_bPrevClippingEnabled = pRenderContext->EnableClipping( false );
m_bFlashlightMode = pRenderContext->GetFlashlightMode();
pRenderContext->SetHeightClipMode( MATERIAL_HEIGHTCLIPMODE_DISABLE );
pRenderContext->SetNumBoneWeights( 0 );
pRenderContext->SetFlashlightMode( false );
if ( !m_bUsingConstantRegisters )
{
// FIXME: We could theoretically avoid pushing this if we copied off all the
// weights and set the weight texture only at the end if any non-zero weights
// were sent down
pRenderContext->PushRenderTargetAndViewport( m_pMorphWeightTexture );
#ifdef _DEBUG
// NOTE: No need to clear the texture; we will only be reading out of that
// texture at points where we've rendered to in this pass.
// But, we'll do it for debugging reasons.
// I believe this pattern of weights is the least likely to occur naturally.
pRenderContext->ClearColor4ub( 0, 0, 0, 0 );
pRenderContext->ClearBuffers( true, false, false );
#endif
}
#ifdef DBGFLAG_ASSERT
pMorphRenderContext->m_bInMorphAccumulation = true;
#endif
}
void CMorphMgr::EndMorphAccumulation( IMorphMgrRenderContext *pIRenderContext )
{
VPROF_BUDGET( "CMorph::EndMorphAccumulation", _T("HW Morphing") );
CMorphMgrRenderContext *pMorphRenderContext = static_cast< CMorphMgrRenderContext* >( pIRenderContext );
Assert( pMorphRenderContext->m_bInMorphAccumulation );
VPROF_INCREMENT_COUNTER( "HW Morph Count", pMorphRenderContext->m_nMorphCount );
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
#ifdef _DEBUG
if ( !m_bUsingConstantRegisters )
{
DebugMorphWeights( pRenderContext );
}
#endif
// Now that all the weights have been rendered, accumulate the morphs
// First, clear the morph accumulation texture
int nWidth = m_pMorphAccumTexture->GetActualWidth();
int nHeight = m_pMorphAccumTexture->GetActualHeight();
if ( !m_bUsingConstantRegisters )
{
pRenderContext->SetRenderTargetEx( 0, m_pMorphAccumTexture );
pRenderContext->Viewport( 0, 0, nWidth, nHeight );
}
else
{
pRenderContext->PushRenderTargetAndViewport( m_pMorphAccumTexture );
}
pRenderContext->ClearColor4ub( 0, 0, 0, 0 );
pRenderContext->ClearBuffers( true, false, false );
for ( int i = 0; i < pMorphRenderContext->m_nMorphCount; ++i )
{
pMorphRenderContext->m_pMorphsToAccumulate[i]->AccumulateMorph( i );
}
#ifdef _DEBUG
DebugMorphAccumulator( pRenderContext );
#endif
pRenderContext->PopRenderTargetAndViewport();
#ifdef _DEBUG
if ( mat_drawmorphweights.GetInt() )
{
if ( !m_bUsingConstantRegisters )
{
DrawMorphTempTexture( pRenderContext, m_pVisualizeMorphWeight, MorphWeights( ) );
}
}
if ( mat_drawmorphaccumulator.GetInt() )
{
DrawMorphTempTexture( pRenderContext, m_pVisualizeMorphAccum, MorphAccumulator( ) );
}
#endif
pRenderContext->Bind( m_pPrevMaterial, m_pPrevProxy );
pRenderContext->SetNumBoneWeights( m_nPrevBoneCount );
pRenderContext->SetHeightClipMode( m_nPrevClipMode );
pRenderContext->EnableClipping( m_bPrevClippingEnabled );
pRenderContext->SetFlashlightMode( m_bFlashlightMode );
#ifdef DBGFLAG_ASSERT
pMorphRenderContext->m_bInMorphAccumulation = false;
#endif
}
//-----------------------------------------------------------------------------
// Accumulates a morph target into the morph texture
//-----------------------------------------------------------------------------
void CMorphMgr::AccumulateMorph( IMorphMgrRenderContext *pIRenderContext, IMorph* pMorph, int nMorphCount, const MorphWeight_t* pWeights )
{
CMorphMgrRenderContext *pMorphRenderContext = static_cast< CMorphMgrRenderContext* >( pIRenderContext );
Assert( pMorphRenderContext->m_bInMorphAccumulation );
Assert( pMorphRenderContext->m_nMorphCount < CMorphMgrRenderContext::MAX_MODEL_MORPHS );
if ( pMorphRenderContext->m_nMorphCount >= CMorphMgrRenderContext::MAX_MODEL_MORPHS )
{
Warning( "Attempted to morph too many meshes in a single model!\n" );
Assert(0);
return;
}
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
CMorph *pMorphInternal = static_cast<CMorph*>( pMorph );
if ( !m_bUsingConstantRegisters )
{
pRenderContext->Bind( m_pRenderMorphWeight );
}
if ( pMorphInternal->RenderMorphWeights( pRenderContext, pMorphRenderContext->m_nMorphCount, nMorphCount, pWeights ) )
{
pMorphRenderContext->m_pMorphsToAccumulate[pMorphRenderContext->m_nMorphCount] = pMorphInternal;
++pMorphRenderContext->m_nMorphCount;
}
}