2281 lines
73 KiB
C++
2281 lines
73 KiB
C++
//========= 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;
|
|
}
|
|
}
|
|
|