204 lines
7.5 KiB
C++
204 lines
7.5 KiB
C++
//===== Copyright 1996-2007, Valve Corporation, All rights reserved. ======//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//===========================================================================//
|
|
|
|
#ifndef BRUSHBATCHRENDER_H
|
|
#define BRUSHBATCHRENDER_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
|
|
|
|
// UNDONE: These are really guesses. Do we ever exceed these limits?
|
|
const int MAX_TRANS_NODES = 256;
|
|
const int MAX_TRANS_DECALS = 256;
|
|
const int MAX_TRANS_BATCHES = 1024;
|
|
const int MAX_TRANS_SURFACES = 1024;
|
|
|
|
class CBrushBatchRender
|
|
{
|
|
public:
|
|
// These are the compact structs produced by the brush render cache. The goal is to have a compact
|
|
// list of drawing instructions for drawing an opaque brush model in the most optimal order.
|
|
// These structs contain ONLY the opaque surfaces of a brush model.
|
|
struct brushrendersurface_t
|
|
{
|
|
short surfaceIndex;
|
|
short planeIndex;
|
|
};
|
|
|
|
// a batch is a list of surfaces with the same material - they can be drawn with one call to the materialsystem
|
|
struct brushrenderbatch_t
|
|
{
|
|
short firstSurface;
|
|
short surfaceCount;
|
|
IMaterial *pMaterial;
|
|
int sortID;
|
|
int indexCount;
|
|
};
|
|
|
|
// a mesh is a list of batches with the same vertex format.
|
|
struct brushrendermesh_t
|
|
{
|
|
short firstBatch;
|
|
short batchCount;
|
|
};
|
|
|
|
// This is the top-level struct containing all data necessary to render an opaque brush model in optimal order
|
|
struct brushrender_t
|
|
{
|
|
// UNDONE: Compact these arrays into a single allocation
|
|
// UNDONE: Compact entire struct to a single allocation? Store brushrender_t * in the linked list?
|
|
~brushrender_t()
|
|
{
|
|
delete[] pPlanes;
|
|
delete[] pMeshes;
|
|
delete[] pBatches;
|
|
delete[] pSurfaces;
|
|
pPlanes = NULL;
|
|
pMeshes = NULL;
|
|
pBatches = NULL;
|
|
pSurfaces = NULL;
|
|
}
|
|
|
|
cplane_t **pPlanes;
|
|
brushrendermesh_t *pMeshes;
|
|
brushrenderbatch_t *pBatches;
|
|
brushrendersurface_t *pSurfaces;
|
|
short planeCount;
|
|
short meshCount;
|
|
short batchCount;
|
|
short surfaceCount;
|
|
short totalIndexCount;
|
|
short totalVertexCount;
|
|
};
|
|
|
|
// Surfaces are stored in a list like this temporarily for sorting purposes only. The compact structs do not store these.
|
|
struct surfacelist_t
|
|
{
|
|
SurfaceHandle_t surfID;
|
|
short surfaceIndex;
|
|
short planeIndex;
|
|
};
|
|
|
|
// Builds a transrender_t, then executes it's drawing commands
|
|
void DrawTranslucentBrushModel( IMatRenderContext *pRenderContext, model_t *model, IClientEntity *baseentity );
|
|
|
|
void LevelInit();
|
|
brushrender_t *FindOrCreateRenderBatch( model_t *pModel );
|
|
void DrawOpaqueBrushModel( IMatRenderContext *pRenderContext, IClientEntity *baseentity, model_t *model, ERenderDepthMode_t DepthMode );
|
|
void DrawTranslucentBrushModel( IMatRenderContext *pRenderContext, IClientEntity *baseentity, model_t *model, ERenderDepthMode_t DepthMode, bool bDrawOpaque, bool bDrawTranslucent );
|
|
void DrawBrushModelShadow( IMatRenderContext *pRenderContext, model_t *model, IClientRenderable *pRenderable );
|
|
void DrawBrushModelArray( IMatRenderContext* pRenderContext, int nCount, const BrushArrayInstanceData_t *pInstanceData );
|
|
void DrawBrushModelShadowArray( IMatRenderContext* pRenderContext, int nCount, const BrushArrayInstanceData_t *pInstanceData, int nModelTypeFlags );
|
|
|
|
private:
|
|
struct BrushBatchRenderData_t
|
|
{
|
|
const BrushArrayInstanceData_t *m_pInstanceData;
|
|
IMaterial *m_pMaterial;
|
|
brushrender_t *m_pBrushRender;
|
|
uint16 m_nBatchIndex : 15;
|
|
uint16 m_nHasPaintedSurfaces : 1;
|
|
int16 m_nLightmapPage : 15;
|
|
uint16 m_nIsAlphaTested : 1;
|
|
};
|
|
|
|
// These are the compact structs produced for translucent brush models. These structs contain
|
|
// only the translucent surfaces of a brush model.
|
|
|
|
// a batch is a list of surfaces with the same material - they can be drawn with one call to the materialsystem
|
|
struct transbatch_t
|
|
{
|
|
short firstSurface;
|
|
short surfaceCount;
|
|
IMaterial *pMaterial;
|
|
int sortID;
|
|
int indexCount;
|
|
};
|
|
|
|
// This is a list of surfaces that have decals.
|
|
struct transdecal_t
|
|
{
|
|
short firstSurface;
|
|
short surfaceCount;
|
|
};
|
|
|
|
// A node is the list of batches that can be drawn without sorting errors. When no decals are present, surfaces
|
|
// from the next node may be appended to this one to improve performance without causing sorting errors.
|
|
struct transnode_t
|
|
{
|
|
short firstBatch;
|
|
short batchCount;
|
|
short firstDecalSurface;
|
|
short decalSurfaceCount;
|
|
};
|
|
|
|
// This is the top-level struct containing all data necessary to render a translucent brush model in optimal order.
|
|
// NOTE: Unlike the opaque struct, the order of the batches is view-dependent, so caching this is pointless since
|
|
// the view usually changes.
|
|
struct transrender_t
|
|
{
|
|
transnode_t nodes[MAX_TRANS_NODES];
|
|
SurfaceHandle_t surfaces[MAX_TRANS_SURFACES];
|
|
SurfaceHandle_t decalSurfaces[MAX_TRANS_DECALS];
|
|
transbatch_t batches[MAX_TRANS_BATCHES];
|
|
transbatch_t *pLastBatch; // These are used to append surfaces to existing batches across nodes.
|
|
transnode_t *pLastNode; // This improves performance.
|
|
short nodeCount;
|
|
short batchCount;
|
|
short surfaceCount;
|
|
short decalSurfaceCount;
|
|
};
|
|
|
|
struct BrushInstanceGroup_t
|
|
{
|
|
BrushBatchRenderData_t *m_pRenderData;
|
|
IMaterial *m_pActualMaterial;
|
|
IMaterial *m_pMaterial;
|
|
uint16 m_nCount : 15;
|
|
uint16 m_nHasPaintedSurfaces : 1;
|
|
uint16 m_nIndexCount;
|
|
};
|
|
|
|
private:
|
|
// build node lists
|
|
void BuildTransLists_r( transrender_t &render, model_t *model, mnode_t *node );
|
|
void DrawTransLists( IMatRenderContext *pRenderContext, transrender_t &render, void *pProxyData );
|
|
void AddSurfaceToBatch( transrender_t &render, transnode_t *pNode, transbatch_t *pBatch, SurfaceHandle_t surfID );
|
|
void AddTransNode( transrender_t &render );
|
|
void AddTransBatch( transrender_t &render, SurfaceHandle_t surfID );
|
|
void BuildBatchListToDraw( int nCount, const BrushArrayInstanceData_t *pInstanceData,
|
|
CUtlVectorFixedGrowable< BrushBatchRenderData_t, 1024 > &batchesToRender, brushrender_t **ppBrushRender );
|
|
bool DrawSortedBatchList( IMatRenderContext* pRenderContext, int nCount, BrushInstanceGroup_t *pInstanceGroup, int nMaxInstanceCount );
|
|
void DrawPaintForBatches( IMatRenderContext* pRenderContext, int nCount, const BrushInstanceGroup_t *pInstanceGroup, int nMaxInstanceCount );
|
|
void ComputeLightmapPages( int nCount, BrushBatchRenderData_t *pRenderData );
|
|
void ClearRenderHandles();
|
|
int ComputeInstanceGroups( IMatRenderContext *pRenderContext, int nCount, BrushBatchRenderData_t *pRenderData, CUtlVectorFixedGrowable< BrushInstanceGroup_t, 512 > &instanceGroups );
|
|
void DrawArrayDebugInformation( IMatRenderContext *pRenderContext, int nCount, const BrushBatchRenderData_t *pRenderData );
|
|
void DrawDecalsForBatches( IMatRenderContext *pRenderContext, int nCount, const BrushArrayInstanceData_t *pInstanceData, brushrender_t **ppBrushRender );
|
|
void BuildShadowBatchListToDraw( int nCount, const BrushArrayInstanceData_t *pInstanceData,
|
|
CUtlVectorFixedGrowable< BrushBatchRenderData_t, 1024 > &batchesToRender, int nModelTypeFlags );
|
|
void DrawShadowBatchList( IMatRenderContext* pRenderContext, int nCount, BrushInstanceGroup_t *pInstanceGroup, int nMaxInstanceCount );
|
|
|
|
static int __cdecl SurfaceCmp(const surfacelist_t *s0, const surfacelist_t *s1 );
|
|
static bool __cdecl BatchSortLessFunc( const BrushBatchRenderData_t &left, const BrushBatchRenderData_t &right );
|
|
static bool __cdecl ShadowSortLessFunc( const BrushBatchRenderData_t &left, const BrushBatchRenderData_t &right );
|
|
|
|
CThreadFastMutex m_Mutex;
|
|
CUtlLinkedList<brushrender_t*> m_renderList;
|
|
};
|
|
|
|
#if !defined( DEDICATED )
|
|
extern CBrushBatchRender g_BrushBatchRenderer;
|
|
#endif
|
|
|
|
|
|
#endif // BRUSHBATCHRENDER_H
|