1625 lines
64 KiB
C++
1625 lines
64 KiB
C++
//===== Copyright © 1996-2007, Valve Corporation, All rights reserved. ======//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Revision: $
|
|
// $NoKeywords: $
|
|
//
|
|
// Fast path model rendering
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "modelrendersystem.h"
|
|
#include "model_types.h"
|
|
#include "iviewrender.h"
|
|
#include "tier3/tier3.h"
|
|
#include <algorithm>
|
|
#include "tier1/memstack.h"
|
|
#include "engine/ivdebugoverlay.h"
|
|
#include "shaderapi/ishaderapi.h"
|
|
#include "materialsystem/materialsystemutil.h"
|
|
#include "tier0/vprof.h"
|
|
|
|
// NOTE: This has to be the last file included!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Convars defined by other systems
|
|
//-----------------------------------------------------------------------------
|
|
ConVar r_lod( "r_lod", "-1" );
|
|
//ConVar r_shadowlod( "r_shadowlod", "-1" );
|
|
ConVar r_drawmodellightorigin( "r_DrawModelLightOrigin", "0", FCVAR_CHEAT );
|
|
extern ConVar g_CV_FlexSmooth;
|
|
extern ConVar r_fastzreject;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The client leaf system
|
|
//-----------------------------------------------------------------------------
|
|
class CModelRenderSystem : public CAutoGameSystem, public IModelRenderSystem
|
|
{
|
|
// Methods of IModelRenderSystem
|
|
public:
|
|
virtual void DrawModels( ModelRenderSystemData_t *pEntities, int nCount, ModelRenderMode_t renderMode );
|
|
virtual void ComputeTranslucentRenderData( ModelRenderSystemData_t *pModels, int nCount, TranslucentInstanceRenderData_t *pRenderData, TranslucentTempData_t *pTempData );
|
|
virtual void CleanupTranslucentTempData( TranslucentTempData_t *pTempData );
|
|
virtual IMaterial *GetFastPathColorMaterial() { return m_DebugMaterial; }
|
|
|
|
// Methods of IGameSystem
|
|
public:
|
|
virtual void LevelInitPostEntity();
|
|
virtual void LevelShutdownPreEntity();
|
|
|
|
// Other public methods
|
|
public:
|
|
CModelRenderSystem();
|
|
virtual ~CModelRenderSystem();
|
|
|
|
private:
|
|
struct ModelListNode_t
|
|
{
|
|
ModelRenderSystemData_t m_Entry;
|
|
int32 m_nInitialListIndex : 24;
|
|
int32 m_bBoneMerge : 1;
|
|
int32 m_nLOD : 7;
|
|
ShaderStencilState_t *m_pStencilState;
|
|
ModelListNode_t *m_pNext;
|
|
};
|
|
|
|
struct RenderModelInfo_t : public StudioArrayInstanceData_t
|
|
{
|
|
ModelRenderSystemData_t m_Entry;
|
|
ModelInstanceHandle_t m_hInstance;
|
|
matrix3x4a_t* m_pBoneToWorld;
|
|
uint32 m_nInitialListIndex : 24;
|
|
uint32 m_bSetupBonesOnly : 1;
|
|
uint32 m_bBoneMerge : 1;
|
|
};
|
|
|
|
struct ModelListByType_t : public StudioModelArrayInfo_t
|
|
{
|
|
RenderableLightingModel_t m_nLightingModel;
|
|
const model_t *m_pModel;
|
|
ModelListNode_t *m_pFirstNode;
|
|
int m_nCount;
|
|
int m_nSetupBoneCount;
|
|
uint32 m_nParentDepth : 31;
|
|
uint32 m_bWantsStencil : 1;
|
|
RenderModelInfo_t *m_pRenderModels;
|
|
ModelListByType_t *m_pNextLightingModel;
|
|
|
|
// speed up std::sort by implementing these
|
|
ModelListByType_t &operator=( const ModelListByType_t &rhs )
|
|
{
|
|
memcpy( this, &rhs, sizeof( ModelListByType_t ) );
|
|
return *this;
|
|
}
|
|
|
|
ModelListByType_t() {}
|
|
|
|
ModelListByType_t( const ModelListByType_t &rhs )
|
|
{
|
|
memcpy( this, &rhs, sizeof( ModelListByType_t ) );
|
|
}
|
|
};
|
|
|
|
struct LightingList_t
|
|
{
|
|
ModelListByType_t *m_pFirstModel;
|
|
int m_nCount;
|
|
int m_nTotalModelCount;
|
|
};
|
|
|
|
private:
|
|
int BucketModelsByMDL( ModelListByType_t *pModelList, ModelListNode_t *pModelListNodes, ModelRenderSystemData_t *pEntities, int nCount, ModelRenderMode_t renderMode, int *pModelsRenderingStencilCountOut );
|
|
bool AddModelToLists( int &nModelTypeCount, ModelListByType_t *pModelList, int &nModelNodeCount, ModelListNode_t *pModelListNodes, int nDataIndex, ModelRenderSystemData_t &data, ModelRenderMode_t renderMode );
|
|
void SortBucketsByDependency( int nModelTypeCount, ModelListByType_t *pModelList, LightingList_t *pLightingList );
|
|
void ComputeModelLODs( int nModelTypeCount, ModelListByType_t *pModelList, ModelListNode_t *pModelListNode, ModelRenderMode_t renderMode );
|
|
void SlamModelLODs( int nLOD, int nModelTypeCount, ModelListByType_t *pModelList, ModelListNode_t *pModelListNode );
|
|
void SortModels( RenderModelInfo_t *pSortedModelListNode, int nModelTypeCount, ModelListByType_t *pModelList, ModelListNode_t *pModelListNode );
|
|
static bool SortLessFunc( const RenderModelInfo_t &left, const RenderModelInfo_t &right );
|
|
void SetupBones( int nModelTypeCount, ModelListByType_t *pModelList );
|
|
void SetupFlexes( int nModelTypeCount, ModelListByType_t *pModelList );
|
|
void ComputeLightingOrigin( ModelListByType_t &list, LightingQuery_t *pLightingQuery, int nQueryStride );
|
|
int SetupLighting( LightingList_t *pLightingList, int nModelTypeCount, ModelListByType_t *pModelList, DataCacheHandle_t *pColorMeshHandles, ModelRenderMode_t renderMode );
|
|
void RenderModels( StudioModelArrayInfo2_t *pInfo, int nModelTypeCount, ModelListByType_t *pModelList, int nTotalModelCount, ModelRenderMode_t renderMode );
|
|
void SetupTranslucentData( int nModelTypeCount, ModelListByType_t *pModelList, int nTotalModelCount, TranslucentInstanceRenderData_t *pRenderData );
|
|
void SetupFlashlightsAndDecals( StudioModelArrayInfo2_t *pInfo, int nModelTypeCount, ModelListByType_t *pModelList, int nTotalModelCount, RenderModelInfo_t *pModelInfo, ModelRenderMode_t renderMode );
|
|
void SetupPerInstanceColorModulation( int nModelTypeCount, ModelListByType_t *pModelList );
|
|
void DebugDrawLightingOrigin( const ModelListByType_t &list, const RenderModelInfo_t &model );
|
|
int BuildLightingList( ModelListByType_t **ppLists, unsigned char *pFlags, int *pTotalModels, const LightingList_t &lightingList );
|
|
int SetupStaticPropLighting( LightingList_t &lightingList, DataCacheHandle_t *pColorMeshHandles );
|
|
void SetupStandardLighting( LightingList_t &lightingList );
|
|
int SetupPhysicsPropLighting( LightingList_t &lightingList, DataCacheHandle_t *pColorMeshHandles );
|
|
|
|
|
|
void HookUpStaticLightingState( int nCount, ModelListByType_t **ppLists, unsigned char *pFlags, ITexture **ppEnvCubemap, MaterialLightingState_t *pLightingState, MaterialLightingState_t *pDecalLightingState, ColorMeshInfo_t **ppColorMeshInfo );
|
|
void RenderDebugOverlays( int nModelTypeCount, ModelListByType_t *pModelList, ModelRenderMode_t renderMode );
|
|
void RenderVCollideDebugOverlay( int nModelTypeCount, ModelListByType_t *pModelList );
|
|
void RenderBBoxDebugOverlay( int nModelTypeCount, ModelListByType_t *pModelList );
|
|
int ComputeParentDepth( C_BaseEntity *pEnt );
|
|
static bool DependencySortLessFunc( const ModelListByType_t &left, const ModelListByType_t &right );
|
|
static bool StencilSortLessFunc( const ModelListByType_t &left, const ModelListByType_t &right );
|
|
|
|
CMemoryStack m_BoneToWorld;
|
|
CTextureReference m_DefaultCubemap;
|
|
CMaterialReference m_DebugMaterial;
|
|
CMaterialReference m_ShadowBuild;
|
|
IMatRenderContext *m_pRenderContext;
|
|
|
|
CUtlMemoryFixedGrowable< DataCacheHandle_t, 1024 > m_ColorMeshHandles;
|
|
CUtlMemoryFixedGrowable< ModelListByType_t, 128 > m_ModelList;
|
|
CUtlMemoryFixedGrowable< ModelListNode_t, 1024 > m_ModelListNode;
|
|
CUtlMemoryFixedGrowable< RenderModelInfo_t, 1024 > m_RenderModelInfo;
|
|
int m_nColorMeshHandles;
|
|
int m_nModelTypeCount;
|
|
int m_nTotalModelCount;
|
|
bool m_bShadowDepth;
|
|
bool m_bHasInstanceData;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Singleton accessor
|
|
//-----------------------------------------------------------------------------
|
|
static CModelRenderSystem s_ModelRenderSystem;
|
|
extern IModelRenderSystem *g_pModelRenderSystem = &s_ModelRenderSystem;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
CModelRenderSystem::CModelRenderSystem()
|
|
{
|
|
m_bHasInstanceData = false;
|
|
m_BoneToWorld.Init( 1 * 1024 * 1024, 32 * 1024, 0, 32 );
|
|
}
|
|
|
|
CModelRenderSystem::~CModelRenderSystem()
|
|
{
|
|
m_BoneToWorld.Term();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Level init, shutdown
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::LevelInitPostEntity()
|
|
{
|
|
m_DefaultCubemap.Init( "engine/defaultcubemap", TEXTURE_GROUP_CUBE_MAP );
|
|
m_DebugMaterial.Init( "debug/debugempty", TEXTURE_GROUP_OTHER );
|
|
m_ShadowBuild.Init( "engine/shadowbuild", TEXTURE_GROUP_OTHER );
|
|
}
|
|
|
|
void CModelRenderSystem::LevelShutdownPreEntity()
|
|
{
|
|
m_DefaultCubemap.Shutdown();
|
|
m_DebugMaterial.Shutdown();
|
|
m_ShadowBuild.Shutdown();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// returns bone setup dependency depth
|
|
//-----------------------------------------------------------------------------
|
|
int CModelRenderSystem::ComputeParentDepth( C_BaseEntity *pEnt )
|
|
{
|
|
if ( !pEnt )
|
|
return 0;
|
|
|
|
int nDepth = 0;
|
|
while ( pEnt->IsFollowingEntity() || ( pEnt->GetMoveParent() && pEnt->GetParentAttachment() > 0 ) )
|
|
{
|
|
++nDepth;
|
|
pEnt = pEnt->GetMoveParent();
|
|
}
|
|
|
|
return nDepth;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Adds a model to the appropriate render lists
|
|
//-----------------------------------------------------------------------------
|
|
bool CModelRenderSystem::AddModelToLists( int &nModelTypeCount, ModelListByType_t *pModelList,
|
|
int &nModelNodeCount, ModelListNode_t *pModelListNodes, int nInitialListIndex, ModelRenderSystemData_t &data, ModelRenderMode_t renderMode )
|
|
{
|
|
// NOTE: we actually are bucketing both by model + also by lighting model
|
|
// Bucketing by lighting model is not strictly necessary, but doing so
|
|
// simplifies the code a lot in exchange for having two batches if the
|
|
// same model is used but a different lighting model, something that could
|
|
// theoretically happen if a static prop + physics prop use the same .mdl
|
|
// My thought is that even if this split happens, it will be rare, and
|
|
// we still will get a lot of sharing.
|
|
|
|
// L4D2: We'll also bucket by whether the model renders stencil or not.
|
|
// This allows us to keep stenciling models in the fastpath but group them together
|
|
// to be rendered AFTER the 360 Z prepass ends. (360 doesn't allow stencil rendering
|
|
// during the Z prepass).
|
|
|
|
const model_t *pModel = data.m_pRenderable->GetModel();
|
|
Assert( modelinfo->GetModelType( pModel ) == mod_studio );
|
|
|
|
RenderableLightingModel_t nLightingModel = LIGHTING_MODEL_NONE;
|
|
uint bWantsStencil = 0;
|
|
ShaderStencilState_t tempStencil;
|
|
if ( data.m_pModelRenderable )
|
|
{
|
|
data.m_pModelRenderable->GetRenderData( &nLightingModel, MODEL_DATA_LIGHTING_MODEL );
|
|
if ( renderMode == MODEL_RENDER_MODE_NORMAL )
|
|
{
|
|
// I considered making a MODEL_DATA_STENCIL_ENABLE renderdata type that would only return a bool
|
|
// if stencil was enabled, but it turns out most of the work for MODEL_DATA_STENCIL is computing
|
|
// that bool, so pulling this out into a separate piece didn't turn out to be a perf win.
|
|
bWantsStencil = data.m_pModelRenderable->GetRenderData( &tempStencil, MODEL_DATA_STENCIL ) ? 1 : 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ExecuteOnce( DevWarning( "data.m_pModelRenderable is NULL for %s\n", modelinfo->GetModelName( pModel ) ) );
|
|
}
|
|
|
|
bool bRetVal = bWantsStencil ? true : false;
|
|
|
|
int j;
|
|
for ( j = 0; j < nModelTypeCount; ++j )
|
|
{
|
|
if ( pModelList[j].m_pModel == pModel &&
|
|
pModelList[j].m_nLightingModel == nLightingModel &&
|
|
pModelList[j].m_bWantsStencil == bWantsStencil )
|
|
break;
|
|
}
|
|
|
|
if ( j == nModelTypeCount )
|
|
{
|
|
// Bail if we're rendering into shadow depth map and this model doesn't cast shadows
|
|
// NOTE: if m_pModelRenderable is NULL, it's a dependent bone setup so we need to keep it
|
|
studiohdr_t *pStudioHdr = modelinfo->GetStudiomodel( pModel );
|
|
if ( ( renderMode != MODEL_RENDER_MODE_NORMAL ) && data.m_pModelRenderable && ( ( pStudioHdr->flags & STUDIOHDR_FLAGS_DO_NOT_CAST_SHADOWS ) != 0 ) )
|
|
{
|
|
return bRetVal;
|
|
}
|
|
|
|
MDLHandle_t hMDL = modelinfo->GetCacheHandle( pModel );
|
|
studiohwdata_t *pHardwareData = g_pMDLCache->GetHardwareData( hMDL );
|
|
|
|
// This can occur if there was an error loading the model; for instance
|
|
// if the vtx and mdl are out of sync.
|
|
if ( !pHardwareData || !pHardwareData->m_pLODs )
|
|
{
|
|
AssertMsg( 0, UTIL_VarArgs( "%s failed to load and is causing EVIL in the model render system!!", pStudioHdr->name ) );
|
|
return bRetVal;
|
|
}
|
|
|
|
ModelListByType_t &list = pModelList[ nModelTypeCount ];
|
|
list.m_pModel = pModel;
|
|
list.m_nLightingModel = nLightingModel;
|
|
list.m_bWantsStencil = bWantsStencil;
|
|
list.m_pStudioHdr = pStudioHdr;
|
|
list.m_pHardwareData = pHardwareData;
|
|
list.m_nFlashlightCount = 0;
|
|
list.m_pFlashlights = NULL;
|
|
list.m_nCount = 0;
|
|
list.m_pFirstNode = 0;
|
|
list.m_pRenderModels = 0;
|
|
list.m_nParentDepth = 0;
|
|
list.m_pNextLightingModel = NULL;
|
|
j = nModelTypeCount++;
|
|
}
|
|
|
|
C_BaseEntity *pEntity = data.m_pRenderable->GetIClientUnknown()->GetBaseEntity();
|
|
uint nParentDepth = ComputeParentDepth( pEntity );
|
|
|
|
ModelListByType_t &list = pModelList[ j ];
|
|
ModelListNode_t &node = pModelListNodes[ nModelNodeCount++ ];
|
|
node.m_Entry = data;
|
|
node.m_nInitialListIndex = nInitialListIndex;
|
|
node.m_bBoneMerge = pEntity && pEntity->IsEffectActive( EF_BONEMERGE );
|
|
|
|
if ( bWantsStencil && ( renderMode == MODEL_RENDER_MODE_NORMAL ) )
|
|
{
|
|
CMatRenderData< ShaderStencilState_t > rdStencil( m_pRenderContext, 1 );
|
|
memcpy( &rdStencil[0], &tempStencil, sizeof( tempStencil ) );
|
|
node.m_pStencilState = &rdStencil[0];
|
|
}
|
|
else
|
|
{
|
|
node.m_pStencilState = NULL;
|
|
}
|
|
|
|
node.m_pNext = list.m_pFirstNode;
|
|
list.m_nParentDepth = MAX( list.m_nParentDepth, nParentDepth );
|
|
list.m_pFirstNode = &node;
|
|
++list.m_nCount;
|
|
|
|
return bRetVal;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// bucket models by type, return # of unique types
|
|
//-----------------------------------------------------------------------------
|
|
int CModelRenderSystem::BucketModelsByMDL( ModelListByType_t *pModelList, ModelListNode_t *pModelListNodes, ModelRenderSystemData_t *pEntities, int nCount, ModelRenderMode_t renderMode,
|
|
int *pModelsRenderingStencilCountOut )
|
|
{
|
|
int nModelTypeCount = 0;
|
|
int nModelNodeCount = 0;
|
|
*pModelsRenderingStencilCountOut = 0;
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
bool bModelWantsStencil = AddModelToLists( nModelTypeCount, pModelList, nModelNodeCount, pModelListNodes, i, pEntities[i], renderMode );
|
|
*pModelsRenderingStencilCountOut += bModelWantsStencil ? 1 : 0;
|
|
}
|
|
return nModelTypeCount;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sort model types function
|
|
//-----------------------------------------------------------------------------
|
|
inline bool CModelRenderSystem::DependencySortLessFunc( const ModelListByType_t &left, const ModelListByType_t &right )
|
|
{
|
|
// Ensures bone setup occurs in the correct order
|
|
if ( left.m_nParentDepth != right.m_nParentDepth )
|
|
return left.m_nParentDepth < right.m_nParentDepth;
|
|
|
|
// Ensure stenciling models are at the end of the list.
|
|
// This doesn't guarantee that stencil stuff is at the end because parent depth trumps it,
|
|
// so we'll have to sort again before rendering.
|
|
if ( left.m_bWantsStencil != right.m_bWantsStencil )
|
|
{
|
|
return left.m_bWantsStencil < right.m_bWantsStencil;
|
|
}
|
|
|
|
// Keep same models with different lighting types together
|
|
return left.m_pModel < right.m_pModel;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sorts so that bone setup occurs in the appropriate order (parents set up first)
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::SortBucketsByDependency( int nModelTypeCount, ModelListByType_t *pModelList, LightingList_t *pLightingList )
|
|
{
|
|
std::sort( pModelList, pModelList + nModelTypeCount, DependencySortLessFunc );
|
|
|
|
// Assign models to the appropriate lighting list
|
|
for ( int i = nModelTypeCount; --i >= 0; )
|
|
{
|
|
ModelListByType_t &list = pModelList[ i ];
|
|
|
|
// Hook into lighting list
|
|
if ( list.m_nLightingModel == LIGHTING_MODEL_NONE )
|
|
continue;
|
|
|
|
LightingList_t &lightList = pLightingList[ list.m_nLightingModel ];
|
|
list.m_pNextLightingModel = lightList.m_pFirstModel;
|
|
lightList.m_pFirstModel = &list;
|
|
++lightList.m_nCount;
|
|
lightList.m_nTotalModelCount += list.m_nCount;
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
// Don't want to allow some MDLs of type A to depend on MDLs of type B
|
|
// and other MDLS of type B to depend on type A because that would
|
|
// dramatically increase complexity of the system here. With this assumption,
|
|
// we can always have all models of the same type be set up at the same time,
|
|
// also improving cache efficiency.
|
|
for ( int i =0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[ i ];
|
|
if ( list.m_nParentDepth == 0 )
|
|
continue;
|
|
|
|
for( ModelListNode_t *pNode = list.m_pFirstNode; pNode; pNode = pNode->m_pNext )
|
|
{
|
|
C_BaseEntity *pEnt = pNode->m_Entry.m_pRenderable->GetIClientUnknown()->GetBaseEntity();
|
|
if ( !pEnt )
|
|
continue;
|
|
|
|
C_BaseEntity *pTest = pEnt;
|
|
while ( pEnt->IsFollowingEntity() || ( pEnt->GetMoveParent() && pEnt->GetParentAttachment() > 0 ) )
|
|
{
|
|
pEnt = pEnt->GetMoveParent();
|
|
const model_t *pModel = pEnt->GetModel();
|
|
|
|
bool bFound = false;
|
|
for ( int j = 0; j < nModelTypeCount; ++j )
|
|
{
|
|
if ( pModelList[j].m_pModel != pModel )
|
|
continue;
|
|
|
|
if ( pModelList[j].m_nParentDepth >= list.m_nParentDepth )
|
|
{
|
|
// NOTE: GetClassname() stores the name in a global, hence need to do the warning on 2 lines
|
|
Warning( "Bone setup dependency ordering issue [ent %s ", pTest->GetClassname() );
|
|
Warning( " depends on ent %s]!\n", pEnt->GetClassname() );
|
|
}
|
|
|
|
for( ModelListNode_t *pParentNode = pModelList[j].m_pFirstNode; pParentNode; pParentNode = pParentNode->m_pNext )
|
|
{
|
|
if ( pParentNode->m_Entry.m_pRenderable == pEnt->GetClientRenderable() )
|
|
{
|
|
bFound = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !bFound )
|
|
{
|
|
// NOTE: GetClassname() stores the name in a global, hence need to do the warning on 2 lines
|
|
// Warning( "Missing bone setup dependency [ent %s ", pTest->GetClassname() );
|
|
// Warning( "depends on ent %s]!\n", pEnt->GetClassname() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Slam model LODs to the appropriate level
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::SlamModelLODs( int nLOD, int nModelTypeCount, ModelListByType_t *pModelList, ModelListNode_t *pModelListNode )
|
|
{
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
int nLODCount = list.m_pHardwareData->m_NumLODs;
|
|
int nRootLOD = list.m_pHardwareData->m_RootLOD;
|
|
bool bHasShadowLOD = ( list.m_pStudioHdr->flags & STUDIOHDR_FLAGS_HASSHADOWLOD ) != 0;
|
|
int nMaxLOD = bHasShadowLOD ? nLODCount - 2 : nLODCount - 1;
|
|
|
|
for ( ModelListNode_t *pNode = list.m_pFirstNode; pNode; pNode = pNode->m_pNext )
|
|
{
|
|
pNode->m_nLOD = clamp( nLOD, nRootLOD, nMaxLOD );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute model LODs
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::ComputeModelLODs( int nModelTypeCount, ModelListByType_t *pModelList, ModelListNode_t *pModelListNode, ModelRenderMode_t renderMode )
|
|
{
|
|
if ( renderMode == MODEL_RENDER_MODE_RTT_SHADOWS )
|
|
{
|
|
// Slam to shadow lod
|
|
//int nShadowLodConVar = r_shadowlod.GetInt();
|
|
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
int nLODCount = list.m_pHardwareData->m_NumLODs;
|
|
//int nRootLOD = list.m_pHardwareData->m_RootLOD;
|
|
int nMaxLOD = nLODCount - 1;
|
|
|
|
for ( ModelListNode_t *pNode = list.m_pFirstNode; pNode; pNode = pNode->m_pNext )
|
|
{
|
|
// Just always use the lowest LOD right now
|
|
//int nLOD = nShadowLodConVar;
|
|
//pNode->m_nLOD = clamp( nLOD, nRootLOD, nMaxLOD );
|
|
pNode->m_nLOD = nMaxLOD;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
int nLOD = r_lod.GetInt();
|
|
if ( nLOD >= 0 )
|
|
{
|
|
SlamModelLODs( nLOD, nModelTypeCount, pModelList, pModelListNode );
|
|
return;
|
|
}
|
|
|
|
ScreenSizeComputeInfo_t info;
|
|
ComputeScreenSizeInfo( &info );
|
|
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
int nLODCount = list.m_pHardwareData->m_NumLODs;
|
|
int nRootLOD = list.m_pHardwareData->m_RootLOD;
|
|
int nMaxLOD = nLODCount - 1;
|
|
|
|
for ( ModelListNode_t *pNode = list.m_pFirstNode; pNode; pNode = pNode->m_pNext )
|
|
{
|
|
// FIXME: SIMD-ize, eliminate all extraneous calls (get view render state outside of loop)
|
|
const Vector &vecRenderOrigin = pNode->m_Entry.m_pRenderable->GetRenderOrigin();
|
|
|
|
// NOTE: The 2.0 is for legacy reasons
|
|
float flScreenSize = 2.0f * ComputeScreenSize( vecRenderOrigin, 0.5f, info );
|
|
|
|
float flMetric = list.m_pHardwareData->LODMetric( flScreenSize );
|
|
nLOD = list.m_pHardwareData->GetLODForMetric( flMetric );
|
|
pNode->m_nLOD = clamp( nLOD, nRootLOD, nMaxLOD );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sort models function
|
|
//-----------------------------------------------------------------------------
|
|
inline bool CModelRenderSystem::SortLessFunc( const RenderModelInfo_t &left, const RenderModelInfo_t &right )
|
|
{
|
|
// NOTE: Could do this, but it is not faster, because the cost of an integer multiply is about three
|
|
// times that of a branch penalty:
|
|
// int nLeft = left.m_nSkin * 1000000 + left.m_nLOD * 1000 + left.m_nBody;
|
|
// int nRight = right.m_nSkin * 1000000 + right.m_nLOD * 1000 + right.m_nBody;
|
|
// return nLeft > nRight;
|
|
if ( left.m_bSetupBonesOnly != right.m_bSetupBonesOnly )
|
|
return !left.m_bSetupBonesOnly;
|
|
if ( left.m_nSkin != right.m_nSkin )
|
|
return left.m_nSkin > right.m_nSkin;
|
|
if ( left.m_nLOD != right.m_nLOD )
|
|
return left.m_nLOD > right.m_nLOD;
|
|
return left.m_nBody > right.m_nBody;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sort models
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::SortModels( RenderModelInfo_t *pRenderModelInfo,
|
|
int nModelTypeCount, ModelListByType_t *pModelList, ModelListNode_t *pModelListNode )
|
|
{
|
|
// First place them in arrays
|
|
RenderModelInfo_t *pCurrInfo = pRenderModelInfo;
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
list.m_pRenderModels = pCurrInfo;
|
|
list.m_nSetupBoneCount = 0;
|
|
for ( ModelListNode_t *pNode = list.m_pFirstNode; pNode; pNode = pNode->m_pNext )
|
|
{
|
|
memset( pCurrInfo, 0, sizeof( RenderModelInfo_t ) );
|
|
pCurrInfo->m_Entry = pNode->m_Entry;
|
|
pCurrInfo->m_nLOD = pNode->m_nLOD;
|
|
pCurrInfo->m_nSkin = pNode->m_Entry.m_pRenderable->GetSkin();
|
|
pCurrInfo->m_nBody = pNode->m_Entry.m_pRenderable->GetBody();
|
|
pCurrInfo->m_hInstance = pNode->m_Entry.m_pRenderable->GetModelInstance();
|
|
pCurrInfo->m_Decals = STUDIORENDER_DECAL_INVALID;
|
|
pCurrInfo->m_nInitialListIndex = pNode->m_nInitialListIndex;
|
|
pCurrInfo->m_bBoneMerge = pNode->m_bBoneMerge;
|
|
pCurrInfo->m_bSetupBonesOnly = ( pNode->m_Entry.m_pModelRenderable == NULL );
|
|
pCurrInfo->m_pStencilState = pNode->m_pStencilState;
|
|
list.m_nSetupBoneCount += pCurrInfo->m_bSetupBonesOnly;
|
|
++pCurrInfo;
|
|
}
|
|
|
|
// Sort within this model type. skin first, then LOD, then body.
|
|
Assert( pCurrInfo - list.m_pRenderModels == list.m_nCount );
|
|
std::sort( list.m_pRenderModels, list.m_pRenderModels + list.m_nCount, SortLessFunc );
|
|
|
|
list.m_nCount -= list.m_nSetupBoneCount;
|
|
list.m_nSetupBoneCount += list.m_nCount;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets up bones on all models
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::SetupBones( int nModelTypeCount, ModelListByType_t *pModelList )
|
|
{
|
|
// FIXME: Can we make parallel bone setup faster? Yes, we can!
|
|
const float flCurTime = gpGlobals->curtime;
|
|
matrix3x4a_t pPoseToBone[MAXSTUDIOBONES];
|
|
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
const int nBoneCount = list.m_pStudioHdr->numbones;
|
|
|
|
// Force setup of attachments if we're going to use an illumposition
|
|
const int nAttachmentMask = ( list.m_pStudioHdr->IllumPositionAttachmentIndex() > 0 ) ? BONE_USED_BY_ATTACHMENT : 0;
|
|
for ( int j = 0; j < list.m_nSetupBoneCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
const int nBoneMask = BONE_USED_BY_VERTEX_AT_LOD( pModel->m_nLOD ) | nAttachmentMask;
|
|
pModel->m_pBoneToWorld = (matrix3x4a_t*)m_BoneToWorld.Alloc( nBoneCount * sizeof(matrix3x4a_t) );
|
|
const bool bOk = pModel->m_Entry.m_pRenderable->SetupBones( pModel->m_pBoneToWorld, nBoneCount, nBoneMask, flCurTime );
|
|
if ( !bOk )
|
|
{
|
|
for ( int k = 0; k < nBoneCount; ++k)
|
|
{
|
|
SetIdentityMatrix( pModel->m_pBoneToWorld[k] );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( list.m_nCount == 0 )
|
|
continue;
|
|
|
|
// Get the pose to bone for the model
|
|
if ( !list.m_pStudioHdr->pLinearBones() )
|
|
{
|
|
// convert bone to world transformations into pose to world transformations
|
|
for (int k = 0; k < nBoneCount; k++)
|
|
{
|
|
mstudiobone_t *pCurBone = list.m_pStudioHdr->pBone( k );
|
|
MatrixCopy( pCurBone->poseToBone, pPoseToBone[k] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mstudiolinearbone_t *pLinearBones = list.m_pStudioHdr->pLinearBones();
|
|
|
|
// convert bone to world transformations into pose to world transformations
|
|
for ( int k = 0; k < nBoneCount; k++)
|
|
{
|
|
MatrixCopy( pLinearBones->poseToBone(k), pPoseToBone[k] );
|
|
}
|
|
}
|
|
|
|
// Apply the pose-to-bone matrix to all instances
|
|
// NOTE: We should be able to optimize this a ton since it's very parallelizable
|
|
// NOTE: We may well want to compute the aggregate bone to world here also.
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
CMatRenderData< matrix3x4a_t > rdPoseToWorld( m_pRenderContext, nBoneCount );
|
|
pModel->m_pPoseToWorld = rdPoseToWorld.Base();
|
|
for ( int b = 0; b < nBoneCount; b++ )
|
|
{
|
|
ConcatTransforms_Aligned( pModel->m_pBoneToWorld[b], pPoseToBone[b], pModel->m_pPoseToWorld[b] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets up flexes on all models
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::SetupFlexes( int nModelTypeCount, ModelListByType_t *pModelList )
|
|
{
|
|
bool bUsesDelayedWeights = g_CV_FlexSmooth.GetBool();
|
|
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
const int nFlexCount = list.m_pStudioHdr->numflexdesc;
|
|
if ( !nFlexCount )
|
|
continue;
|
|
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
CMatRenderData< float > rdFlexWeights( m_pRenderContext );
|
|
CMatRenderData< float > rdDelayedFlexWeights( m_pRenderContext );
|
|
pModel->m_pFlexWeights = rdFlexWeights.Lock( nFlexCount );
|
|
if ( bUsesDelayedWeights )
|
|
{
|
|
pModel->m_pDelayedFlexWeights = rdDelayedFlexWeights.Lock( nFlexCount );
|
|
}
|
|
pModel->m_Entry.m_pRenderable->SetupWeights( pModel->m_pBoneToWorld, nFlexCount, pModel->m_pFlexWeights, pModel->m_pDelayedFlexWeights );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Draws debugging information for lighting
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::DebugDrawLightingOrigin( const ModelListByType_t &list, const RenderModelInfo_t &model )
|
|
{
|
|
if ( !model.m_pLightingState )
|
|
return;
|
|
|
|
const Vector& lightOrigin = model.m_pLightingState->m_vecLightingOrigin;
|
|
const matrix3x4_t &modelToWorld = model.m_Entry.m_pRenderable->RenderableToWorldTransform();
|
|
|
|
// draw z planar cross at lighting origin
|
|
Vector pt0;
|
|
Vector pt1;
|
|
pt0 = lightOrigin;
|
|
pt1 = lightOrigin;
|
|
pt0.x -= 4;
|
|
pt1.x += 4;
|
|
debugoverlay->AddLineOverlay( pt0, pt1, 0, 255, 0, true, 0.0f );
|
|
pt0 = lightOrigin;
|
|
pt1 = lightOrigin;
|
|
pt0.y -= 4;
|
|
pt1.y += 4;
|
|
debugoverlay->AddLineOverlay( pt0, pt1, 0, 255, 0, true, 0.0f );
|
|
|
|
// draw lines from the light origin to the hull boundaries to identify model
|
|
Vector pt;
|
|
pt0.x = list.m_pStudioHdr->hull_min.x;
|
|
pt0.y = list.m_pStudioHdr->hull_min.y;
|
|
pt0.z = list.m_pStudioHdr->hull_min.z;
|
|
VectorTransform( pt0, modelToWorld, pt1 );
|
|
debugoverlay->AddLineOverlay( lightOrigin, pt1, 100, 100, 150, true, 0.0f );
|
|
pt0.x = list.m_pStudioHdr->hull_min.x;
|
|
pt0.y = list.m_pStudioHdr->hull_max.y;
|
|
pt0.z = list.m_pStudioHdr->hull_min.z;
|
|
VectorTransform( pt0, modelToWorld, pt1 );
|
|
debugoverlay->AddLineOverlay( lightOrigin, pt1, 100, 100, 150, true, 0.0f );
|
|
pt0.x = list.m_pStudioHdr->hull_max.x;
|
|
pt0.y = list.m_pStudioHdr->hull_max.y;
|
|
pt0.z = list.m_pStudioHdr->hull_min.z;
|
|
VectorTransform( pt0, modelToWorld, pt1 );
|
|
debugoverlay->AddLineOverlay( lightOrigin, pt1, 100, 100, 150, true, 0.0f );
|
|
pt0.x = list.m_pStudioHdr->hull_max.x;
|
|
pt0.y = list.m_pStudioHdr->hull_min.y;
|
|
pt0.z = list.m_pStudioHdr->hull_min.z;
|
|
VectorTransform( pt0, modelToWorld, pt1 );
|
|
debugoverlay->AddLineOverlay( lightOrigin, pt1, 100, 100, 150, true, 0.0f );
|
|
|
|
pt0.x = list.m_pStudioHdr->hull_min.x;
|
|
pt0.y = list.m_pStudioHdr->hull_min.y;
|
|
pt0.z = list.m_pStudioHdr->hull_max.z;
|
|
VectorTransform( pt0, modelToWorld, pt1 );
|
|
debugoverlay->AddLineOverlay( lightOrigin, pt1, 100, 100, 150, true, 0.0f );
|
|
pt0.x = list.m_pStudioHdr->hull_min.x;
|
|
pt0.y = list.m_pStudioHdr->hull_max.y;
|
|
pt0.z = list.m_pStudioHdr->hull_max.z;
|
|
VectorTransform( pt0, modelToWorld, pt1 );
|
|
debugoverlay->AddLineOverlay( lightOrigin, pt1, 100, 100, 150, true, 0.0f );
|
|
pt0.x = list.m_pStudioHdr->hull_max.x;
|
|
pt0.y = list.m_pStudioHdr->hull_max.y;
|
|
pt0.z = list.m_pStudioHdr->hull_max.z;
|
|
VectorTransform( pt0, modelToWorld, pt1 );
|
|
debugoverlay->AddLineOverlay( lightOrigin, pt1, 100, 100, 150, true, 0.0f );
|
|
pt0.x = list.m_pStudioHdr->hull_max.x;
|
|
pt0.y = list.m_pStudioHdr->hull_min.y;
|
|
pt0.z = list.m_pStudioHdr->hull_max.z;
|
|
VectorTransform( pt0, modelToWorld, pt1 );
|
|
debugoverlay->AddLineOverlay( lightOrigin, pt1, 100, 100, 150, true, 0.0f );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute lighting origin on all models
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::ComputeLightingOrigin( ModelListByType_t &list, LightingQuery_t *pLightingQueryBase, int nQueryStride )
|
|
{
|
|
LightingQuery_t *pLightingQuery = pLightingQueryBase;
|
|
|
|
//int nBoneMergeCount = 0;
|
|
int nAttachmentIndex = list.m_pStudioHdr->IllumPositionAttachmentIndex();
|
|
bool bAmbientBoost = ( list.m_pStudioHdr->flags & STUDIOHDR_FLAGS_AMBIENT_BOOST ) != 0;
|
|
if ( nAttachmentIndex <= 0 || nAttachmentIndex > list.m_pStudioHdr->GetNumAttachments() )
|
|
{
|
|
const Vector &vecIllumPosition = list.m_pStudioHdr->illumposition;
|
|
for ( int j = 0; j < list.m_nCount; ++j, pLightingQuery = (LightingQuery_t*)( (unsigned char*)pLightingQuery + nQueryStride ) )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
//nBoneMergeCount += pModel->m_bBoneMerge;
|
|
const matrix3x4_t &renderToWorld = pModel->m_Entry.m_pRenderable->RenderableToWorldTransform();
|
|
pLightingQuery->m_InstanceHandle = pModel->m_hInstance;
|
|
VectorTransform( vecIllumPosition, renderToWorld, pLightingQuery->m_LightingOrigin );
|
|
//pLightingQuery->m_ParentInstanceHandle = MODEL_INSTANCE_INVALID;
|
|
pLightingQuery->m_bAmbientBoost = bAmbientBoost;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// NOTE: We don't care about orientation here.
|
|
// Assume the attachment->bone matrix has identity rotation. Given that,
|
|
// compute attachment->world = bone->world * attachment->bone.
|
|
// We only care about the translation component of attachment->world
|
|
// which can be obtained by transforming the attachment offset by bone->world
|
|
|
|
// Oh, and tough noogies if you want an illumposition offset also.
|
|
// Just make an attachment exactly where you want it. Otherwise this is slower.
|
|
#ifdef _DEBUG
|
|
if ( list.m_pStudioHdr->illumposition != vec3_origin )
|
|
{
|
|
static int nWarnCount = 0;
|
|
if ( nWarnCount++ < 10 )
|
|
{
|
|
AssertMsg( false, "Model fast path: illumposition must be (0,0,0) if an attachment is being used!\n" );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Attachment index is 1 too large, 0 means no attachment
|
|
--nAttachmentIndex;
|
|
|
|
Vector attachmentOffset;
|
|
const mstudioattachment_t &attachment = list.m_pStudioHdr->pAttachment( nAttachmentIndex );
|
|
MatrixGetColumn( attachment.local, 3, attachmentOffset );
|
|
int iBone = list.m_pStudioHdr->GetAttachmentBone( nAttachmentIndex );
|
|
|
|
for ( int j = 0; j < list.m_nCount; ++j, pLightingQuery = (LightingQuery_t*)( (unsigned char*)pLightingQuery + nQueryStride ) )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
//nBoneMergeCount += pModel->m_bBoneMerge;
|
|
pLightingQuery->m_InstanceHandle = pModel->m_hInstance;
|
|
VectorTransform( attachmentOffset, pModel->m_pBoneToWorld[iBone], pLightingQuery->m_LightingOrigin );
|
|
//pLightingQuery->m_ParentInstanceHandle = MODEL_INSTANCE_INVALID;
|
|
pLightingQuery->m_bAmbientBoost = bAmbientBoost;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
// NOTE: This is more expensive, but hopefully is uncommon
|
|
// Bonemerged models will copy the lighting environment from their parent entity.
|
|
// This fixes issues with L4D2 infected wounds where the wounds would sometimes receive different lighting
|
|
// than the body they're embedded in.
|
|
if ( nBoneMergeCount > 0 )
|
|
{
|
|
pLightingQuery = pLightingQueryBase;
|
|
for ( int j = 0; j < list.m_nCount; ++j, pLightingQuery = (LightingQuery_t*)( (unsigned char*)pLightingQuery + nQueryStride ) )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
if ( !pModel->m_bBoneMerge )
|
|
continue;
|
|
|
|
C_BaseEntity *pEnt = pModel->m_Entry.m_pRenderable->GetIClientUnknown()->GetBaseEntity();
|
|
C_BaseEntity *pParent = pEnt->GetMoveParent();
|
|
if ( !pParent )
|
|
continue;
|
|
|
|
pLightingQuery->m_ParentInstanceHandle = pParent->GetModelInstance();
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Builds the model lighting list
|
|
//-----------------------------------------------------------------------------
|
|
enum
|
|
{
|
|
LIGHTING_USES_ENV_CUBEMAP = 0x1,
|
|
LIGHTING_IS_VERTEX_LIT = 0x2,
|
|
LIGHTING_IS_STATIC_LIT = 0x4,
|
|
};
|
|
|
|
int CModelRenderSystem::BuildLightingList( ModelListByType_t **ppLists, unsigned char *pFlags, int *pTotalModels, const LightingList_t &lightingList )
|
|
{
|
|
// FIXME: This may be better placed in the engine to avoid all the virtual calls?
|
|
int nSetupCount = 0;
|
|
*pTotalModels = 0;
|
|
for ( ModelListByType_t* pList = lightingList.m_pFirstModel; pList; pList = pList->m_pNextLightingModel )
|
|
{
|
|
// FIXME: Under what conditions can the static prop skip lighting? [unlit materials]
|
|
bool bIsLit = modelinfo->IsModelVertexLit( pList->m_pModel );
|
|
bool bUsesEnvCubemap = modelinfo->UsesEnvCubemap( pList->m_pModel );
|
|
bool bIsStaticLit = modelinfo->UsesStaticLighting( pList->m_pModel );
|
|
if ( !bIsLit && !bUsesEnvCubemap && !bIsStaticLit )
|
|
continue;
|
|
ppLists[ nSetupCount ] = pList;
|
|
pFlags[ nSetupCount ] = ( bIsStaticLit << 2 ) | ( bIsLit << 1 ) | ( bUsesEnvCubemap << 0 );
|
|
*pTotalModels += pList->m_nCount;
|
|
++nSetupCount;
|
|
}
|
|
|
|
return nSetupCount;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Hook up computed lighting state
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::HookUpStaticLightingState( int nCount, ModelListByType_t **ppLists,
|
|
unsigned char *pFlags, ITexture **ppEnvCubemap, MaterialLightingState_t *pLightingState,
|
|
MaterialLightingState_t *pDecalLightingState, ColorMeshInfo_t **ppColorMeshInfo )
|
|
{
|
|
// FIXME: This has got to be more efficient that this
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
ModelListByType_t &list = *( ppLists[i] );
|
|
if ( pFlags[i] & LIGHTING_USES_ENV_CUBEMAP )
|
|
{
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
pModel->m_pEnvCubemapTexture = ppEnvCubemap[j] ? ppEnvCubemap[j] : m_DefaultCubemap;
|
|
}
|
|
}
|
|
|
|
if ( pFlags[i] & LIGHTING_IS_VERTEX_LIT )
|
|
{
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
pModel->m_pLightingState = &pLightingState[j];
|
|
pModel->m_pDecalLightingState = &pDecalLightingState[j];
|
|
}
|
|
}
|
|
|
|
if ( pFlags[i] & LIGHTING_IS_STATIC_LIT )
|
|
{
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
pModel->m_pColorMeshInfo = ppColorMeshInfo[j];
|
|
}
|
|
}
|
|
|
|
ppEnvCubemap += list.m_nCount;
|
|
pLightingState += list.m_nCount;
|
|
pDecalLightingState += list.m_nCount;
|
|
ppColorMeshInfo += list.m_nCount;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets up lighting on all models
|
|
//-----------------------------------------------------------------------------
|
|
int CModelRenderSystem::SetupStaticPropLighting( LightingList_t &lightingList, DataCacheHandle_t *pColorMeshHandle )
|
|
{
|
|
if ( lightingList.m_nCount == 0 )
|
|
return 0;
|
|
|
|
// Build list of everything that needs lighting
|
|
int nTotalModels;
|
|
ModelListByType_t **ppLists = (ModelListByType_t**)stackalloc( lightingList.m_nCount * sizeof(ModelListByType_t*) );
|
|
unsigned char *pFlags = (unsigned char*)stackalloc( lightingList.m_nCount * sizeof(unsigned char) );
|
|
int nSetupCount = BuildLightingList( ppLists, pFlags, &nTotalModels, lightingList );
|
|
if ( nSetupCount == 0 )
|
|
return 0;
|
|
|
|
// Build queries used to compute lighting
|
|
StaticLightingQuery_t *pLightingQuery = (StaticLightingQuery_t*)stackalloc( nTotalModels * sizeof(StaticLightingQuery_t) );
|
|
int nOffset = 0;
|
|
for ( int i = 0; i < nSetupCount; ++i )
|
|
{
|
|
ModelListByType_t &list = *( ppLists[i] );
|
|
|
|
for ( int j = 0; j < list.m_nCount; ++j, ++nOffset )
|
|
{
|
|
pLightingQuery[ nOffset ].m_pRenderable = list.m_pRenderModels[j].m_Entry.m_pRenderable;
|
|
pLightingQuery[ nOffset ].m_InstanceHandle = list.m_pRenderModels[j].m_hInstance;
|
|
pLightingQuery[ nOffset ].m_bAmbientBoost = false;
|
|
}
|
|
}
|
|
|
|
// Compute lighting origins
|
|
staticpropmgr->GetLightingOrigins( &pLightingQuery[0].m_LightingOrigin,
|
|
sizeof(StaticLightingQuery_t), nTotalModels, &pLightingQuery[0].m_pRenderable, sizeof(StaticLightingQuery_t) );
|
|
|
|
// Does all lighting computations for all models
|
|
ColorMeshInfo_t **ppColorMeshInfo = (ColorMeshInfo_t**)stackalloc( nTotalModels * sizeof(ColorMeshInfo_t*) );
|
|
ITexture **ppEnvCubemap = (ITexture**)stackalloc( nTotalModels * sizeof(ITexture*) );
|
|
|
|
CMatRenderData< MaterialLightingState_t > rdLightingState( m_pRenderContext, 2 * nTotalModels );
|
|
MaterialLightingState_t *pLightingState = rdLightingState.Base();
|
|
MaterialLightingState_t *pDecalLightingState = &rdLightingState[ nTotalModels ];
|
|
modelrender->ComputeStaticLightingState( nTotalModels, pLightingQuery, pLightingState, pDecalLightingState, ppColorMeshInfo, ppEnvCubemap, pColorMeshHandle );
|
|
|
|
// Hook up pointers
|
|
HookUpStaticLightingState( nSetupCount, ppLists, pFlags, ppEnvCubemap, pLightingState, pDecalLightingState, ppColorMeshInfo );
|
|
|
|
return nTotalModels;
|
|
}
|
|
|
|
|
|
void CModelRenderSystem::SetupStandardLighting( LightingList_t &lightingList )
|
|
{
|
|
if ( lightingList.m_nCount == 0 )
|
|
return;
|
|
|
|
// Determine which groups need lighting
|
|
ModelListByType_t **ppLists = (ModelListByType_t**)stackalloc( lightingList.m_nCount * sizeof(ModelListByType_t*) );
|
|
unsigned char *pFlags = (unsigned char*)stackalloc( lightingList.m_nCount * sizeof(unsigned char) );
|
|
int nTotalModels = 0;
|
|
int nSetupCount = BuildLightingList( ppLists, pFlags, &nTotalModels, lightingList );
|
|
if ( nSetupCount == 0 )
|
|
return;
|
|
|
|
// Compute data necessary for lighting computations
|
|
int nOffset = 0;
|
|
LightingQuery_t *pLightingQuery = (LightingQuery_t*)stackalloc( nTotalModels * sizeof(LightingQuery_t) );
|
|
CMatRenderData<MaterialLightingState_t> rdLightingState( m_pRenderContext, nTotalModels );
|
|
MaterialLightingState_t *pLightingState = rdLightingState.Base();
|
|
memset( pLightingState, 0, nTotalModels * sizeof(MaterialLightingState_t) );
|
|
for ( int i = 0; i < nSetupCount; ++i )
|
|
{
|
|
ModelListByType_t &list = *( ppLists[i] );
|
|
ComputeLightingOrigin( list, &pLightingQuery[nOffset], sizeof(LightingQuery_t) );
|
|
nOffset += list.m_nCount;
|
|
}
|
|
|
|
// Does all lighting computations for all models
|
|
ITexture **ppEnvCubemap = (ITexture**)stackalloc( nTotalModels * sizeof(ITexture*) );
|
|
modelrender->ComputeLightingState( nTotalModels, pLightingQuery, pLightingState, ppEnvCubemap );
|
|
|
|
// Hook up pointers
|
|
MaterialLightingState_t *pCurrState = pLightingState;
|
|
for ( int i = 0; i < nSetupCount; ++i )
|
|
{
|
|
ModelListByType_t &list = *( ppLists[i] );
|
|
if ( pFlags[i] & 0x1 )
|
|
{
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
pModel->m_pEnvCubemapTexture = ppEnvCubemap[j] ? ppEnvCubemap[j] : m_DefaultCubemap;
|
|
}
|
|
}
|
|
|
|
if ( pFlags[i] & 0x2 )
|
|
{
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
pModel->m_pLightingState = &pCurrState[j];
|
|
}
|
|
}
|
|
|
|
ppEnvCubemap += list.m_nCount;
|
|
pCurrState += list.m_nCount;
|
|
}
|
|
}
|
|
|
|
int CModelRenderSystem::SetupPhysicsPropLighting( LightingList_t &lightingList, DataCacheHandle_t *pColorMeshHandle )
|
|
{
|
|
if ( lightingList.m_nCount == 0 )
|
|
return 0;
|
|
|
|
// NOTE: Physics prop lighting is the same as static prop lighting, only
|
|
// the static lighting is *always* used (the system goes to the standard path
|
|
// for physics props which are moving or which use bumpmapping).
|
|
ModelListByType_t **ppLists = (ModelListByType_t**)stackalloc( lightingList.m_nCount * sizeof(ModelListByType_t*) );
|
|
unsigned char *pFlags = (unsigned char*)stackalloc( lightingList.m_nCount * sizeof(unsigned char) );
|
|
int nTotalModels = 0;
|
|
int nSetupCount = BuildLightingList( ppLists, pFlags, &nTotalModels, lightingList );
|
|
if ( nSetupCount == 0 )
|
|
return 0;
|
|
|
|
StaticLightingQuery_t *pLightingQuery = (StaticLightingQuery_t*)stackalloc( nTotalModels * sizeof(StaticLightingQuery_t) );
|
|
int nOffset = 0;
|
|
for ( int i = 0; i < nSetupCount; ++i )
|
|
{
|
|
ModelListByType_t &list = *( ppLists[i] );
|
|
|
|
ComputeLightingOrigin( list, &pLightingQuery[nOffset], sizeof(StaticLightingQuery_t) );
|
|
for ( int j = 0; j < list.m_nCount; ++j, ++nOffset )
|
|
{
|
|
pLightingQuery[ nOffset ].m_pRenderable = list.m_pRenderModels[j].m_Entry.m_pRenderable;
|
|
}
|
|
}
|
|
|
|
// Does all lighting computations for all models
|
|
ColorMeshInfo_t **ppColorMeshInfo = (ColorMeshInfo_t**)stackalloc( nTotalModels * sizeof(ColorMeshInfo_t*) );
|
|
ITexture **ppEnvCubemap = (ITexture**)stackalloc( nTotalModels * sizeof(ITexture*) );
|
|
CMatRenderData< MaterialLightingState_t > rdLightingState( m_pRenderContext, 2 * nTotalModels );
|
|
MaterialLightingState_t *pLightingState = rdLightingState.Base();
|
|
MaterialLightingState_t *pDecalLightingState = &pLightingState[ nTotalModels ];
|
|
modelrender->ComputeStaticLightingState( nTotalModels, pLightingQuery, pLightingState, pDecalLightingState, ppColorMeshInfo, ppEnvCubemap, pColorMeshHandle );
|
|
|
|
// Hook up pointers
|
|
HookUpStaticLightingState( nSetupCount, ppLists, pFlags, ppEnvCubemap, pLightingState, pDecalLightingState, ppColorMeshInfo );
|
|
return nTotalModels;
|
|
}
|
|
|
|
int CModelRenderSystem::SetupLighting( LightingList_t *pLightingList, int nModelTypeCount, ModelListByType_t *pModelList, DataCacheHandle_t *pColorMeshHandles, ModelRenderMode_t renderMode )
|
|
{
|
|
if ( renderMode != MODEL_RENDER_MODE_NORMAL )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int nCount = SetupStaticPropLighting( pLightingList[ LIGHTING_MODEL_STATIC_PROP ], pColorMeshHandles );
|
|
pColorMeshHandles += nCount;
|
|
SetupStandardLighting( pLightingList[ LIGHTING_MODEL_STANDARD ] );
|
|
nCount += SetupPhysicsPropLighting( pLightingList[ LIGHTING_MODEL_PHYSICS_PROP ], pColorMeshHandles );
|
|
|
|
// Debugging info
|
|
if ( r_drawmodellightorigin.GetBool() )
|
|
{
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
const ModelListByType_t &list = pModelList[ i ];
|
|
if ( list.m_nLightingModel == LIGHTING_MODEL_NONE )
|
|
continue;
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
const RenderModelInfo_t &info = list.m_pRenderModels[j];
|
|
DebugDrawLightingOrigin( list, info );
|
|
}
|
|
}
|
|
}
|
|
|
|
return nCount;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Setup render state related to flashlights and decals
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::SetupFlashlightsAndDecals( StudioModelArrayInfo2_t *pInfo, int nModelTypeCount, ModelListByType_t *pModelList, int nTotalModelCount, RenderModelInfo_t *pRenderModels, ModelRenderMode_t renderMode )
|
|
{
|
|
// Skip lighting + decals if we don't need it
|
|
if ( renderMode != MODEL_RENDER_MODE_NORMAL )
|
|
return;
|
|
|
|
ShadowHandle_t pFlashlights[MAX_FLASHLIGHTS_PER_INSTANCE_DRAW_CALL];
|
|
int nInstCount = 0;
|
|
ModelInstanceHandle_t *pModelInstanceHandle = (ModelInstanceHandle_t*)stackalloc( nTotalModelCount * sizeof(ModelInstanceHandle_t) );
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[ i ];
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
pModelInstanceHandle[nInstCount++] = pModel->m_hInstance;
|
|
}
|
|
}
|
|
|
|
Assert( nTotalModelCount == nInstCount );
|
|
|
|
if ( nTotalModelCount != nInstCount )
|
|
{
|
|
DevWarning( "CModelRenderSystem::SetupFlashlightsAndDecals sorted model list count incorrect! A model was probably unable to load!" );
|
|
nTotalModelCount = nInstCount;
|
|
}
|
|
|
|
// Gets all decals
|
|
StudioDecalHandle_t *pDecals = &pRenderModels->m_Decals;
|
|
modelrender->GetModelDecalHandles( pDecals, sizeof(RenderModelInfo_t), nTotalModelCount, pModelInstanceHandle );
|
|
|
|
// Builds a list of all flashlights affecting this model
|
|
uint32 *pFlashlightUsage = &pRenderModels->m_nFlashlightUsage;
|
|
pInfo->m_nFlashlightCount = shadowmgr->SetupFlashlightRenderInstanceInfo( pFlashlights, pFlashlightUsage, sizeof(RenderModelInfo_t), nTotalModelCount, pModelInstanceHandle );
|
|
if ( pInfo->m_nFlashlightCount )
|
|
{
|
|
// Copy over the flashlight state
|
|
// FIXME: Should we do this over the entire list of all instances?
|
|
// There's going to be a fair amount of copying of flashlight_ts
|
|
CMatRenderData< FlashlightInstance_t > rdFlashlights( m_pRenderContext, pInfo->m_nFlashlightCount );
|
|
pInfo->m_pFlashlights = rdFlashlights.Base();
|
|
shadowmgr->GetFlashlightRenderInfo( pInfo->m_pFlashlights, pInfo->m_nFlashlightCount, pFlashlights );
|
|
}
|
|
else
|
|
{
|
|
pInfo->m_pFlashlights = NULL;
|
|
}
|
|
|
|
// FIXME: Hack!
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[ i ];
|
|
list.m_nFlashlightCount = pInfo->m_nFlashlightCount;
|
|
list.m_pFlashlights = pInfo->m_pFlashlights;
|
|
}
|
|
}
|
|
|
|
void CModelRenderSystem::SetupPerInstanceColorModulation( int nModelTypeCount, ModelListByType_t *pModelList )
|
|
{
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[ i ];
|
|
if ( !list.m_nCount )
|
|
continue;
|
|
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t *pModel = &list.m_pRenderModels[j];
|
|
IClientRenderable *pRenderable = pModel->m_Entry.m_pRenderable;
|
|
#if 0
|
|
Vector diffuseModulation;
|
|
pRenderable->GetColorModulation( diffuseModulation.Base() );
|
|
pModel->m_DiffuseModulation.x = diffuseModulation.x;
|
|
pModel->m_DiffuseModulation.y = diffuseModulation.y;
|
|
pModel->m_DiffuseModulation.z = diffuseModulation.z;
|
|
#else // preferred to do it this way, because it avoids a load-hit-store on 360
|
|
pRenderable->GetColorModulation( pModel->m_DiffuseModulation.AsVector3D().Base() );
|
|
#endif
|
|
pModel->m_DiffuseModulation.w = pModel->m_Entry.m_InstanceData.m_nAlpha * ( 1.0f / 255.0f );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Call into studiorender
|
|
//-----------------------------------------------------------------------------
|
|
ConVar cl_colorfastpath( "cl_colorfastpath", "0" );
|
|
void CModelRenderSystem::RenderModels( StudioModelArrayInfo2_t *pInfo, int nModelTypeCount, ModelListByType_t *pModelList, int nTotalModelCount, ModelRenderMode_t renderMode )
|
|
{
|
|
if ( renderMode == MODEL_RENDER_MODE_NORMAL )
|
|
{
|
|
bool bColorize = cl_colorfastpath.GetBool();
|
|
if ( bColorize )
|
|
{
|
|
g_pStudioRender->ForcedMaterialOverride( m_DebugMaterial );
|
|
}
|
|
|
|
const int nFlags = STUDIORENDER_DRAW_OPAQUE_ONLY;
|
|
CMatRenderData< StudioArrayData_t > rdArray( m_pRenderContext, nModelTypeCount );
|
|
|
|
#ifdef _DEBUG
|
|
bool bFoundStencil = false;
|
|
#endif
|
|
|
|
int nNonStencilModelTypeCount = 0;
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
rdArray[ i ].m_pStudioHdr = list.m_pStudioHdr;
|
|
rdArray[ i ].m_pHardwareData = list.m_pHardwareData;
|
|
rdArray[ i ].m_pInstanceData = list.m_pRenderModels;
|
|
rdArray[ i ].m_nCount = list.m_nCount;
|
|
nNonStencilModelTypeCount += list.m_bWantsStencil ? 0 : 1;
|
|
|
|
#ifdef _DEBUG
|
|
if ( list.m_bWantsStencil )
|
|
{
|
|
bFoundStencil = true;
|
|
}
|
|
else
|
|
{
|
|
Assert( !bFoundStencil );
|
|
}
|
|
#endif
|
|
}
|
|
if ( IsX360() && r_fastzreject.GetBool() && ( nNonStencilModelTypeCount != nModelTypeCount ) )
|
|
{
|
|
// Render all models without stencil
|
|
g_pStudioRender->DrawModelArray( *pInfo, nNonStencilModelTypeCount, rdArray.Base(), sizeof(RenderModelInfo_t), nFlags );
|
|
|
|
#ifdef _X360
|
|
// end z prepass here
|
|
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
|
|
pRenderContext->End360ZPass();
|
|
#endif
|
|
|
|
// Render all models with stencil
|
|
g_pStudioRender->DrawModelArray( *pInfo, nModelTypeCount - nNonStencilModelTypeCount, rdArray.Base() + nNonStencilModelTypeCount,
|
|
sizeof(RenderModelInfo_t), nFlags );
|
|
}
|
|
else
|
|
{
|
|
// PC renders all models in one go regardless of stencil state
|
|
g_pStudioRender->DrawModelArray( *pInfo, nModelTypeCount, rdArray.Base(), sizeof(RenderModelInfo_t), nFlags );
|
|
}
|
|
g_pStudioRender->ForcedMaterialOverride( NULL );
|
|
}
|
|
else if ( renderMode == MODEL_RENDER_MODE_SHADOW_DEPTH )
|
|
{
|
|
// NOTE: Use this path because we can aggregate draw calls across mdls
|
|
|
|
const int nFlags = STUDIORENDER_SHADOWDEPTHTEXTURE | STUDIORENDER_DRAW_OPAQUE_ONLY;
|
|
CMatRenderData< StudioArrayData_t > rdShadow( m_pRenderContext, nModelTypeCount );
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
rdShadow[ i ].m_pStudioHdr = list.m_pStudioHdr;
|
|
rdShadow[ i ].m_pHardwareData = list.m_pHardwareData;
|
|
rdShadow[ i ].m_pInstanceData = list.m_pRenderModels;
|
|
rdShadow[ i ].m_nCount = list.m_nCount;
|
|
}
|
|
g_pStudioRender->DrawModelShadowArray( nModelTypeCount, rdShadow.Base(), sizeof(RenderModelInfo_t), nFlags );
|
|
}
|
|
else if ( renderMode == MODEL_RENDER_MODE_RTT_SHADOWS )
|
|
{
|
|
// shouldn't get here unless the code is ported from l4d2 to drive this properly.
|
|
Assert(0);
|
|
#if 0
|
|
// HACK: Assume all models in this batch use the same material. This only works because we submit batches of 1 model from the client shadow manager at the moment
|
|
IMaterial* pShadowDrawMaterial = pModelList[0].m_pFirstNode->m_Entry.m_pRenderable->GetShadowDrawMaterial();
|
|
g_pStudioRender->ForcedMaterialOverride( pShadowDrawMaterial ? pShadowDrawMaterial : m_ShadowBuild, OVERRIDE_BUILD_SHADOWS );
|
|
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
g_pStudioRender->DrawModelArray( list, list.m_nCount, list.m_pRenderModels, sizeof(RenderModelInfo_t), STUDIORENDER_DRAW_OPAQUE_ONLY );
|
|
}
|
|
|
|
g_pStudioRender->ForcedMaterialOverride( NULL );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Call into studiorender
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::SetupTranslucentData( int nModelTypeCount, ModelListByType_t *pModelList, int nTotalModelCount, TranslucentInstanceRenderData_t *pRenderData )
|
|
{
|
|
memset( pRenderData, 0, nTotalModelCount * sizeof( TranslucentInstanceRenderData_t ) );
|
|
CMatRenderData< StudioModelArrayInfo_t > arrayInfo( m_pRenderContext, nModelTypeCount );
|
|
CMatRenderData< StudioArrayInstanceData_t > instanceData( m_pRenderContext, nTotalModelCount );
|
|
|
|
int nCurInstance = 0;
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
StudioModelArrayInfo_t *pModelInfo = &arrayInfo[i];
|
|
memcpy( pModelInfo, &list, sizeof( StudioModelArrayInfo_t ) );
|
|
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
RenderModelInfo_t &info = list.m_pRenderModels[j];
|
|
|
|
StudioArrayInstanceData_t *pInstanceData = &instanceData[nCurInstance++];
|
|
memcpy( pInstanceData, &info, sizeof( StudioArrayInstanceData_t ) );
|
|
|
|
TranslucentInstanceRenderData_t &data = pRenderData[ info.m_nInitialListIndex ];
|
|
data.m_pModelInfo = pModelInfo;
|
|
data.m_pInstanceData = pInstanceData;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Renders debug overlays
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::RenderVCollideDebugOverlay( int nModelTypeCount, ModelListByType_t *pModelList )
|
|
{
|
|
if ( !vcollide_wireframe.GetBool() )
|
|
return;
|
|
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
IClientRenderable *pRenderable = list.m_pRenderModels[j].m_Entry.m_pRenderable;
|
|
C_BaseAnimating *pAnim = dynamic_cast< C_BaseAnimating * >( pRenderable );
|
|
if ( pAnim && pAnim->IsRagdoll() )
|
|
{
|
|
pAnim->m_pRagdoll->DrawWireframe();
|
|
continue;
|
|
}
|
|
|
|
ICollideable *pCollideable = pRenderable->GetIClientUnknown()->GetCollideable();
|
|
if ( pCollideable && ( pCollideable->GetSolid() == SOLID_VPHYSICS ) &&
|
|
IsSolid( pCollideable->GetSolid(), pCollideable->GetSolidFlags() ) )
|
|
{
|
|
vcollide_t *pCollide = modelinfo->GetVCollide( pCollideable->GetCollisionModel() );
|
|
if ( pCollide && pCollide->solidCount == 1 )
|
|
{
|
|
static color32 debugColor = {0,255,255,0};
|
|
engine->DebugDrawPhysCollide( pCollide->solids[0], NULL, pCollideable->CollisionToWorldTransform(), debugColor );
|
|
|
|
C_BaseEntity *pEntity = pRenderable->GetIClientUnknown()->GetBaseEntity();
|
|
if ( pEntity && pEntity->VPhysicsGetObject() )
|
|
{
|
|
static color32 debugColorPhys = {255,0,0,0};
|
|
matrix3x4_t matrix;
|
|
pEntity->VPhysicsGetObject()->GetPositionMatrix( &matrix );
|
|
engine->DebugDrawPhysCollide( pCollide->solids[0], NULL, matrix, debugColorPhys );
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CModelRenderSystem::RenderBBoxDebugOverlay( int nModelTypeCount, ModelListByType_t *pModelList )
|
|
{
|
|
for ( int i = 0; i < nModelTypeCount; ++i )
|
|
{
|
|
ModelListByType_t &list = pModelList[i];
|
|
for ( int j = 0; j < list.m_nCount; ++j )
|
|
{
|
|
IClientRenderable *pRenderable = list.m_pRenderModels[j].m_Entry.m_pRenderable;
|
|
if ( !pRenderable->GetIClientUnknown() )
|
|
continue;
|
|
C_BaseEntity *pEntity = pRenderable->GetIClientUnknown()->GetBaseEntity();
|
|
if ( !pEntity )
|
|
continue;
|
|
|
|
pEntity->DrawBBoxVisualizations();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Renders debug overlays
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::RenderDebugOverlays( int nModelTypeCount, ModelListByType_t *pModelList, ModelRenderMode_t renderMode )
|
|
{
|
|
if ( renderMode != MODEL_RENDER_MODE_NORMAL )
|
|
{
|
|
return;
|
|
}
|
|
|
|
RenderVCollideDebugOverlay( nModelTypeCount, pModelList );
|
|
RenderBBoxDebugOverlay( nModelTypeCount, pModelList );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sort model types function
|
|
//-----------------------------------------------------------------------------
|
|
inline bool CModelRenderSystem::StencilSortLessFunc( const ModelListByType_t &left, const ModelListByType_t &right )
|
|
{
|
|
// Ensure stenciling models are at the end of the list
|
|
if ( left.m_bWantsStencil != right.m_bWantsStencil )
|
|
{
|
|
return left.m_bWantsStencil < right.m_bWantsStencil;
|
|
}
|
|
|
|
// Keep same models with different lighting types together
|
|
return left.m_pModel < right.m_pModel;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Draw models
|
|
//-----------------------------------------------------------------------------
|
|
static ConVar cl_skipfastpath( "cl_skipfastpath", "0", FCVAR_CHEAT, "Set to 1 to stop all models that go through the model fast path from rendering" );
|
|
void CModelRenderSystem::DrawModels( ModelRenderSystemData_t *pEntities, int nCount, ModelRenderMode_t renderMode )
|
|
{
|
|
if ( nCount == 0 || cl_skipfastpath.GetInt() )
|
|
return;
|
|
|
|
VPROF_BUDGET( "CModelRenderSystem::DrawModels", VPROF_BUDGETGROUP_MODEL_FAST_PATH_RENDERING );
|
|
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
|
|
|
|
// While doing this, we need materialsystem to keep around its temp allocations
|
|
// which we use for bone matrices + flexes
|
|
CMatRenderContextPtr matRenderContext( g_pMaterialSystem );
|
|
m_pRenderContext = matRenderContext;
|
|
|
|
PIXEVENT( m_pRenderContext, "CModelRenderSystem::DrawModels (FASTPATH)" );
|
|
|
|
CMatRenderDataReference rdLock( m_pRenderContext );
|
|
|
|
// FIXME: This is infected-specific for perf test reasons.
|
|
// Will break into a more fixed pipeline at a later date
|
|
DataCacheHandle_t *pColorMeshHandles = NULL;
|
|
if ( renderMode == MODEL_RENDER_MODE_NORMAL )
|
|
{
|
|
pColorMeshHandles = (DataCacheHandle_t*)stackalloc( nCount * sizeof(DataCacheHandle_t) );
|
|
}
|
|
ModelListByType_t *pModelList = (ModelListByType_t*)stackalloc( nCount * sizeof(ModelListByType_t) );
|
|
ModelListNode_t *pModelListNode = (ModelListNode_t*)stackalloc( nCount * sizeof(ModelListNode_t) );
|
|
int nModelsRenderingStencilCount = 0;
|
|
int nModelTypeCount = BucketModelsByMDL( pModelList, pModelListNode, pEntities, nCount, renderMode, &nModelsRenderingStencilCount );
|
|
|
|
LightingList_t pLightingList[ LIGHTING_MODEL_COUNT ];
|
|
memset( pLightingList, 0, LIGHTING_MODEL_COUNT * sizeof(LightingList_t) );
|
|
SortBucketsByDependency( nModelTypeCount, pModelList, pLightingList );
|
|
|
|
// Compute LODs for each model
|
|
ComputeModelLODs( nModelTypeCount, pModelList, pModelListNode, renderMode );
|
|
|
|
// Sort processing list by body, lod, skin, etc.
|
|
CMatRenderData< RenderModelInfo_t > rdRenderModelInfo( m_pRenderContext, nCount );
|
|
RenderModelInfo_t *pSortedModelListNode = rdRenderModelInfo.Base();
|
|
SortModels( pSortedModelListNode, nModelTypeCount, pModelList, pModelListNode );
|
|
|
|
// Setup bones
|
|
SetupBones( nModelTypeCount, pModelList );
|
|
|
|
// Setup flexes
|
|
if ( renderMode != MODEL_RENDER_MODE_RTT_SHADOWS )
|
|
{
|
|
SetupFlexes( nModelTypeCount, pModelList );
|
|
}
|
|
|
|
// Setup lighting
|
|
int nColorMeshHandles = SetupLighting( pLightingList, nModelTypeCount, pModelList, pColorMeshHandles, renderMode );
|
|
|
|
// Setup flashlights + decals
|
|
StudioModelArrayInfo2_t info;
|
|
SetupFlashlightsAndDecals( &info, nModelTypeCount, pModelList, nCount, pSortedModelListNode, renderMode );
|
|
|
|
// Setup per-instance color modulation
|
|
SetupPerInstanceColorModulation( nModelTypeCount, pModelList );
|
|
|
|
// Setup per-instance wound data
|
|
//SetupInfectedWoundRenderData( nModelTypeCount, pModelList, nCount, renderMode );
|
|
|
|
if ( IsX360() && ( renderMode == MODEL_RENDER_MODE_NORMAL ) && ( nModelsRenderingStencilCount > 0) )
|
|
{
|
|
// resort here to make sure all models rendering stencil come last
|
|
std::sort( pModelList, pModelList + nModelTypeCount, StencilSortLessFunc );
|
|
}
|
|
|
|
// Draw models
|
|
RenderModels( &info, nModelTypeCount, pModelList, nCount, renderMode );
|
|
|
|
rdLock.Release();
|
|
|
|
if ( renderMode == MODEL_RENDER_MODE_NORMAL )
|
|
{
|
|
modelrender->CleanupStaticLightingState( nColorMeshHandles, pColorMeshHandles );
|
|
stackfree( pColorMeshHandles );
|
|
}
|
|
|
|
// Blat out temporary memory for bone-to-world transforms
|
|
m_BoneToWorld.FreeAll( false );
|
|
|
|
RenderDebugOverlays( nModelTypeCount, pModelList, renderMode );
|
|
|
|
m_pRenderContext = NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes per-instance data for fast path rendering
|
|
//-----------------------------------------------------------------------------
|
|
void CModelRenderSystem::ComputeTranslucentRenderData( ModelRenderSystemData_t *pModels, int nCount, TranslucentInstanceRenderData_t *pRenderData, TranslucentTempData_t *pTempData )
|
|
{
|
|
if ( nCount == 0 )
|
|
{
|
|
pTempData->m_nColorMeshHandleCount = 0;
|
|
pTempData->m_bReleaseRenderData = false;
|
|
return;
|
|
}
|
|
|
|
VPROF_BUDGET( "CModelRenderSystem::ComputeTranslucentRenderData", VPROF_BUDGETGROUP_MODEL_FAST_PATH_RENDERING );
|
|
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
|
|
|
|
// While doing this, we need materialsystem to keep around its temp allocations
|
|
// which we use for bone matrices + flexes
|
|
CMatRenderContextPtr matRenderContext( g_pMaterialSystem );
|
|
m_pRenderContext = matRenderContext;
|
|
|
|
PIXEVENT( m_pRenderContext, "CModelRenderSystem::ComputeTranslucentRenderData (FASTPATH)" );
|
|
|
|
m_pRenderContext->AddRefRenderData();
|
|
pTempData->m_bReleaseRenderData = true;
|
|
|
|
ModelRenderMode_t renderMode = MODEL_RENDER_MODE_NORMAL;
|
|
|
|
// FIXME: This is infected-specific for perf test reasons.
|
|
// Will break into a more fixed pipeline at a later date
|
|
DataCacheHandle_t *pColorMeshHandles = pTempData->m_pColorMeshHandles;
|
|
ModelListByType_t *pModelList = (ModelListByType_t*)stackalloc( nCount * sizeof(ModelListByType_t) );
|
|
ModelListNode_t *pModelListNode = (ModelListNode_t*)stackalloc( nCount * sizeof(ModelListNode_t) );
|
|
int nModelsRenderingStencilCount = 0;
|
|
int nModelTypeCount = BucketModelsByMDL( pModelList, pModelListNode, pModels, nCount, renderMode, &nModelsRenderingStencilCount );
|
|
|
|
LightingList_t pLightingList[ LIGHTING_MODEL_COUNT ];
|
|
memset( pLightingList, 0, LIGHTING_MODEL_COUNT * sizeof(LightingList_t) );
|
|
SortBucketsByDependency( nModelTypeCount, pModelList, pLightingList );
|
|
|
|
// Compute LODs for each model
|
|
ComputeModelLODs( nModelTypeCount, pModelList, pModelListNode, renderMode );
|
|
|
|
// Sort processing list by body, lod, skin, etc.
|
|
RenderModelInfo_t *pSortedModelListNode = (RenderModelInfo_t*)stackalloc( nCount * sizeof(RenderModelInfo_t) );
|
|
SortModels( pSortedModelListNode, nModelTypeCount, pModelList, pModelListNode );
|
|
|
|
// Setup bones
|
|
SetupBones( nModelTypeCount, pModelList );
|
|
|
|
// Setup flexes
|
|
SetupFlexes( nModelTypeCount, pModelList );
|
|
|
|
// Setup lighting
|
|
pTempData->m_nColorMeshHandleCount = SetupLighting( pLightingList, nModelTypeCount, pModelList, pColorMeshHandles, renderMode );
|
|
|
|
// Setup flashlights + decals
|
|
StudioModelArrayInfo2_t info;
|
|
SetupFlashlightsAndDecals( &info, nModelTypeCount, pModelList, nCount, pSortedModelListNode, renderMode );
|
|
|
|
// Setup per-instance color modulation
|
|
SetupPerInstanceColorModulation( nModelTypeCount, pModelList );
|
|
|
|
// Setup per-instance wound data
|
|
// SetupInfectedWoundRenderData( nModelTypeCount, pModelList, nCount, renderMode );
|
|
|
|
// Draw models
|
|
SetupTranslucentData( nModelTypeCount, pModelList, nCount, pRenderData );
|
|
|
|
// Blat out temporary memory for bone-to-world transforms
|
|
m_BoneToWorld.FreeAll( false );
|
|
|
|
RenderDebugOverlays( nModelTypeCount, pModelList, renderMode );
|
|
|
|
m_pRenderContext = NULL;
|
|
}
|
|
|
|
void CModelRenderSystem::CleanupTranslucentTempData( TranslucentTempData_t *pTempData )
|
|
{
|
|
if ( pTempData->m_bReleaseRenderData )
|
|
{
|
|
modelrender->CleanupStaticLightingState( pTempData->m_nColorMeshHandleCount, pTempData->m_pColorMeshHandles );
|
|
CMatRenderContextPtr matRenderContext( g_pMaterialSystem );
|
|
matRenderContext->ReleaseRenderData();
|
|
}
|
|
}
|