d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
98 Commits
25 Branches
6 Tags
221 MiB
Tree: 76bfcf40ca
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '76bfcf40ca'
${ noResults }
source-engine/studiorender/studiorendercontext.cpp

2455 lines
82 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include <stdlib.h>
#include "tier0/platform.h"
#include "studiorendercontext.h"
#include "optimize.h"
#include "materialsystem/imaterialvar.h"
#include "materialsystem/imesh.h"
#include "materialsystem/imorph.h"
#include "materialsystem/ivballoctracker.h"
#include "vstdlib/random.h"
#include "tier0/tslist.h"
#include "tier0/platform.h"
#include "tier1/refcount.h"
#include "tier1/callqueue.h"
#include "cmodel.h"
#include "tier0/vprof.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// garymcthack - this should go elsewhere
#define MAX_NUM_BONE_INDICES 4
//-----------------------------------------------------------------------------
// Toggles studio queued mode
//-----------------------------------------------------------------------------
void StudioChangeCallback( IConVar *var, const char *pOldValue, float flOldValue )
{
// NOTE: This is necessary to flush the queued thread when this value changes
MaterialLock_t hLock = g_pMaterialSystem->Lock();
g_pMaterialSystem->Unlock( hLock );
}
static ConVar studio_queue_mode( "studio_queue_mode", "1", 0, "", StudioChangeCallback );
//-----------------------------------------------------------------------------
// Globals
//-----------------------------------------------------------------------------
static float s_pZeroFlexWeights[MAXSTUDIOFLEXDESC];
//-----------------------------------------------------------------------------
// Singleton instance
//-----------------------------------------------------------------------------
IStudioDataCache *g_pStudioDataCache = NULL;
static CStudioRenderContext s_StudioRenderContext;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CStudioRenderContext, IStudioRender,
STUDIO_RENDER_INTERFACE_VERSION, s_StudioRenderContext );
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CStudioRenderContext::CStudioRenderContext()
{
// Initialize render context
m_RC.m_pForcedMaterial = NULL;
m_RC.m_nForcedMaterialType = OVERRIDE_NORMAL;
m_RC.m_ColorMod[0] = m_RC.m_ColorMod[1] = m_RC.m_ColorMod[2] = 1.0f;
m_RC.m_AlphaMod = 1.0f;
m_RC.m_ViewOrigin.Init();
m_RC.m_ViewRight.Init();
m_RC.m_ViewUp.Init();
m_RC.m_ViewPlaneNormal.Init();
m_RC.m_Config.m_bEnableHWMorph = true;
m_RC.m_Config.m_bStatsMode = false;
m_RC.m_NumLocalLights = 0;
for ( int i = 0; i < 6; ++i )
{
m_RC.m_LightBoxColors[i].Init( 0, 0, 0 );
}
}
CStudioRenderContext::~CStudioRenderContext()
{
}
//-----------------------------------------------------------------------------
// Connect, disconnect
//-----------------------------------------------------------------------------
bool CStudioRenderContext::Connect( CreateInterfaceFn factory )
{
if ( !BaseClass::Connect( factory ) )
return false;
g_pStudioDataCache = ( IStudioDataCache * )factory( STUDIO_DATA_CACHE_INTERFACE_VERSION, NULL );
if ( !g_pMaterialSystem || !g_pMaterialSystemHardwareConfig || !g_pStudioDataCache )
{
Msg("StudioRender failed to connect to a required system\n" );
}
return ( g_pMaterialSystem && g_pMaterialSystemHardwareConfig && g_pStudioDataCache );
}
void CStudioRenderContext::Disconnect()
{
g_pStudioDataCache = NULL;
BaseClass::Disconnect();
}
//-----------------------------------------------------------------------------
// Here's where systems can access other interfaces implemented by this object
// Returns NULL if it doesn't implement the requested interface
//-----------------------------------------------------------------------------
void *CStudioRenderContext::QueryInterface( const char *pInterfaceName )
{
// Loading the studiorender DLL mounts *all* interfaces
CreateInterfaceFn factory = Sys_GetFactoryThis(); // This silly construction is necessary
return factory( pInterfaceName, NULL ); // to prevent the LTCG compiler from crashing.
}
//-----------------------------------------------------------------------------
// Init, shutdown
//-----------------------------------------------------------------------------
InitReturnVal_t CStudioRenderContext::Init()
{
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
InitReturnVal_t nRetVal = BaseClass::Init();
if ( nRetVal != INIT_OK )
return nRetVal;
if( !g_pMaterialSystem || !g_pMaterialSystemHardwareConfig )
return INIT_FAILED;
return g_pStudioRenderImp->Init();
}
void CStudioRenderContext::Shutdown( void )
{
g_pStudioRenderImp->Shutdown();
BaseClass::Shutdown();
}
//-----------------------------------------------------------------------------
// Used to activate the stub material system.
//-----------------------------------------------------------------------------
void CStudioRenderContext::Mat_Stub( IMaterialSystem *pMatSys )
{
g_pMaterialSystem = pMatSys;
}
//-----------------------------------------------------------------------------
// Determines material flags
//-----------------------------------------------------------------------------
void CStudioRenderContext::ComputeMaterialFlags( studiohdr_t *phdr, studioloddata_t &lodData, IMaterial *pMaterial )
{
// requesting info forces the initial material precache (and its build out)
if ( pMaterial->UsesEnvCubemap() )
{
phdr->flags |= STUDIOHDR_FLAGS_USES_ENV_CUBEMAP;
}
if ( pMaterial->NeedsPowerOfTwoFrameBufferTexture( false ) ) // The false checks if it will ever need the frame buffer, not just this frame
{
phdr->flags |= STUDIOHDR_FLAGS_USES_FB_TEXTURE;
}
// FIXME: I'd rather know that the material is definitely using the bumpmap.
// It could be in the file without actually being used.
static unsigned int bumpvarCache = 0;
IMaterialVar *pBumpMatVar = pMaterial->FindVarFast( "$bumpmap", &bumpvarCache );
if ( pBumpMatVar && pBumpMatVar->IsDefined() && pMaterial->NeedsTangentSpace() )
{
phdr->flags |= STUDIOHDR_FLAGS_USES_BUMPMAPPING;
}
// Make sure material is treated as bump mapped if phong is set
static unsigned int phongVarCache = 0;
IMaterialVar *pPhongMatVar = pMaterial->FindVarFast( "$phong", &phongVarCache );
if ( pPhongMatVar && pPhongMatVar->IsDefined() && ( pPhongMatVar->GetIntValue() != 0 ) )
{
phdr->flags |= STUDIOHDR_FLAGS_USES_BUMPMAPPING;
}
}
//-----------------------------------------------------------------------------
// Does this material use a mouth shader?
//-----------------------------------------------------------------------------
static bool UsesMouthShader( IMaterial *pMaterial )
{
// FIXME: hack, needs proper client side material system interface
static unsigned int clientShaderCache = 0;
IMaterialVar *clientShaderVar = pMaterial->FindVarFast( "$clientShader", &clientShaderCache );
if ( clientShaderVar )
return ( Q_stricmp( clientShaderVar->GetStringValue(), "MouthShader" ) == 0 );
return false;
}
//-----------------------------------------------------------------------------
// Returns the actual texture name to use on the model
//-----------------------------------------------------------------------------
static const char *GetTextureName( studiohdr_t *phdr, OptimizedModel::FileHeader_t *pVtxHeader,
int lodID, int inMaterialID )
{
OptimizedModel::MaterialReplacementListHeader_t *materialReplacementList =
pVtxHeader->pMaterialReplacementList( lodID );
int i;
for( i = 0; i < materialReplacementList->numReplacements; i++ )
{
OptimizedModel::MaterialReplacementHeader_t *materialReplacement =
materialReplacementList->pMaterialReplacement( i );
if( materialReplacement->materialID == inMaterialID )
{
const char *str = materialReplacement->pMaterialReplacementName();
return str;
}
}
return phdr->pTexture( inMaterialID )->pszName();
}
//-----------------------------------------------------------------------------
// Loads materials associated with a particular LOD of a model
//-----------------------------------------------------------------------------
void CStudioRenderContext::LoadMaterials( studiohdr_t *phdr,
OptimizedModel::FileHeader_t *pVtxHeader, studioloddata_t &lodData, int lodID )
{
typedef IMaterial *IMaterialPtr;
Assert( phdr );
lodData.numMaterials = phdr->numtextures;
if ( lodData.numMaterials == 0 )
{
lodData.ppMaterials = NULL;
return;
}
lodData.ppMaterials = new IMaterialPtr[lodData.numMaterials];
Assert( lodData.ppMaterials );
lodData.pMaterialFlags = new int[lodData.numMaterials];
Assert( lodData.pMaterialFlags );
int i, j;
// get index of each material
// set the runtime studiohdr flags that are material derived
if ( phdr->textureindex == 0 )
return;
for ( i = 0; i < phdr->numtextures; i++ )
{
char szPath[MAX_PATH];
IMaterial *pMaterial = NULL;
// search through all specified directories until a valid material is found
for ( j = 0; j < phdr->numcdtextures && IsErrorMaterial( pMaterial ); j++ )
{
// If we don't do this, we get filenames like "materials\\blah.vmt".
const char *textureName = GetTextureName( phdr, pVtxHeader, lodID, i );
if ( textureName[0] == CORRECT_PATH_SEPARATOR || textureName[0] == INCORRECT_PATH_SEPARATOR )
++textureName;
// This prevents filenames like /models/blah.vmt.
const char *pCdTexture = phdr->pCdtexture( j );
if ( pCdTexture[0] == CORRECT_PATH_SEPARATOR || pCdTexture[0] == INCORRECT_PATH_SEPARATOR )
++pCdTexture;
V_ComposeFileName( pCdTexture, textureName, szPath, sizeof( szPath ) );
if ( phdr->flags & STUDIOHDR_FLAGS_OBSOLETE )
{
pMaterial = g_pMaterialSystem->FindMaterial( "models/obsolete/obsolete", TEXTURE_GROUP_MODEL, false );
if ( IsErrorMaterial( pMaterial ) )
{
Warning( "StudioRender: OBSOLETE material missing: \"models/obsolete/obsolete\"\n" );
}
}
else
{
pMaterial = g_pMaterialSystem->FindMaterial( szPath, TEXTURE_GROUP_MODEL, false );
}
}
if ( IsErrorMaterial( pMaterial ) )
{
// hack - if it isn't found, go through the motions of looking for it again
// so that the materialsystem will give an error.
char szPrefix[256];
Q_strncpy( szPrefix, phdr->pszName(), sizeof( szPrefix ) );
Q_strncat( szPrefix, " : ", sizeof( szPrefix ), COPY_ALL_CHARACTERS );
for ( j = 0; j < phdr->numcdtextures; j++ )
{
Q_strncpy( szPath, phdr->pCdtexture( j ), sizeof( szPath ) );
const char *textureName = GetTextureName( phdr, pVtxHeader, lodID, i );
Q_strncat( szPath, textureName, sizeof( szPath ), COPY_ALL_CHARACTERS );
Q_FixSlashes( szPath, CORRECT_PATH_SEPARATOR );
g_pMaterialSystem->FindMaterial( szPath, TEXTURE_GROUP_MODEL, true, szPrefix );
}
}
lodData.ppMaterials[i] = pMaterial;
if ( pMaterial )
{
// Increment the reference count for the material.
pMaterial->IncrementReferenceCount();
ComputeMaterialFlags( phdr, lodData, pMaterial );
lodData.pMaterialFlags[i] = UsesMouthShader( pMaterial ) ? 1 : 0;
}
}
}
//-----------------------------------------------------------------------------
// Suppresses all hw morphs on a model
//-----------------------------------------------------------------------------
static void SuppressAllHWMorphs( mstudiomodel_t *pModel, OptimizedModel::ModelLODHeader_t *pVtxLOD )
{
for ( int k = 0; k < pModel->nummeshes; ++k )
{
OptimizedModel::MeshHeader_t* pVtxMesh = pVtxLOD->pMesh(k);
for (int i = 0; i < pVtxMesh->numStripGroups; ++i )
{
OptimizedModel::StripGroupHeader_t* pStripGroup = pVtxMesh->pStripGroup(i);
if ( ( pStripGroup->flags & OptimizedModel::STRIPGROUP_IS_DELTA_FLEXED ) )
{
pStripGroup->flags |= OptimizedModel::STRIPGROUP_SUPPRESS_HW_MORPH;
}
}
}
}
//-----------------------------------------------------------------------------
// Computes the total flexes on a model
//-----------------------------------------------------------------------------
static int ComputeTotalFlexCount( mstudiomodel_t *pModel )
{
int nFlexCount = 0;
for ( int k = 0; k < pModel->nummeshes; ++k )
{
mstudiomesh_t* pMesh = pModel->pMesh(k);
nFlexCount += pMesh->numflexes;
}
return nFlexCount;
}
//-----------------------------------------------------------------------------
// Count deltas affecting a particular stripgroup
//-----------------------------------------------------------------------------
int CStudioRenderContext::CountDeltaFlexedStripGroups( mstudiomodel_t *pModel, OptimizedModel::ModelLODHeader_t *pVtxLOD )
{
int nFlexedStripGroupCount = 0;
for ( int k = 0; k < pModel->nummeshes; ++k )
{
Assert( pModel->nummeshes == pVtxLOD->numMeshes );
OptimizedModel::MeshHeader_t* pVtxMesh = pVtxLOD->pMesh(k);
for (int i = 0; i < pVtxMesh->numStripGroups; ++i )
{
OptimizedModel::StripGroupHeader_t* pStripGroup = pVtxMesh->pStripGroup(i);
if ( ( pStripGroup->flags & OptimizedModel::STRIPGROUP_IS_DELTA_FLEXED ) == 0 )
continue;
++nFlexedStripGroupCount;
}
}
return nFlexedStripGroupCount;
}
//-----------------------------------------------------------------------------
// Count vertices affected by deltas in a particular strip group
//-----------------------------------------------------------------------------
int CStudioRenderContext::CountFlexedVertices( mstudiomesh_t* pMesh, OptimizedModel::StripGroupHeader_t* pStripGroup )
{
if ( !pMesh->numflexes )
return 0;
// an inverse mapping from mesh index to strip group index
unsigned short *pMeshIndexToGroupIndex = (unsigned short*)_alloca( pMesh->pModel()->numvertices * sizeof(unsigned short) );
memset( pMeshIndexToGroupIndex, 0xFF, pMesh->pModel()->numvertices * sizeof(unsigned short) );
for ( int i = 0; i < pStripGroup->numVerts; ++i )
{
int nMeshVert = pStripGroup->pVertex(i)->origMeshVertID;
pMeshIndexToGroupIndex[ nMeshVert ] = (unsigned short)i;
}
int nFlexVertCount = 0;
for ( int i = 0; i < pMesh->numflexes; ++i )
{
mstudioflex_t *pFlex = pMesh->pFlex( i );
byte *pVAnim = pFlex->pBaseVertanim();
int nVAnimSizeBytes = pFlex->VertAnimSizeBytes();
for ( int j = 0; j < pFlex->numverts; ++j )
{
mstudiovertanim_t *pAnim = (mstudiovertanim_t*)( pVAnim + j * nVAnimSizeBytes );
int nMeshVert = pAnim->index;
unsigned short nGroupVert = pMeshIndexToGroupIndex[nMeshVert];
// In this case, this vertex is not part of this meshgroup. Ignore it.
if ( nGroupVert != 0xFFFF )
{
// Only count it once
pMeshIndexToGroupIndex[nMeshVert] = 0xFFFF;
++nFlexVertCount;
}
}
}
return nFlexVertCount;
}
//-----------------------------------------------------------------------------
// Determine if any strip groups shouldn't be morphed
//-----------------------------------------------------------------------------
static int* s_pVertexCount;
static int SortVertCount( const void *arg1, const void *arg2 )
{
/* Compare all of both strings: */
return s_pVertexCount[*( const int* )arg2] - s_pVertexCount[*( const int* )arg1];
}
#define MIN_HWMORPH_FLEX_COUNT 200
void CStudioRenderContext::DetermineHWMorphing( mstudiomodel_t *pModel, OptimizedModel::ModelLODHeader_t *pVtxLOD )
{
if ( !g_pMaterialSystemHardwareConfig->HasFastVertexTextures() )
return;
// There is fixed cost to using HW morphing in the form of setting rendertargets.
// Therefore if there is a low chance of there being enough work, then do it in software.
int nTotalFlexCount = ComputeTotalFlexCount( pModel );
if ( nTotalFlexCount == 0 )
return;
if ( nTotalFlexCount < MIN_HWMORPH_FLEX_COUNT )
{
SuppressAllHWMorphs( pModel, pVtxLOD );
return;
}
// If we have less meshes than the most morphs we can do in a batch, we're done.
int nMaxHWMorphBatchCount = g_pMaterialSystemHardwareConfig->MaxHWMorphBatchCount();
bool bHWMorph = ( pModel->nummeshes <= nMaxHWMorphBatchCount );
if ( bHWMorph )
return;
// If we have less flexed strip groups than the most we can do in a batch, we're done.
int nFlexedStripGroup = CountDeltaFlexedStripGroups( pModel, pVtxLOD );
if ( nFlexedStripGroup <= nMaxHWMorphBatchCount )
return;
// Finally, the expensive method. Do HW morphing on the N most expensive strip groups
// FIXME: We should do this at studiomdl time?
// Certainly counting the # of flexed vertices can be done at studiomdl time.
int *pVertexCount = (int*)_alloca( nFlexedStripGroup * sizeof(int) );
int nCount = 0;
for ( int k = 0; k < pModel->nummeshes; ++k )
{
Assert( pModel->nummeshes == pVtxLOD->numMeshes );
mstudiomesh_t* pMesh = pModel->pMesh(k);
OptimizedModel::MeshHeader_t* pVtxMesh = pVtxLOD->pMesh(k);
for (int i = 0; i < pVtxMesh->numStripGroups; ++i )
{
OptimizedModel::StripGroupHeader_t* pStripGroup = pVtxMesh->pStripGroup(i);
if ( ( pStripGroup->flags & OptimizedModel::STRIPGROUP_IS_DELTA_FLEXED ) == 0 )
continue;
pVertexCount[nCount++] = CountFlexedVertices( pMesh, pStripGroup );
}
}
int *pSortedVertexIndices = (int*)_alloca( nFlexedStripGroup * sizeof(int) );
for ( int i = 0; i < nFlexedStripGroup; ++i )
{
pSortedVertexIndices[i] = i;
}
s_pVertexCount = pVertexCount;
qsort( pSortedVertexIndices, nCount, sizeof(int), SortVertCount );
bool *pSuppressHWMorph = (bool*)_alloca( nFlexedStripGroup * sizeof(bool) );
memset( pSuppressHWMorph, 1, nFlexedStripGroup * sizeof(bool) );
for ( int i = 0; i < nMaxHWMorphBatchCount; ++i )
{
pSuppressHWMorph[pSortedVertexIndices[i]] = false;
}
// Bleah. Pretty lame. We should change StripGroupHeader_t to store the flex vertex count
int nIndex = 0;
for ( int k = 0; k < pModel->nummeshes; ++k )
{
Assert( pModel->nummeshes == pVtxLOD->numMeshes );
OptimizedModel::MeshHeader_t* pVtxMesh = pVtxLOD->pMesh(k);
for (int i = 0; i < pVtxMesh->numStripGroups; ++i )
{
OptimizedModel::StripGroupHeader_t* pStripGroup = pVtxMesh->pStripGroup(i);
if ( ( pStripGroup->flags & OptimizedModel::STRIPGROUP_IS_DELTA_FLEXED ) == 0 )
continue;
if ( pSuppressHWMorph[nIndex] )
{
pStripGroup->flags |= OptimizedModel::STRIPGROUP_SUPPRESS_HW_MORPH;
}
++nIndex;
}
}
}
//-----------------------------------------------------------------------------
// Adds a vertex to the meshbuilder. Returns false if boneweights did not sum to 1.0
//-----------------------------------------------------------------------------
template <VertexCompressionType_t T> bool CStudioRenderContext::R_AddVertexToMesh( const char *pModelName, bool bNeedsTangentSpace, CMeshBuilder& meshBuilder,
OptimizedModel::Vertex_t* pVertex, mstudiomesh_t* pMesh, const mstudio_meshvertexdata_t *vertData, bool hwSkin )
{
bool bOK = true;
int idx = pVertex->origMeshVertID;
mstudiovertex_t &vert = *vertData->Vertex( idx );
// FIXME: if this ever becomes perf-critical... these writes are not in memory-ascending order,
// which hurts since VBs are in write-combined memory (See WriteCombineOrdering_t)
meshBuilder.Position3fv( vert.m_vecPosition.Base() );
meshBuilder.CompressedNormal3fv<T>( vert.m_vecNormal.Base() );
/*
if( vert.m_vecNormal.Length() < .9f || vert.m_vecNormal.Length() > 1.1f )
{
static CUtlStringMap<bool> errorMessages;
if( !errorMessages.Defined( pModelName ) )
{
errorMessages[pModelName] = true;
Warning( "MODELBUG %s: bad normal\n", pModelName );
Warning( "\tnormal %0.1f %0.1f %0.1f pos: %0.1f %0.1f %0.1f\n",
vert.m_vecNormal.x, vert.m_vecNormal.y, vert.m_vecNormal.z,
vert.m_vecPosition.x, vert.m_vecPosition.y, vert.m_vecPosition.z );
}
}
*/
meshBuilder.TexCoord2fv( 0, vert.m_vecTexCoord.Base() );
if (vertData->HasTangentData())
{
/*
if( bNeedsTangentSpace && pModelName && vertData->TangentS( idx ) )
{
const Vector4D &tangentS = *vertData->TangentS( idx );
float w = tangentS.w;
if( !( w == 1.0f || w == -1.0f ) )
{
static CUtlStringMap<bool> errorMessages;
if( !errorMessages.Defined( pModelName ) )
{
errorMessages[pModelName] = true;
Warning( "MODELBUG %s: bad tangent sign\n", pModelName );
Warning( "\tsign %0.1f at position %0.1f %0.1f %0.1f\n",
w, vert.m_vecPosition.x, vert.m_vecPosition.y, vert.m_vecPosition.z );
}
}
float len = tangentS.AsVector3D().Length();
if( len < .9f || len > 1.1f )
{
static CUtlStringMap<bool> errorMessages;
if( !errorMessages.Defined( pModelName ) )
{
errorMessages[pModelName] = true;
Warning( "MODELBUG %s: bad tangent vector\n", pModelName );
Warning( "\ttangent: %0.1f %0.1f %0.1f with length %0.1f at position %0.1f %0.1f %0.1f\n",
tangentS.x, tangentS.y, tangentS.z,
len,
vert.m_vecPosition.x, vert.m_vecPosition.y, vert.m_vecPosition.z );
}
}
#if 0
float dot = DotProduct( vert.m_vecNormal, tangentS.AsVector3D() );
if( dot > .95 || dot < -.95 )
{
static CUtlStringMap<bool> errorMessages;
if( !errorMessages.Defined( pModelName ) )
{
errorMessages[pModelName] = true;
// this is crashing for some reason. .need to investigate.
Warning( "MODELBUG %s: nearly colinear tangentS (%f %f %f) and normal (%f %f %f) at position %f %f %f Probably have 2 or more texcoords that are the same on a triangle.\n",
pModelName, tangentS.x, tangentS.y, tangentS.y, vert.m_vecNormal.x, vert.m_vecNormal.y, vert.m_vecNormal.z, vert.m_vecPosition.x, vert.m_vecPosition.y, vert.m_vecPosition.z );
}
}
#endif
}
*/
// send down tangent S as a 4D userdata vect.
meshBuilder.CompressedUserData<T>( (*vertData->TangentS( idx )).Base() );
}
// Just in case we get hooked to a material that wants per-vertex color
meshBuilder.Color4ub( 255, 255, 255, 255 );
float boneWeights[ MAX_NUM_BONE_INDICES ];
if ( hwSkin )
{
// sum up weights..
int i;
// We have to do this because since we're potentially dropping bones
// to get them to fit in hardware, we'll need to renormalize based on
// the actual total.
mstudioboneweight_t *pBoneWeight = vertData->BoneWeights(idx);
// NOTE: We use pVertex->numbones because that's the number of bones actually influencing this
// vertex. Note that pVertex->numBones is not necessary the *desired* # of bones influencing this
// vertex; we could have collapsed some of those bones out. pBoneWeight->numbones stures the desired #
float totalWeight = 0;
for (i = 0; i < pVertex->numBones; ++i)
{
totalWeight += pBoneWeight->weight[pVertex->boneWeightIndex[i]];
}
// The only way we should not add up to 1 is if there's more than 3 *desired* bones
// and more than 1 *actual* bone (we can have 0 vertex bones in the case of static props
if ( (pVertex->numBones > 0) && (pBoneWeight->numbones <= 3) && fabs(totalWeight - 1.0f) > 1e-3 )
{
// force them to re-normalize
bOK = false;
totalWeight = 1.0f;
}
// Fix up the static prop case
if ( totalWeight == 0.0f )
{
totalWeight = 1.0f;
}
float invTotalWeight = 1.0f / totalWeight;
// It is essential to iterate over all actual bones so that the bone indices
// are set correctly, even though the last bone weight is computed in a shader program
for (i = 0; i < pVertex->numBones; ++i)
{
if ( pVertex->boneID[i] == -1 )
{
boneWeights[ i ] = 0.0f;
meshBuilder.BoneMatrix( i, BONE_MATRIX_INDEX_INVALID );
}
else
{
float weight = pBoneWeight->weight[pVertex->boneWeightIndex[i]];
boneWeights[ i ] = weight * invTotalWeight;
meshBuilder.BoneMatrix( i, pVertex->boneID[i] );
}
}
for( ; i < MAX_NUM_BONE_INDICES; i++ )
{
boneWeights[ i ] = 0.0f;
meshBuilder.BoneMatrix( i, BONE_MATRIX_INDEX_INVALID );
}
}
else
{
for (int i = 0; i < MAX_NUM_BONE_INDICES; ++i)
{
boneWeights[ i ] = (i == 0) ? 1.0f : 0.0f;
meshBuilder.BoneMatrix( i, BONE_MATRIX_INDEX_INVALID );
}
}
// Set all the weights at once (the meshbuilder performs additional, post-compression, normalization):
Assert( pVertex->numBones <= 3 );
if ( pVertex->numBones > 0 )
{
meshBuilder.CompressedBoneWeight3fv<T>( &( boneWeights[ 0 ] ) );
}
meshBuilder.AdvanceVertex();
return bOK;
}
// Get (uncompressed) vertex data from a mesh, if available
inline const mstudio_meshvertexdata_t * GetFatVertexData( mstudiomesh_t * pMesh, studiohdr_t * pStudioHdr )
{
if ( !pMesh->pModel()->CacheVertexData( pStudioHdr ) )
{
// not available yet
return NULL;
}
const mstudio_meshvertexdata_t *pVertData = pMesh->GetVertexData( pStudioHdr );
Assert( pVertData );
if ( !pVertData )
{
static unsigned int warnCount = 0;
if ( warnCount++ < 20 )
Warning( "ERROR: model verts have been compressed, cannot render! (use \"-no_compressed_vvds\")" );
}
return pVertData;
}
//-----------------------------------------------------------------------------
// Builds the group
//-----------------------------------------------------------------------------
void CStudioRenderContext::R_StudioBuildMeshGroup( const char *pModelName, bool bNeedsTangentSpace, studiomeshgroup_t* pMeshGroup,
OptimizedModel::StripGroupHeader_t *pStripGroup, mstudiomesh_t* pMesh,
studiohdr_t *pStudioHdr, VertexFormat_t vertexFormat )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
// We have to do this here because of skinning; there may be any number of
// materials that are applied to this mesh.
// Copy over all the vertices + indices in this strip group
pMeshGroup->m_pMesh = pRenderContext->CreateStaticMesh( vertexFormat, TEXTURE_GROUP_STATIC_VERTEX_BUFFER_MODELS );
VertexCompressionType_t compressionType = CompressionType( vertexFormat );
pMeshGroup->m_ColorMeshID = -1;
bool hwSkin = (pMeshGroup->m_Flags & MESHGROUP_IS_HWSKINNED) != 0;
// This mesh could have tristrips or trilists in it
CMeshBuilder meshBuilder;
meshBuilder.SetCompressionType( compressionType );
meshBuilder.Begin( pMeshGroup->m_pMesh, MATERIAL_HETEROGENOUS,
hwSkin ? pStripGroup->numVerts : 0, pStripGroup->numIndices );
int i;
bool bBadBoneWeights = false;
if ( hwSkin )
{
const mstudio_meshvertexdata_t *vertData = GetFatVertexData( pMesh, pStudioHdr );
Assert( vertData );
for ( i = 0; i < pStripGroup->numVerts; ++i )
{
bool success;
switch ( compressionType )
{
case VERTEX_COMPRESSION_ON:
success = R_AddVertexToMesh<VERTEX_COMPRESSION_ON>( pModelName, bNeedsTangentSpace, meshBuilder, pStripGroup->pVertex(i), pMesh, vertData, hwSkin );
break;
case VERTEX_COMPRESSION_NONE:
default:
success = R_AddVertexToMesh<VERTEX_COMPRESSION_NONE>( pModelName, bNeedsTangentSpace, meshBuilder, pStripGroup->pVertex(i), pMesh, vertData, hwSkin );
break;
}
if ( !success )
{
bBadBoneWeights = true;
}
}
}
if ( bBadBoneWeights )
{
mstudiomodel_t* pModel = pMesh->pModel();
ConMsg( "Bad data found in model \"%s\" (bad bone weights)\n", pModel->pszName() );
}
for (i = 0; i < pStripGroup->numIndices; ++i)
{
meshBuilder.Index( *pStripGroup->pIndex(i) );
meshBuilder.AdvanceIndex();
}
meshBuilder.End();
// Copy over the strip indices. We need access to the indices for decals
pMeshGroup->m_pIndices = new unsigned short[ pStripGroup->numIndices ];
memcpy( pMeshGroup->m_pIndices, pStripGroup->pIndex(0),
pStripGroup->numIndices * sizeof(unsigned short) );
// Compute the number of non-degenerate trianges in each strip group
// for statistics gathering
pMeshGroup->m_pUniqueTris = new int[ pStripGroup->numStrips ];
for (i = 0; i < pStripGroup->numStrips; ++i )
{
int numUnique = 0;
if (pStripGroup->pStrip(i)->flags & OptimizedModel::STRIP_IS_TRISTRIP)
{
int last[2] = {-1, -1};
int curr = pStripGroup->pStrip(i)->indexOffset;
int end = curr + pStripGroup->pStrip(i)->numIndices;
while (curr != end)
{
int idx = *pStripGroup->pIndex(curr);
if (idx != last[0] && idx != last[1] && last[0] != last[1] && last[0] != -1)
++numUnique;
last[0] = last[1];
last[1] = idx;
++curr;
}
}
else
{
numUnique = pStripGroup->pStrip(i)->numIndices / 3;
}
pMeshGroup->m_pUniqueTris[i] = numUnique;
}
}
//-----------------------------------------------------------------------------
// Builds the group
//-----------------------------------------------------------------------------
void CStudioRenderContext::R_StudioBuildMorph( studiohdr_t *pStudioHdr,
studiomeshgroup_t* pMeshGroup, mstudiomesh_t* pMesh,
OptimizedModel::StripGroupHeader_t *pStripGroup )
{
if ( !g_pMaterialSystemHardwareConfig->HasFastVertexTextures() ||
( ( pMeshGroup->m_Flags & MESHGROUP_IS_DELTA_FLEXED ) == 0 ) ||
( ( pStripGroup->flags & OptimizedModel::STRIPGROUP_SUPPRESS_HW_MORPH ) != 0 ) )
{
pMeshGroup->m_pMorph = NULL;
return;
}
// Build an inverse mapping from mesh index to strip group index
unsigned short *pMeshIndexToGroupIndex = (unsigned short*)_alloca( pMesh->pModel()->numvertices * sizeof(unsigned short) );
memset( pMeshIndexToGroupIndex, 0xFF, pMesh->pModel()->numvertices * sizeof(unsigned short) );
for ( int i = 0; i < pStripGroup->numVerts; ++i )
{
int nMeshVert = pStripGroup->pVertex(i)->origMeshVertID;
pMeshIndexToGroupIndex[ nMeshVert ] = (unsigned short)i;
}
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
MorphFormat_t morphType = MORPH_POSITION | MORPH_NORMAL | MORPH_SPEED | MORPH_SIDE;
for ( int i = 0; i < pMesh->numflexes; ++i )
{
if ( pMesh->pFlex( i )->vertanimtype == STUDIO_VERT_ANIM_WRINKLE )
{
morphType |= MORPH_WRINKLE;
break;
}
}
char pTemp[256];
Q_snprintf( pTemp, sizeof(pTemp), "%s [%p]", pStudioHdr->pszName(), pMeshGroup );
pMeshGroup->m_pMorph = pRenderContext->CreateMorph( morphType, pTemp );
const float flVertAnimFixedPointScale = pStudioHdr->VertAnimFixedPointScale();
CMorphBuilder morphBuilder;
morphBuilder.Begin( pMeshGroup->m_pMorph, 1.0f / flVertAnimFixedPointScale );
for ( int i = 0; i < pMesh->numflexes; ++i )
{
mstudioflex_t *pFlex = pMesh->pFlex( i );
byte *pVAnim = pFlex->pBaseVertanim();
int nVAnimSizeBytes = pFlex->VertAnimSizeBytes();
for ( int j = 0; j < pFlex->numverts; ++j )
{
mstudiovertanim_t *pAnim = (mstudiovertanim_t*)( pVAnim + j * nVAnimSizeBytes );
int nMeshVert = pAnim->index;
unsigned short nGroupVert = pMeshIndexToGroupIndex[nMeshVert];
// In this case, this vertex is not part of this meshgroup. Ignore it.
if ( nGroupVert == 0xFFFF )
continue;
morphBuilder.PositionDelta3( pAnim->GetDeltaFixed( flVertAnimFixedPointScale ) );
morphBuilder.NormalDelta3( pAnim->GetNDeltaFixed( flVertAnimFixedPointScale ) );
morphBuilder.Speed1f( pAnim->speed / 255.0f );
morphBuilder.Side1f( pAnim->side / 255.0f );
if ( pFlex->vertanimtype == STUDIO_VERT_ANIM_WRINKLE )
{
mstudiovertanim_wrinkle_t *pWrinkleAnim = static_cast<mstudiovertanim_wrinkle_t*>( pAnim );
morphBuilder.WrinkleDelta1f( pWrinkleAnim->GetWrinkleDeltaFixed( flVertAnimFixedPointScale ) );
}
else
{
morphBuilder.WrinkleDelta1f( 0.0f );
}
morphBuilder.AdvanceMorph( nGroupVert, i );
}
}
morphBuilder.End();
}
//-----------------------------------------------------------------------------
// Builds the strip data
//-----------------------------------------------------------------------------
void CStudioRenderContext::R_StudioBuildMeshStrips( studiomeshgroup_t* pMeshGroup,
OptimizedModel::StripGroupHeader_t *pStripGroup )
{
// FIXME: This is bogus
// Compute the amount of memory we need to store the strip data
int i;
int stripDataSize = 0;
for( i = 0; i < pStripGroup->numStrips; ++i )
{
stripDataSize += sizeof(OptimizedModel::StripHeader_t);
stripDataSize += pStripGroup->pStrip(i)->numBoneStateChanges *
sizeof(OptimizedModel::BoneStateChangeHeader_t);
}
pMeshGroup->m_pStripData = (OptimizedModel::StripHeader_t*)malloc(stripDataSize);
// Copy over the strip info
int boneStateChangeOffset = pStripGroup->numStrips * sizeof(OptimizedModel::StripHeader_t);
for( i = 0; i < pStripGroup->numStrips; ++i )
{
memcpy( &pMeshGroup->m_pStripData[i], pStripGroup->pStrip(i),
sizeof( OptimizedModel::StripHeader_t ) );
// Fixup the bone state change offset, since we have it right after the strip data
pMeshGroup->m_pStripData[i].boneStateChangeOffset = boneStateChangeOffset -
i * sizeof(OptimizedModel::StripHeader_t);
// copy over bone state changes
int boneWeightSize = pMeshGroup->m_pStripData[i].numBoneStateChanges *
sizeof(OptimizedModel::BoneStateChangeHeader_t);
if (boneWeightSize != 0)
{
unsigned char* pBoneStateChange = (unsigned char*)pMeshGroup->m_pStripData + boneStateChangeOffset;
memcpy( pBoneStateChange, pStripGroup->pStrip(i)->pBoneStateChange(0), boneWeightSize);
boneStateChangeOffset += boneWeightSize;
}
}
pMeshGroup->m_NumStrips = pStripGroup->numStrips;
}
//-----------------------------------------------------------------------------
// Determine the max. number of bone weights used by a stripgroup
//-----------------------------------------------------------------------------
int CStudioRenderContext::GetNumBoneWeights( const OptimizedModel::StripGroupHeader_t *pGroup )
{
int nBoneWeightsMax = 0;
for (int i = 0;i < pGroup->numStrips; i++)
{
OptimizedModel::StripHeader_t * pStrip = pGroup->pStrip( i );
nBoneWeightsMax = max( nBoneWeightsMax, (int)pStrip->numBones );
}
return nBoneWeightsMax;
}
//-----------------------------------------------------------------------------
// Determine an actual model vertex format for a mesh based on its material usage.
// Bypasses the homegenous model vertex format in favor of the actual format.
// Ideally matches 1:1 the shader's data requirements without any bloat.
//-----------------------------------------------------------------------------
VertexFormat_t CStudioRenderContext::CalculateVertexFormat( const studiohdr_t *pStudioHdr, const studioloddata_t *pStudioLodData,
const mstudiomesh_t* pMesh, OptimizedModel::StripGroupHeader_t *pGroup, bool bIsHwSkinned )
{
bool bSkinnedMesh = ( pStudioHdr->numbones > 1 );
int nBoneWeights = GetNumBoneWeights( pGroup );
bool bIsDX7 = !g_pMaterialSystemHardwareConfig->SupportsVertexAndPixelShaders();
bool bIsDX8 = ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 90 );
if ( bIsDX7 )
{
// FIXME: this is untested (as of June '07, the engine currently doesn't work with "-dxlevel 70")
if ( bSkinnedMesh )
return MATERIAL_VERTEX_FORMAT_MODEL_SKINNED_DX7;
else
return MATERIAL_VERTEX_FORMAT_MODEL_DX7;
}
else if ( bIsDX8 )
{
if ( bSkinnedMesh )
return MATERIAL_VERTEX_FORMAT_MODEL_SKINNED;
else
return MATERIAL_VERTEX_FORMAT_MODEL;
}
else
{
// DX9+ path (supports vertex compression)
// iterate each skin table
// determine aggregate vertex format for specified mesh's material
VertexFormat_t newVertexFormat = 0;
//bool bBumpmapping = false;
short *pSkinref = pStudioHdr->pSkinref( 0 );
for ( int i = 0; i < pStudioHdr->numskinfamilies; i++ )
{
// FIXME: ### MATERIAL VERTEX FORMATS ARE UNRELIABLE! ###
//
// IMaterial* pMaterial = pStudioLodData->ppMaterials[ pSkinref[ pMesh->material ] ];
// Assert( pMaterial );
// VertexFormat_t vertexFormat = pMaterial->GetVertexFormat();
// newVertexFormat &= ~VERTEX_FORMAT_COMPRESSED; // Decide whether to compress below
//
// FIXME: ### MATERIAL VERTEX FORMATS ARE UNRELIABLE! ###
// we need to go through all the shader CPP code and make sure that the correct vertex format
// is being specified for every single shader combo! We don't have time to fix that before
// shipping Ep2, but should fix it ASAP afterwards. To make catching such errors easier, we
// should Assert in draw calls that the vertexdecl matches vertex shader inputs (note that D3D
// debug DLLs will do that on PC, though it's not as informative as if we do it ourselves).
// So, in the absence of reliable material vertex formats, use the old 'standard' elements
// (we can still omit skinning data - and COLOR for DX8+, where it should come from the
// second static lighting stream):
VertexFormat_t vertexFormat = bIsDX7 ? MATERIAL_VERTEX_FORMAT_MODEL_DX7 : ( MATERIAL_VERTEX_FORMAT_MODEL & ~VERTEX_COLOR );
// aggregate single bit settings
newVertexFormat |= vertexFormat & ( ( 1 << VERTEX_LAST_BIT ) - 1 );
int nUserDataSize = UserDataSize( vertexFormat );
if ( nUserDataSize > UserDataSize( newVertexFormat ) )
{
newVertexFormat &= ~USER_DATA_SIZE_MASK;
newVertexFormat |= VERTEX_USERDATA_SIZE( nUserDataSize );
}
for (int j = 0; j < VERTEX_MAX_TEXTURE_COORDINATES; ++j)
{
int nSize = TexCoordSize( j, vertexFormat );
if ( nSize > TexCoordSize( j, newVertexFormat ) )
{
newVertexFormat &= ~VERTEX_TEXCOORD_SIZE( j, 0x7 );
newVertexFormat |= VERTEX_TEXCOORD_SIZE( j, nSize );
}
}
// FIXME: re-enable this test, fix it to work and see how much memory we save (Q: why is this different to CStudioRenderContext::MeshNeedsTangentSpace ?)
/*if ( !bBumpmapping && pMaterial->NeedsTangentSpace() )
{
bool bFound = false;
IMaterialVar *pEnvmapMatVar = pMaterial->FindVar( "$envmap", &bFound, false );
if ( bFound && pEnvmapMatVar->IsDefined() )
{
IMaterialVar *pBumpMatVar = pMaterial->FindVar( "$bumpmap", &bFound, false );
if ( bFound && pBumpMatVar->IsDefined() )
{
bBumpmapping = true;
}
}
} */
pSkinref += pStudioHdr->numskinref;
}
// Add skinning elements for non-rigid models (with more than one bone weight)
if ( bSkinnedMesh )
{
if ( nBoneWeights > 0 )
{
// Always exactly zero or two weights
newVertexFormat |= VERTEX_BONEWEIGHT( 2 );
}
newVertexFormat |= VERTEX_BONE_INDEX;
}
// FIXME: re-enable this (see above)
/*if ( !bBumpmapping )
{
// no bumpmapping, user data not needed
newVertexFormat &= ~USER_DATA_SIZE_MASK;
}*/
// materials on models should never have tangent space as they use userdata
Assert( !(newVertexFormat & VERTEX_TANGENT_SPACE) );
// Don't compress the mesh unless it is HW-skinned (we only want to compress static
// VBs, not dynamic ones - that would slow down the MeshBuilder in dynamic use cases).
// Also inspect the vertex data to see if it's appropriate for the vertex element
// compression techniques that we do (e.g. look at UV ranges).
if ( //IsX360() && // Disabled until the craziness is banished
bIsHwSkinned &&
( g_pMaterialSystemHardwareConfig->SupportsCompressedVertices() == VERTEX_COMPRESSION_ON ) )
{
// this mesh is appropriate for vertex compression
newVertexFormat |= VERTEX_FORMAT_COMPRESSED;
}
return newVertexFormat;
}
}
bool CStudioRenderContext::MeshNeedsTangentSpace( studiohdr_t *pStudioHdr, studioloddata_t *pStudioLodData, mstudiomesh_t* pMesh )
{
// iterate each skin table
if( !pStudioHdr || !pStudioHdr->pSkinref( 0 ) || !pStudioHdr->numskinfamilies )
{
return false;
}
short *pSkinref = pStudioHdr->pSkinref( 0 );
for ( int i=0; i<pStudioHdr->numskinfamilies; i++)
{
IMaterial* pMaterial = pStudioLodData->ppMaterials[pSkinref[pMesh->material]];
Assert( pMaterial );
if( !pMaterial )
{
continue;
}
// Warning( "*****%s needstangentspace: %d\n", pMaterial->GetName(), pMaterial->NeedsTangentSpace() ? 1 : 0 );
if( pMaterial->NeedsTangentSpace() )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Creates a single mesh
//-----------------------------------------------------------------------------
void CStudioRenderContext::R_StudioCreateSingleMesh( studiohdr_t *pStudioHdr, studioloddata_t *pStudioLodData,
mstudiomesh_t* pMesh, OptimizedModel::MeshHeader_t* pVtxMesh, int numBones,
studiomeshdata_t* pMeshData, int *pColorMeshID )
{
// Here are the cases where we don't use any meshes at all...
// In the case of eyes, we're just gonna use dynamic buffers
// because it's the fastest solution (prevents lots of locks)
bool bNeedsTangentSpace = MeshNeedsTangentSpace( pStudioHdr, pStudioLodData, pMesh );
// Each strip group represents a locking group, it's a set of vertices
// that are locked together, and, potentially, software light + skinned together
pMeshData->m_NumGroup = pVtxMesh->numStripGroups;
pMeshData->m_pMeshGroup = new studiomeshgroup_t[pVtxMesh->numStripGroups];
for (int i = 0; i < pVtxMesh->numStripGroups; ++i )
{
OptimizedModel::StripGroupHeader_t* pStripGroup = pVtxMesh->pStripGroup(i);
studiomeshgroup_t* pMeshGroup = &pMeshData->m_pMeshGroup[i];
pMeshGroup->m_MeshNeedsRestore = false;
// Set the flags...
pMeshGroup->m_Flags = 0;
if (pStripGroup->flags & OptimizedModel::STRIPGROUP_IS_FLEXED)
{
pMeshGroup->m_Flags |= MESHGROUP_IS_FLEXED;
}
if (pStripGroup->flags & OptimizedModel::STRIPGROUP_IS_DELTA_FLEXED)
{
pMeshGroup->m_Flags |= MESHGROUP_IS_DELTA_FLEXED;
}
bool bIsHwSkinned = !!(pStripGroup->flags & OptimizedModel::STRIPGROUP_IS_HWSKINNED);
if ( bIsHwSkinned )
{
pMeshGroup->m_Flags |= MESHGROUP_IS_HWSKINNED;
}
// get the minimal vertex format for this mesh
VertexFormat_t vertexFormat = CalculateVertexFormat( pStudioHdr, pStudioLodData, pMesh, pStripGroup, bIsHwSkinned );
// Build the vertex + index buffers
R_StudioBuildMeshGroup( pStudioHdr->pszName(), bNeedsTangentSpace, pMeshGroup, pStripGroup, pMesh, pStudioHdr, vertexFormat );
// Copy over the tristrip and triangle list data
R_StudioBuildMeshStrips( pMeshGroup, pStripGroup );
// Builds morph targets
R_StudioBuildMorph( pStudioHdr, pMeshGroup, pMesh, pStripGroup );
// Build the mapping from strip group vertex idx to actual mesh idx
pMeshGroup->m_pGroupIndexToMeshIndex = new unsigned short[pStripGroup->numVerts + PREFETCH_VERT_COUNT];
pMeshGroup->m_NumVertices = pStripGroup->numVerts;
int j;
for ( j = 0; j < pStripGroup->numVerts; ++j )
{
pMeshGroup->m_pGroupIndexToMeshIndex[j] = pStripGroup->pVertex(j)->origMeshVertID;
}
// Extra copies are for precaching...
for ( j = pStripGroup->numVerts; j < pStripGroup->numVerts + PREFETCH_VERT_COUNT; ++j )
{
pMeshGroup->m_pGroupIndexToMeshIndex[j] = pMeshGroup->m_pGroupIndexToMeshIndex[pStripGroup->numVerts - 1];
}
// assign the possibly used color mesh id now
pMeshGroup->m_ColorMeshID = (*pColorMeshID)++;
}
}
//-----------------------------------------------------------------------------
// Creates static meshes
//-----------------------------------------------------------------------------
void CStudioRenderContext::R_StudioCreateStaticMeshes( studiohdr_t *pStudioHdr,
OptimizedModel::FileHeader_t *pVtxHdr, studiohwdata_t *pStudioHWData, int nLodID, int *pColorMeshID )
{
int i, j, k;
Assert( pStudioHdr && pVtxHdr && pStudioHWData );
pStudioHWData->m_pLODs[nLodID].m_pMeshData = new studiomeshdata_t[pStudioHWData->m_NumStudioMeshes];
// Iterate over every body part...
for ( i = 0; i < pStudioHdr->numbodyparts; i++ )
{
mstudiobodyparts_t* pBodyPart = pStudioHdr->pBodypart(i);
OptimizedModel::BodyPartHeader_t* pVtxBodyPart = pVtxHdr->pBodyPart(i);
// Iterate over every submodel...
for ( j = 0; j < pBodyPart->nummodels; ++j )
{
mstudiomodel_t* pModel = pBodyPart->pModel(j);
OptimizedModel::ModelHeader_t* pVtxModel = pVtxBodyPart->pModel(j);
OptimizedModel::ModelLODHeader_t *pVtxLOD = pVtxModel->pLOD( nLodID );
// Determine which meshes should be hw morphed
DetermineHWMorphing( pModel, pVtxLOD );
// Support tracking of VB allocations
// FIXME: categorise studiomodel allocs more precisely
if ( g_VBAllocTracker )
{
if ( ( pStudioHdr->numbones > 8 ) || ( pStudioHdr->numflexdesc > 0 ) )
{
g_VBAllocTracker->TrackMeshAllocations( "R_StudioCreateStaticMeshes (character)" );
}
else
{
if ( pStudioHdr->flags & STUDIOHDR_FLAGS_STATIC_PROP )
{
g_VBAllocTracker->TrackMeshAllocations( "R_StudioCreateStaticMeshes (prop_static)" );
}
else
{
g_VBAllocTracker->TrackMeshAllocations( "R_StudioCreateStaticMeshes (prop_dynamic)" );
}
}
}
// Iterate over all the meshes....
for ( k = 0; k < pModel->nummeshes; ++k )
{
Assert( pModel->nummeshes == pVtxLOD->numMeshes );
mstudiomesh_t* pMesh = pModel->pMesh(k);
OptimizedModel::MeshHeader_t* pVtxMesh = pVtxLOD->pMesh(k);
Assert( pMesh->meshid < pStudioHWData->m_NumStudioMeshes );
R_StudioCreateSingleMesh( pStudioHdr, &pStudioHWData->m_pLODs[nLodID],
pMesh, pVtxMesh, pVtxHdr->maxBonesPerVert,
&pStudioHWData->m_pLODs[nLodID].m_pMeshData[pMesh->meshid], pColorMeshID );
}
if ( g_VBAllocTracker )
{
g_VBAllocTracker->TrackMeshAllocations( NULL );
}
}
}
}
//-----------------------------------------------------------------------------
// Destroys static meshes
//-----------------------------------------------------------------------------
void CStudioRenderContext::R_StudioDestroyStaticMeshes( int numStudioMeshes, studiomeshdata_t **ppStudioMeshes )
{
if( !*ppStudioMeshes)
return;
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
// Iterate over every body mesh...
for ( int i = 0; i < numStudioMeshes; ++i )
{
studiomeshdata_t* pMesh = &((*ppStudioMeshes)[i]);
for (int j = 0; j < pMesh->m_NumGroup; ++j)
{
studiomeshgroup_t* pGroup = &pMesh->m_pMeshGroup[j];
if (pGroup->m_pGroupIndexToMeshIndex)
{
delete[] pGroup->m_pGroupIndexToMeshIndex;
pGroup->m_pGroupIndexToMeshIndex = 0;
}
if (pGroup->m_pUniqueTris)
{
delete [] pGroup->m_pUniqueTris;
pGroup->m_pUniqueTris = 0;
}
if (pGroup->m_pIndices)
{
delete [] pGroup->m_pIndices;
pGroup->m_pIndices = 0;
}
if (pGroup->m_pMesh)
{
pRenderContext->DestroyStaticMesh( pGroup->m_pMesh );
pGroup->m_pMesh = 0;
}
if (pGroup->m_pMorph)
{
pRenderContext->DestroyMorph( pGroup->m_pMorph );
pGroup->m_pMorph = 0;
}
if (pGroup->m_pStripData)
{
free( pGroup->m_pStripData );
pGroup->m_pStripData = 0;
}
}
if (pMesh->m_pMeshGroup)
{
delete[] pMesh->m_pMeshGroup;
pMesh->m_pMeshGroup = 0;
}
}
if ( *ppStudioMeshes )
{
delete *ppStudioMeshes;
*ppStudioMeshes = 0;
}
}
//-----------------------------------------------------------------------------
// Builds the decal bone remap for a particular mesh
//-----------------------------------------------------------------------------
void CStudioRenderContext::BuildDecalBoneMap( studiohdr_t *pStudioHdr, int *pUsedBones, int *pBoneRemap, int *pMaxBoneCount, mstudiomesh_t* pMesh, OptimizedModel::StripGroupHeader_t* pStripGroup )
{
const mstudio_meshvertexdata_t *pVertData = GetFatVertexData( pMesh, pStudioHdr );
Assert( pVertData );
for ( int i = 0; i < pStripGroup->numVerts; ++i )
{
int nMeshVert = pStripGroup->pVertex( i )->origMeshVertID;
mstudioboneweight_t &boneWeight = pVertData->Vertex( nMeshVert )->m_BoneWeights;
int nBoneCount = boneWeight.numbones;
for ( int j = 0; j < nBoneCount; ++j )
{
if ( boneWeight.weight[j] == 0.0f )
continue;
if ( pBoneRemap[ (unsigned)boneWeight.bone[j] ] >= 0 )
continue;
pBoneRemap[ (unsigned)boneWeight.bone[j] ] = *pUsedBones;
*pUsedBones = *pUsedBones + 1;
}
}
for ( int i = 0; i < pStripGroup->numStrips; ++i )
{
if ( pStripGroup->pStrip(i)->numBones > *pMaxBoneCount )
{
*pMaxBoneCount = pStripGroup->pStrip(i)->numBones;
}
}
}
//-----------------------------------------------------------------------------
// For decals on hardware morphing, we must actually do hardware skinning
// because the flex must occur before skinning.
// For this to work, we have to hope that the total # of bones used by
// hw flexed verts is < than the max possible for the dx level we're running under
//-----------------------------------------------------------------------------
void CStudioRenderContext::ComputeHWMorphDecalBoneRemap( studiohdr_t *pStudioHdr, OptimizedModel::FileHeader_t *pVtxHdr, studiohwdata_t *pStudioHWData, int nLOD )
{
if ( pStudioHdr->numbones == 0 )
return;
// Remaps sw bones to hw bones during decal rendering
// NOTE: Only bones affecting vertices which have hw flexes will be add to this map.
int nBufSize = pStudioHdr->numbones * sizeof(int);
int *pBoneRemap = (int*)_alloca( nBufSize );
memset( pBoneRemap, 0xFF, nBufSize );
int nMaxBoneCount = 0;
// NOTE: HW bone index 0 is always the identity transform during decals.
pBoneRemap[0] = 0; // necessary for unused bones in a vertex
int nUsedBones = 1;
studioloddata_t *pStudioLOD = &pStudioHWData->m_pLODs[nLOD];
for ( int i = 0; i < pStudioHdr->numbodyparts; ++i )
{
mstudiobodyparts_t* pBodyPart = pStudioHdr->pBodypart(i);
OptimizedModel::BodyPartHeader_t* pVtxBodyPart = pVtxHdr->pBodyPart(i);
// Iterate over every submodel...
for ( int j = 0; j < pBodyPart->nummodels; ++j )
{
mstudiomodel_t* pModel = pBodyPart->pModel(j);
OptimizedModel::ModelHeader_t* pVtxModel = pVtxBodyPart->pModel(j);
OptimizedModel::ModelLODHeader_t *pVtxLOD = pVtxModel->pLOD( nLOD );
// Iterate over all the meshes....
for ( int k = 0; k < pModel->nummeshes; ++k )
{
Assert( pModel->nummeshes == pVtxLOD->numMeshes );
mstudiomesh_t* pMesh = pModel->pMesh(k);
OptimizedModel::MeshHeader_t* pVtxMesh = pVtxLOD->pMesh(k);
studiomeshdata_t* pMeshData = &pStudioLOD->m_pMeshData[pMesh->meshid];
for ( int l = 0; l < pVtxMesh->numStripGroups; ++l )
{
studiomeshgroup_t* pMeshGroup = &pMeshData->m_pMeshGroup[l];
if ( !pMeshGroup->m_pMorph )
continue;
OptimizedModel::StripGroupHeader_t* pStripGroup = pVtxMesh->pStripGroup(l);
BuildDecalBoneMap( pStudioHdr, &nUsedBones, pBoneRemap, &nMaxBoneCount, pMesh, pStripGroup );
}
}
}
}
if ( nUsedBones > 1 )
{
if ( nUsedBones > g_pMaterialSystemHardwareConfig->MaxVertexShaderBlendMatrices() )
{
Warning( "Hardware morphing of decals will be busted! Too many unique bones on flexed vertices!\n" );
}
pStudioLOD->m_pHWMorphDecalBoneRemap = new int[ pStudioHdr->numbones ];
memcpy( pStudioLOD->m_pHWMorphDecalBoneRemap, pBoneRemap, nBufSize );
pStudioLOD->m_nDecalBoneCount = nMaxBoneCount;
}
}
//-----------------------------------------------------------------------------
// Hook needed by mdlcache to load the vertex data
//-----------------------------------------------------------------------------
const vertexFileHeader_t * mstudiomodel_t::CacheVertexData( void *pModelData )
{
// make requested data resident
return g_pStudioDataCache->CacheVertexData( (studiohdr_t *)pModelData );
}
//-----------------------------------------------------------------------------
// Loads, unloads models
//-----------------------------------------------------------------------------
bool CStudioRenderContext::LoadModel( studiohdr_t *pStudioHdr, void *pVtxBuffer, studiohwdata_t *pStudioHWData )
{
int i;
int j;
Assert( pStudioHdr );
Assert( pVtxBuffer );
Assert( pStudioHWData );
if ( !pStudioHdr || !pVtxBuffer || !pStudioHWData )
return false;
// NOTE: This must be called *after* Mod_LoadStudioModel
OptimizedModel::FileHeader_t* pVertexHdr = (OptimizedModel::FileHeader_t*)pVtxBuffer;
if ( pVertexHdr->checkSum != pStudioHdr->checksum )
{
ConDMsg("Error! Model %s .vtx file out of synch with .mdl\n", pStudioHdr->pszName() );
return false;
}
pStudioHWData->m_NumStudioMeshes = 0;
for ( i = 0; i < pStudioHdr->numbodyparts; i++ )
{
mstudiobodyparts_t* pBodyPart = pStudioHdr->pBodypart(i);
for (j = 0; j < pBodyPart->nummodels; j++)
{
pStudioHWData->m_NumStudioMeshes += pBodyPart->pModel(j)->nummeshes;
}
}
// Create static meshes
Assert( pVertexHdr->numLODs );
pStudioHWData->m_RootLOD = min( (int)pStudioHdr->rootLOD, pVertexHdr->numLODs-1 );
pStudioHWData->m_NumLODs = pVertexHdr->numLODs;
pStudioHWData->m_pLODs = new studioloddata_t[pVertexHdr->numLODs];
memset( pStudioHWData->m_pLODs, 0, pVertexHdr->numLODs * sizeof( studioloddata_t ));
// reset the runtime flags
pStudioHdr->flags &= ~STUDIOHDR_FLAGS_USES_ENV_CUBEMAP;
pStudioHdr->flags &= ~STUDIOHDR_FLAGS_USES_FB_TEXTURE;
pStudioHdr->flags &= ~STUDIOHDR_FLAGS_USES_BUMPMAPPING;
#ifdef _DEBUG
int totalNumMeshGroups = 0;
#endif
int nColorMeshID = 0;
int nLodID;
for ( nLodID = pStudioHWData->m_RootLOD; nLodID < pStudioHWData->m_NumLODs; nLodID++ )
{
// Load materials and determine material dependent mesh requirements
LoadMaterials( pStudioHdr, pVertexHdr, pStudioHWData->m_pLODs[nLodID], nLodID );
// build the meshes
R_StudioCreateStaticMeshes( pStudioHdr, pVertexHdr, pStudioHWData, nLodID, &nColorMeshID );
// Build the hardware bone remap for decal rendering using HW morphing
ComputeHWMorphDecalBoneRemap( pStudioHdr, pVertexHdr, pStudioHWData, nLodID );
// garymcthack - need to check for NULL here.
// save off the lod switch point
pStudioHWData->m_pLODs[nLodID].m_SwitchPoint = pVertexHdr->pBodyPart( 0 )->pModel( 0 )->pLOD( nLodID )->switchPoint;
#ifdef _DEBUG
studioloddata_t *pLOD = &pStudioHWData->m_pLODs[nLodID];
for ( int meshID = 0; meshID < pStudioHWData->m_NumStudioMeshes; ++meshID )
{
totalNumMeshGroups += pLOD->m_pMeshData[meshID].m_NumGroup;
}
#endif
}
#ifdef _DEBUG
Assert( nColorMeshID == totalNumMeshGroups );
#endif
return true;
}
void CStudioRenderContext::UnloadModel( studiohwdata_t *pHardwareData )
{
int i;
for ( i = pHardwareData->m_RootLOD; i < pHardwareData->m_NumLODs; i++ )
{
int j;
for ( j = 0; j < pHardwareData->m_pLODs[i].numMaterials; j++ )
{
if ( pHardwareData->m_pLODs[i].ppMaterials[j] )
{
pHardwareData->m_pLODs[i].ppMaterials[j]->DecrementReferenceCount();
}
}
delete [] pHardwareData->m_pLODs[i].ppMaterials;
delete [] pHardwareData->m_pLODs[i].pMaterialFlags;
pHardwareData->m_pLODs[i].ppMaterials = NULL;
pHardwareData->m_pLODs[i].pMaterialFlags = NULL;
}
for ( i = pHardwareData->m_RootLOD; i < pHardwareData->m_NumLODs; i++ )
{
R_StudioDestroyStaticMeshes( pHardwareData->m_NumStudioMeshes, &pHardwareData->m_pLODs[i].m_pMeshData );
}
delete[] pHardwareData->m_pLODs;
pHardwareData->m_pLODs = NULL;
}
//-----------------------------------------------------------------------------
// Refresh the studiohdr since it was lost...
//-----------------------------------------------------------------------------
void CStudioRenderContext::RefreshStudioHdr( studiohdr_t* pStudioHdr, studiohwdata_t* pHardwareData )
{
}
//-----------------------------------------------------------------------------
// Set the eye view target
//-----------------------------------------------------------------------------
void CStudioRenderContext::SetEyeViewTarget( const studiohdr_t *pStudioHdr, int nBodyIndex, const Vector& viewtarget )
{
VectorCopy( viewtarget, m_RC.m_ViewTarget );
}
//-----------------------------------------------------------------------------
// Returns information about the ambient light samples
//-----------------------------------------------------------------------------
static TableVector s_pAmbientLightDir[6] =
{
{ 1, 0, 0 },
{ -1, 0, 0 },
{ 0, 1, 0 },
{ 0, -1, 0 },
{ 0, 0, 1 },
{ 0, 0, -1 },
};
int CStudioRenderContext::GetNumAmbientLightSamples()
{
return 6;
}
const Vector *CStudioRenderContext::GetAmbientLightDirections()
{
return (const Vector*)s_pAmbientLightDir;
}
//-----------------------------------------------------------------------------
// Methods related to LOD
//-----------------------------------------------------------------------------
int CStudioRenderContext::GetNumLODs( const studiohwdata_t &hardwareData ) const
{
return hardwareData.m_NumLODs;
}
float CStudioRenderContext::GetLODSwitchValue( const studiohwdata_t &hardwareData, int nLOD ) const
{
return hardwareData.m_pLODs[nLOD].m_SwitchPoint;
}
void CStudioRenderContext::SetLODSwitchValue( studiohwdata_t &hardwareData, int nLOD, float flSwitchValue )
{
// NOTE: This must block the hardware thread since it reads this data.
// This method is only used in tools, though.
MaterialLock_t hLock = g_pMaterialSystem->Lock();
hardwareData.m_pLODs[nLOD].m_SwitchPoint = flSwitchValue;
g_pMaterialSystem->Unlock( hLock );
}
//-----------------------------------------------------------------------------
// Returns the first n materials. The studiohdr material list is the superset
// for all lods.
//-----------------------------------------------------------------------------
int CStudioRenderContext::GetMaterialList( studiohdr_t *pStudioHdr, int count, IMaterial** ppMaterials )
{
AssertMsg( pStudioHdr, "Don't ignore this assert! CStudioRenderContext::GetMaterialList() has null pStudioHdr." );
if ( !pStudioHdr )
return 0;
if ( pStudioHdr->textureindex == 0 )
return 0;
// iterate each texture
int i;
int j;
int found = 0;
for ( i = 0; i < pStudioHdr->numtextures; i++ )
{
char szPath[MAX_PATH];
IMaterial *pMaterial = NULL;
// iterate quietly through all specified directories until a valid material is found
for ( j = 0; j < pStudioHdr->numcdtextures && IsErrorMaterial( pMaterial ); j++ )
{
// If we don't do this, we get filenames like "materials\\blah.vmt".
const char *textureName = pStudioHdr->pTexture( i )->pszName();
if ( textureName[0] == CORRECT_PATH_SEPARATOR || textureName[0] == INCORRECT_PATH_SEPARATOR )
++textureName;
// This prevents filenames like /models/blah.vmt.
const char *pCdTexture = pStudioHdr->pCdtexture( j );
if ( pCdTexture[0] == CORRECT_PATH_SEPARATOR || pCdTexture[0] == INCORRECT_PATH_SEPARATOR )
++pCdTexture;
V_ComposeFileName( pCdTexture, textureName, szPath, sizeof( szPath ) );
if ( pStudioHdr->flags & STUDIOHDR_FLAGS_OBSOLETE )
{
pMaterial = g_pMaterialSystem->FindMaterialEx( "models/obsolete/obsolete", TEXTURE_GROUP_MODEL, MATERIAL_FINDCONTEXT_ISONAMODEL, false );
}
else
{
pMaterial = g_pMaterialSystem->FindMaterialEx( szPath, TEXTURE_GROUP_MODEL, MATERIAL_FINDCONTEXT_ISONAMODEL, false );
}
}
if ( !pMaterial )
continue;
if ( found < count )
{
int k;
for ( k=0; k<found; k++ )
{
if ( ppMaterials[k] == pMaterial )
break;
}
if ( k >= found )
{
// add uniquely
ppMaterials[found++] = pMaterial;
}
}
else
{
break;
}
}
return found;
}
int CStudioRenderContext::GetMaterialListFromBodyAndSkin( MDLHandle_t studio, int nSkin, int nBody, int nCountOutputMaterials, IMaterial** ppOutputMaterials )
{
int found = 0;
studiohwdata_t *pStudioHWData = g_pMDLCache->GetHardwareData( studio );
if ( pStudioHWData == NULL )
return 0;
for ( int lodID = pStudioHWData->m_RootLOD; lodID < pStudioHWData->m_NumLODs; lodID++ )
{
studiohdr_t *pStudioHdr = g_pMDLCache->GetStudioHdr( studio );
IMaterial **ppInputMaterials = pStudioHWData->m_pLODs[lodID].ppMaterials;
if ( nSkin >= pStudioHdr->numskinfamilies )
{
nSkin = 0;
}
short *pSkinRef = pStudioHdr->pSkinref( nSkin * pStudioHdr->numskinref );
for (int i=0 ; i < pStudioHdr->numbodyparts ; i++)
{
mstudiomodel_t *pModel = NULL;
R_StudioSetupModel( i, nBody, &pModel, pStudioHdr );
// Iterate over all the meshes.... each mesh is a new material
for( int k = 0; k < pModel->nummeshes; ++k )
{
mstudiomesh_t *pMesh = pModel->pMesh(k);
IMaterial *pMaterial = ppInputMaterials[pSkinRef[pMesh->material]];
Assert( pMaterial );
int m;
for ( m=0; m<found; m++ )
{
if ( ppOutputMaterials[m] == pMaterial )
break;
}
if ( m >= found )
{
// add uniquely
ppOutputMaterials[found++] = pMaterial;
// No more room to store additional materials!
if ( found >= nCountOutputMaterials )
return found;
}
}
}
}
return found;
}
//-----------------------------------------------------------------------------
// Returns perf stats about a particular model
//-----------------------------------------------------------------------------
void CStudioRenderContext::GetPerfStats( DrawModelResults_t *pResults, const DrawModelInfo_t &info, CUtlBuffer *pSpewBuf ) const
{
pResults->m_ActualTriCount = pResults->m_TextureMemoryBytes = 0;
pResults->m_Materials.RemoveAll();
Assert( info.m_Lod >= 0 );
if ( info.m_Lod < 0 || !info.m_pHardwareData->m_pLODs )
return;
studiomeshdata_t *pStudioMeshes = info.m_pHardwareData->m_pLODs[info.m_Lod].m_pMeshData;
// Set up an array that keeps up with the number of used hardware bones in the models.
CUtlVector<bool> hardwareBonesUsed;
hardwareBonesUsed.EnsureCount( info.m_pStudioHdr->numbones );
int i;
for( i = 0; i < info.m_pStudioHdr->numbones; i++ )
{
hardwareBonesUsed[i] = false;
}
// Warning( "\n\n\n" );
pResults->m_NumMaterials = 0;
int numBoneStateChangeBatches = 0;
int numBoneStateChanges = 0;
// Iterate over every submodel...
IMaterial **ppMaterials = info.m_pHardwareData->m_pLODs[info.m_Lod].ppMaterials;
int nSkin = info.m_Skin;
if ( nSkin >= info.m_pStudioHdr->numskinfamilies )
{
nSkin = 0;
}
short *pSkinRef = info.m_pStudioHdr->pSkinref( nSkin * info.m_pStudioHdr->numskinref );
pResults->m_NumBatches = 0;
for (i=0 ; i < info.m_pStudioHdr->numbodyparts ; i++)
{
mstudiomodel_t *pModel = NULL;
R_StudioSetupModel( i, info.m_Body, &pModel, info.m_pStudioHdr );
// Iterate over all the meshes.... each mesh is a new material
int k;
for( k = 0; k < pModel->nummeshes; ++k )
{
mstudiomesh_t *pMesh = pModel->pMesh(k);
IMaterial *pMaterial = ppMaterials[pSkinRef[pMesh->material]];
Assert( pMaterial );
studiomeshdata_t *pMeshData = &pStudioMeshes[pMesh->meshid];
if( pMeshData->m_NumGroup == 0 )
continue;
Assert( pResults->m_NumMaterials == pResults->m_Materials.Count() );
pResults->m_NumMaterials++;
if( pResults->m_NumMaterials < MAX_DRAW_MODEL_INFO_MATERIALS )
{
pResults->m_Materials.AddToTail( pMaterial );
}
else
{
Assert( 0 );
}
if( pSpewBuf )
{
pSpewBuf->Printf( " material: %s\n", pMaterial->GetName() );
}
int numPasses = m_RC.m_pForcedMaterial ? m_RC.m_pForcedMaterial->GetNumPasses() : pMaterial->GetNumPasses();
if( pSpewBuf )
{
pSpewBuf->Printf( " numPasses:%d\n", numPasses );
}
int bytes = pMaterial->GetTextureMemoryBytes();
pResults->m_TextureMemoryBytes += bytes;
if( pSpewBuf )
{
pSpewBuf->Printf( " texture memory: %d (Only valid in a rendering app)\n", bytes );
}
// Iterate over all stripgroups
int stripGroupID;
for( stripGroupID = 0; stripGroupID < pMeshData->m_NumGroup; stripGroupID++ )
{
studiomeshgroup_t *pMeshGroup = &pMeshData->m_pMeshGroup[stripGroupID];
bool bIsFlexed = ( pMeshGroup->m_Flags & MESHGROUP_IS_FLEXED ) != 0;
bool bIsHWSkinned = ( pMeshGroup->m_Flags & MESHGROUP_IS_HWSKINNED ) != 0;
if( pSpewBuf )
{
pSpewBuf->Printf( " %d batch(es):\n", ( int )pMeshGroup->m_NumStrips );
}
// Iterate over all strips. . . each strip potentially changes bones states.
int stripID;
for( stripID = 0; stripID < pMeshGroup->m_NumStrips; stripID++ )
{
pResults->m_NumBatches++;
OptimizedModel::StripHeader_t *pStripData = &pMeshGroup->m_pStripData[stripID];
numBoneStateChangeBatches++;
numBoneStateChanges += pStripData->numBoneStateChanges;
if( bIsHWSkinned )
{
// Only count bones as hardware bones if we are using hardware skinning here.
int boneID;
for( boneID = 0; boneID < pStripData->numBoneStateChanges; boneID++ )
{
OptimizedModel::BoneStateChangeHeader_t *pBoneStateChange = pStripData->pBoneStateChange( boneID );
hardwareBonesUsed[pBoneStateChange->newBoneID] = true;
}
}
if( pStripData->flags & OptimizedModel::STRIP_IS_TRILIST )
{
// TODO: need to factor in bIsFlexed and bIsHWSkinned
int numTris = pStripData->numIndices / 3;
if( pSpewBuf )
{
pSpewBuf->Printf( " %s%s", bIsFlexed ? "flexed " : "nonflexed ",
bIsHWSkinned ? "hwskinned " : "swskinned " );
pSpewBuf->Printf( "tris: %d ", numTris );
pSpewBuf->Printf( "bone changes: %d bones/strip: %d\n", pStripData->numBoneStateChanges,
( int )pStripData->numBones );
}
pResults->m_ActualTriCount += numTris * numPasses;
}
else if( pStripData->flags & OptimizedModel::STRIP_IS_TRISTRIP )
{
Assert( 0 ); // FIXME: fill this in when we start using strips again.
}
else
{
Assert( 0 );
}
}
}
}
}
if( pSpewBuf )
{
char nil = '\0';
pSpewBuf->Put( &nil, 1 );;
}
pResults->m_NumHardwareBones = 0;
for( i = 0; i < info.m_pStudioHdr->numbones; i++ )
{
if( hardwareBonesUsed[i] )
{
pResults->m_NumHardwareBones++;
}
}
}
//-----------------------------------------------------------------------------
// Begin/end frame
//-----------------------------------------------------------------------------
static ConVar r_hwmorph( "r_hwmorph", "1", FCVAR_CHEAT );
void CStudioRenderContext::BeginFrame( void )
{
// Cache a few values here so I don't have to in software inner loops:
Assert( g_pMaterialSystemHardwareConfig );
m_RC.m_Config.m_bSupportsVertexAndPixelShaders = g_pMaterialSystemHardwareConfig->SupportsVertexAndPixelShaders();
m_RC.m_Config.m_bSupportsOverbright = g_pMaterialSystemHardwareConfig->SupportsOverbright();
m_RC.m_Config.m_bEnableHWMorph = r_hwmorph.GetInt() != 0;
// Haven't implemented the hw morph with threading yet
if ( g_pMaterialSystem->GetThreadMode() != MATERIAL_SINGLE_THREADED )
{
m_RC.m_Config.m_bEnableHWMorph = false;
}
m_RC.m_Config.m_bStatsMode = false;
g_pStudioRenderImp->PrecacheGlint();
}
void CStudioRenderContext::EndFrame( void )
{
}
//-----------------------------------------------------------------------------
// Methods related to config
//-----------------------------------------------------------------------------
void CStudioRenderContext::UpdateConfig( const StudioRenderConfig_t& config )
{
memcpy( &m_RC.m_Config, &config, sizeof( StudioRenderConfig_t ) );
}
void CStudioRenderContext::GetCurrentConfig( StudioRenderConfig_t& config )
{
memcpy( &config, &m_RC.m_Config, sizeof( StudioRenderConfig_t ) );
}
//-----------------------------------------------------------------------------
// Material overrides
//-----------------------------------------------------------------------------
void CStudioRenderContext::ForcedMaterialOverride( IMaterial *newMaterial, OverrideType_t nOverrideType )
{
m_RC.m_pForcedMaterial = newMaterial;
m_RC.m_nForcedMaterialType = nOverrideType;
}
//-----------------------------------------------------------------------------
// Return the material overrides
//-----------------------------------------------------------------------------
void CStudioRenderContext::GetMaterialOverride( IMaterial** ppOutForcedMaterial, OverrideType_t* pOutOverrideType )
{
Assert( ppOutForcedMaterial != NULL && pOutOverrideType != NULL );
*ppOutForcedMaterial = m_RC.m_pForcedMaterial;
*pOutOverrideType = m_RC.m_nForcedMaterialType;
}
//-----------------------------------------------------------------------------
// Sets the view state
//-----------------------------------------------------------------------------
void CStudioRenderContext::SetViewState( const Vector& viewOrigin,
const Vector& viewRight, const Vector& viewUp, const Vector& viewPlaneNormal )
{
VectorCopy( viewOrigin, m_RC.m_ViewOrigin );
VectorCopy( viewRight, m_RC.m_ViewRight );
VectorCopy( viewUp, m_RC.m_ViewUp );
VectorCopy( viewPlaneNormal, m_RC.m_ViewPlaneNormal );
}
//-----------------------------------------------------------------------------
// Sets lighting state
//-----------------------------------------------------------------------------
void CStudioRenderContext::SetAmbientLightColors( const Vector *pColors )
{
for( int i = 0; i < 6; i++ )
{
VectorCopy( pColors[i], m_RC.m_LightBoxColors[i].AsVector3D() );
m_RC.m_LightBoxColors[i][3] = 1.0f;
}
// FIXME: Would like to get this into the render thread, but there's systemic confusion
// about whether to set lighting state here or in the material system
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->SetAmbientLightCube( m_RC.m_LightBoxColors );
}
void CStudioRenderContext::SetAmbientLightColors( const Vector4D *pColors )
{
memcpy( m_RC.m_LightBoxColors, pColors, 6 * sizeof(Vector4D) );
// FIXME: Would like to get this into the render thread, but there's systemic confusion
// about whether to set lighting state here or in the material system
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->SetAmbientLightCube( m_RC.m_LightBoxColors );
}
void CStudioRenderContext::SetLocalLights( int nLightCount, const LightDesc_t *pLights )
{
m_RC.m_NumLocalLights = CopyLocalLightingState( MAXLOCALLIGHTS, m_RC.m_LocalLights, nLightCount, pLights );
// FIXME: Would like to get this into the render thread, but there's systemic confusion
// about whether to set lighting state here or in the material system
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
if ( m_RC.m_Config.bSoftwareLighting || m_RC.m_NumLocalLights == 0 )
{
pRenderContext->DisableAllLocalLights();
}
else
{
int i;
int nMaxLightCount = g_pMaterialSystemHardwareConfig->MaxNumLights();
int nLightCount = min( m_RC.m_NumLocalLights, nMaxLightCount );
for( i = 0; i < nLightCount; i++ )
{
pRenderContext->SetLight( i, m_RC.m_LocalLights[i] );
}
for( ; i < nMaxLightCount; i++ )
{
LightDesc_t desc;
desc.m_Type = MATERIAL_LIGHT_DISABLE;
pRenderContext->SetLight( i, desc );
}
}
}
//-----------------------------------------------------------------------------
// Sets the color modulation
//-----------------------------------------------------------------------------
void CStudioRenderContext::SetColorModulation( const float* pColor )
{
VectorCopy( pColor, m_RC.m_ColorMod );
}
void CStudioRenderContext::SetAlphaModulation( float alpha )
{
m_RC.m_AlphaMod = alpha;
}
//-----------------------------------------------------------------------------
// Used to set bone-to-world transforms.
// FIXME: Should this be a lock/unlock pattern so we can't read after unlock?
//-----------------------------------------------------------------------------
matrix3x4_t* CStudioRenderContext::LockBoneMatrices( int nCount )
{
MEM_ALLOC_CREDIT_( "CStudioRenderContext::m_BoneToWorldMatrices" );
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
CMatRenderData<matrix3x4_t> rdMatrix( pRenderContext );
matrix3x4_t *pDest = rdMatrix.Lock( nCount );
return pDest;
}
void CStudioRenderContext::UnlockBoneMatrices()
{
}
//-----------------------------------------------------------------------------
// Allocates flex weights
//-----------------------------------------------------------------------------
void CStudioRenderContext::LockFlexWeights( int nWeightCount, float **ppFlexWeights, float **ppFlexDelayedWeights )
{
MEM_ALLOC_CREDIT_( "CStudioRenderContext::m_FlexWeights" );
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
CMatRenderData<float> rdFlex( pRenderContext );
CMatRenderData<float> rdFlexDelayed( pRenderContext );
float *pFlexOut = rdFlex.Lock( nWeightCount );
for ( int i = 0; i < nWeightCount; i++ )
{
pFlexOut[i] = 0.0f;
}
*ppFlexWeights = pFlexOut;
if ( ppFlexDelayedWeights )
{
pFlexOut = rdFlexDelayed.Lock( nWeightCount );
for ( int i = 0; i < nWeightCount; i++ )
{
pFlexOut[i] = 0.0f;
}
*ppFlexDelayedWeights = pFlexOut;
}
}
void CStudioRenderContext::UnlockFlexWeights()
{
}
//-----------------------------------------------------------------------------
// Methods related to flex weights
//-----------------------------------------------------------------------------
static ConVar r_randomflex( "r_randomflex", "0", FCVAR_CHEAT );
//-----------------------------------------------------------------------------
// This will generate random flex data that has a specified # of non-zero values
//-----------------------------------------------------------------------------
void CStudioRenderContext::GenerateRandomFlexWeights( int nWeightCount, float* pWeights, float *pDelayedWeights )
{
int nRandomFlex = r_randomflex.GetInt();
if ( nRandomFlex <= 0 || !pWeights )
return;
if ( nRandomFlex > nWeightCount )
{
nRandomFlex = nWeightCount;
}
int *pIndices = (int*)_alloca( nWeightCount * sizeof(int) );
for ( int i = 0; i < nWeightCount; ++i )
{
pIndices[i] = i;
}
// Shuffle
for ( int i = 0; i < nWeightCount; ++i )
{
int n = RandomInt( 0, nWeightCount-1 );
int nTemp = pIndices[n];
pIndices[n] = pIndices[i];
pIndices[i] = nTemp;
}
memset( pWeights, 0, nWeightCount * sizeof(float) );
for ( int i = 0; i < nRandomFlex; ++i )
{
pWeights[ pIndices[i] ] = RandomFloat( 0.0f, 1.0f );
}
if ( pDelayedWeights )
{
memset( pDelayedWeights, 0, nWeightCount * sizeof(float) );
for ( int i = 0; i < nRandomFlex; ++i )
{
pDelayedWeights[ pIndices[i] ] = RandomFloat( 0.0f, 1.0f );
}
}
}
//-----------------------------------------------------------------------------
// Computes LOD
//-----------------------------------------------------------------------------
int CStudioRenderContext::ComputeRenderLOD( IMatRenderContext *pRenderContext,
const DrawModelInfo_t& info, const Vector &origin, float *pMetric )
{
int lod = info.m_Lod;
int lastlod = info.m_pHardwareData->m_NumLODs - 1;
if ( pMetric )
{
*pMetric = 0.0f;
}
if ( lod == USESHADOWLOD )
return lastlod;
if ( lod != -1 )
return clamp( lod, info.m_pHardwareData->m_RootLOD, lastlod );
float screenSize = pRenderContext->ComputePixelWidthOfSphere( origin, 0.5f );
lod = ComputeModelLODAndMetric( info.m_pHardwareData, screenSize, pMetric );
// make sure we have a valid lod
if ( info.m_pStudioHdr->flags & STUDIOHDR_FLAGS_HASSHADOWLOD )
{
lastlod--;
}
lod = clamp( lod, info.m_pHardwareData->m_RootLOD, lastlod );
return lod;
}
//-----------------------------------------------------------------------------
// This invokes proxies of all materials that are queued to be rendered
// It has the effect of ensuring the material vars are in the correct state
// since material var sets generated by the proxy bind are queued.
//-----------------------------------------------------------------------------
void CStudioRenderContext::InvokeBindProxies( const DrawModelInfo_t &info )
{
if ( m_RC.m_pForcedMaterial )
{
if ( m_RC.m_nForcedMaterialType == OVERRIDE_NORMAL && m_RC.m_pForcedMaterial->HasProxy() )
{
m_RC.m_pForcedMaterial->CallBindProxy( info.m_pClientEntity );
}
return;
}
// get skinref array
int nSkin = ( m_RC.m_Config.skin > 0 ) ? m_RC.m_Config.skin : info.m_Skin;
short *pSkinRef = info.m_pStudioHdr->pSkinref( 0 );
if ( nSkin > 0 && nSkin < info.m_pStudioHdr->numskinfamilies )
{
pSkinRef += ( nSkin * info.m_pStudioHdr->numskinref );
}
// This is used to ensure proxies are only called once
int nBufSize = info.m_pStudioHdr->numtextures * sizeof(bool);
bool *pProxyCalled = (bool*)stackalloc( nBufSize );
memset( pProxyCalled, 0, nBufSize );
IMaterial **ppMaterials = info.m_pHardwareData->m_pLODs[ info.m_Lod ].ppMaterials;
mstudiomodel_t *pModel;
for ( int i=0 ; i < info.m_pStudioHdr->numbodyparts; ++i )
{
R_StudioSetupModel( i, info.m_Body, &pModel, info.m_pStudioHdr );
for ( int somethingOtherThanI = 0; somethingOtherThanI < pModel->nummeshes; ++somethingOtherThanI)
{
mstudiomesh_t *pMesh = pModel->pMesh(somethingOtherThanI);
int nMaterialIndex = pSkinRef[ pMesh->material ];
if ( pProxyCalled[ nMaterialIndex ] )
continue;
pProxyCalled[ nMaterialIndex ] = true;
IMaterial* pMaterial = ppMaterials[ nMaterialIndex ];
if ( pMaterial && pMaterial->HasProxy() )
{
pMaterial->CallBindProxy( info.m_pClientEntity );
}
}
}
}
//-----------------------------------------------------------------------------
// Draws a model
//-----------------------------------------------------------------------------
void CStudioRenderContext::DrawModel( DrawModelResults_t *pResults, const DrawModelInfo_t& info,
matrix3x4_t *pBoneToWorld, float *pFlexWeights, float *pFlexDelayedWeights, const Vector &origin, int flags )
{
// Set to zero in case we don't render anything.
if ( pResults )
{
pResults->m_ActualTriCount = pResults->m_TextureMemoryBytes = 0;
}
if( !info.m_pStudioHdr || !info.m_pHardwareData ||
!info.m_pHardwareData->m_NumLODs || !info.m_pHardwareData->m_pLODs )
{
return;
}
// Replace the flex weight data with random data for testing
GenerateRandomFlexWeights( info.m_pStudioHdr->numflexdesc, pFlexWeights, pFlexDelayedWeights );
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
float flMetric;
const_cast<DrawModelInfo_t*>( &info )->m_Lod = ComputeRenderLOD( pRenderContext, info, origin, &flMetric );
if ( pResults )
{
pResults->m_nLODUsed = info.m_Lod;
pResults->m_flLODMetric = flMetric;
}
MaterialLock_t hLock = 0;
if ( flags & STUDIORENDER_DRAW_ACCURATETIME )
{
VPROF("STUDIORENDER_DRAW_ACCURATETIME");
// Flush the material system before timing this model:
hLock = g_pMaterialSystem->Lock();
g_pMaterialSystem->Flush(true);
}
if ( pResults )
{
pResults->m_RenderTime.Start();
}
FlexWeights_t flex;
flex.m_pFlexWeights = pFlexWeights ? pFlexWeights : s_pZeroFlexWeights;
flex.m_pFlexDelayedWeights = pFlexDelayedWeights ? pFlexDelayedWeights : flex.m_pFlexWeights;
ICallQueue *pCallQueue = pRenderContext->GetCallQueue();
if ( !pCallQueue || studio_queue_mode.GetInt() == 0 )
{
g_pStudioRenderImp->DrawModel( info, m_RC, pBoneToWorld, flex, flags );
}
else
{
CMatRenderData<matrix3x4_t> rdMatrix( pRenderContext, info.m_pStudioHdr->numbones, pBoneToWorld );
CMatRenderData<float> rdFlex( pRenderContext );
CMatRenderData<float> rdFlexDelayed( pRenderContext );
InvokeBindProxies( info );
pBoneToWorld = rdMatrix.Base();
if ( info.m_pStudioHdr->numflexdesc != 0 )
{
rdFlex.Lock( info.m_pStudioHdr->numflexdesc, flex.m_pFlexWeights );
flex.m_pFlexWeights = rdFlex.Base();
if ( !pFlexDelayedWeights )
{
flex.m_pFlexDelayedWeights = flex.m_pFlexWeights;
}
else
{
rdFlexDelayed.Lock( info.m_pStudioHdr->numflexdesc, flex.m_pFlexDelayedWeights );
flex.m_pFlexDelayedWeights = rdFlexDelayed.Base();
}
}
pCallQueue->QueueCall( g_pStudioRenderImp, &CStudioRender::DrawModel, info, m_RC, pBoneToWorld, flex, flags );
}
if( flags & STUDIORENDER_DRAW_ACCURATETIME )
{
VPROF( "STUDIORENDER_DRAW_ACCURATETIME" );
// Make sure this model is completely drawn before ending the timer:
g_pMaterialSystem->Flush(true);
g_pMaterialSystem->Flush(true);
g_pMaterialSystem->Unlock( hLock );
}
if ( pResults )
{
pResults->m_RenderTime.End();
if( flags & STUDIORENDER_DRAW_GET_PERF_STATS )
{
GetPerfStats( pResults, info, 0 );
}
}
}
void CStudioRenderContext::DrawModelArray( const DrawModelInfo_t &drawInfo, int arrayCount, model_array_instance_t *pInstanceData, int instanceStride, int flags )
{
// UNDONE: Support queue mode?
g_pStudioRenderImp->DrawModelArray( drawInfo, m_RC, arrayCount, pInstanceData, instanceStride, flags );
}
//-----------------------------------------------------------------------------
// Methods related to rendering static props
//-----------------------------------------------------------------------------
void CStudioRenderContext::DrawModelStaticProp( const DrawModelInfo_t& info, const matrix3x4_t &modelToWorld, int flags )
{
if ( info.m_Lod < info.m_pHardwareData->m_RootLOD )
{
const_cast< DrawModelInfo_t* >( &info )->m_Lod = info.m_pHardwareData->m_RootLOD;
}
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
ICallQueue *pCallQueue = pRenderContext->GetCallQueue();
if ( !pCallQueue || studio_queue_mode.GetInt() == 0 )
{
g_pStudioRenderImp->DrawModelStaticProp( info, m_RC, modelToWorld, flags );
}
else
{
InvokeBindProxies( info );
pCallQueue->QueueCall( g_pStudioRenderImp, &CStudioRender::DrawModelStaticProp, info, m_RC, modelToWorld, flags );
}
}
void CStudioRenderContext::DrawStaticPropDecals( const DrawModelInfo_t &info, const matrix3x4_t &modelToWorld )
{
QUEUE_STUDIORENDER_CALL( DrawStaticPropDecals, CStudioRender, g_pStudioRenderImp, info, m_RC, modelToWorld );
}
void CStudioRenderContext::DrawStaticPropShadows( const DrawModelInfo_t &info, const matrix3x4_t &modelToWorld, int flags )
{
QUEUE_STUDIORENDER_CALL( DrawStaticPropShadows, CStudioRender, g_pStudioRenderImp, info, m_RC, modelToWorld, flags );
}
//-----------------------------------------------------------------------------
// Methods related to shadows
//-----------------------------------------------------------------------------
void CStudioRenderContext::AddShadow( IMaterial* pMaterial, void* pProxyData,
FlashlightState_t *pFlashlightState, VMatrix *pWorldToTexture, ITexture *pFlashlightDepthTexture )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
ICallQueue *pCallQueue = pRenderContext->GetCallQueue();
if ( !pCallQueue || studio_queue_mode.GetInt() == 0 )
{
g_pStudioRenderImp->AddShadow( pMaterial, pProxyData, pFlashlightState, pWorldToTexture, pFlashlightDepthTexture );
}
else
{
// NOTE: We don't need to make proxies work, because proxies are only ever used
// when casting shadows onto props, which we don't do..that feature is disabled.
// When casting flashlights onto mdls, which we *do* use, the proxy is NULL.
Assert( pProxyData == NULL );
if ( pProxyData != NULL )
{
Warning( "Cannot call CStudioRenderContext::AddShadows w/ proxies in queued mode!\n" );
return;
}
CMatRenderData< FlashlightState_t > rdFlashlight( pRenderContext, 1, pFlashlightState );
CMatRenderData< VMatrix > rdMatrix( pRenderContext, 1, pWorldToTexture );
pCallQueue->QueueCall( g_pStudioRenderImp, &CStudioRender::AddShadow, pMaterial,
(void*)NULL, rdFlashlight.Base(), rdMatrix.Base(), pFlashlightDepthTexture );
}
}
void CStudioRenderContext::ClearAllShadows()
{
QUEUE_STUDIORENDER_CALL( ClearAllShadows, CStudioRender, g_pStudioRenderImp );
}
//-----------------------------------------------------------------------------
// Methods related to decals
//-----------------------------------------------------------------------------
void CStudioRenderContext::DestroyDecalList( StudioDecalHandle_t handle )
{
QUEUE_STUDIORENDER_CALL( DestroyDecalList, CStudioRender, g_pStudioRenderImp, handle );
}
void CStudioRenderContext::AddDecal( StudioDecalHandle_t handle, studiohdr_t *pStudioHdr,
matrix3x4_t *pBoneToWorld, const Ray_t& ray, const Vector& decalUp,
IMaterial* pDecalMaterial, float radius, int body, bool noPokethru, int maxLODToDecal )
{
// This substition always has to be done in the main thread, so do it here.
pDecalMaterial = GetModelSpecificDecalMaterial( pDecalMaterial );
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
Assert( pRenderContext->IsRenderData( pBoneToWorld ) );
QUEUE_STUDIORENDER_CALL_RC( AddDecal, CStudioRender, g_pStudioRenderImp, pRenderContext,
handle, m_RC, pBoneToWorld, pStudioHdr, ray, decalUp, pDecalMaterial, radius,
body, noPokethru, maxLODToDecal );
}
// Function to do replacement because we always need to do this from the main thread.
IMaterial* GetModelSpecificDecalMaterial( IMaterial* pDecalMaterial )
{
Assert( ThreadInMainThread() );
// Since we're adding this to a studio model, check the decal to see if
// there's an alternate form used for static props...
bool found;
IMaterialVar* pModelMaterialVar = pDecalMaterial->FindVar( "$modelmaterial", &found, false );
if ( found )
{
IMaterial* pModelMaterial = g_pMaterialSystem->FindMaterial( pModelMaterialVar->GetStringValue(), TEXTURE_GROUP_DECAL, false );
if ( !IsErrorMaterial( pModelMaterial ) )
{
return pModelMaterial;
}
}
return pDecalMaterial;
}