3039 lines
88 KiB
C++
3039 lines
88 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include "render_pch.h"
|
|
#include "r_decal.h"
|
|
#include "client.h"
|
|
#include <materialsystem/imaterialsystemhardwareconfig.h>
|
|
#include "decal.h"
|
|
#include "tier0/vprof.h"
|
|
#include "materialsystem/materialsystem_config.h"
|
|
#include "icliententity.h"
|
|
#include "icliententitylist.h"
|
|
#include "tier2/tier2.h"
|
|
#include "tier1/callqueue.h"
|
|
#include "tier1/memstack.h"
|
|
#include "mempool.h"
|
|
#include "vstdlib/random.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#define DECAL_DISTANCE 4
|
|
|
|
// Empirically determined constants for minimizing overalpping decals
|
|
ConVar r_decal_overlap_count("r_decal_overlap_count", "3");
|
|
ConVar r_decal_overlap_area("r_decal_overlap_area", "0.4");
|
|
|
|
// if a new decal covers more than this many old decals, retire until this count remains
|
|
ConVar r_decal_cover_count("r_decal_cover_count", "4" );
|
|
|
|
static unsigned int s_DecalScaleVarCache = 0;
|
|
static unsigned int s_DecalScaleVariationVarCache = 0;
|
|
static unsigned int s_DecalFadeVarCache = 0;
|
|
static unsigned int s_DecalFadeTimeVarCache = 0;
|
|
static unsigned int s_DecalSecondPassVarCache = 0;
|
|
|
|
|
|
// This structure contains the information used to create new decals
|
|
struct decalinfo_t
|
|
{
|
|
Vector m_Position; // world coordinates of the decal center
|
|
Vector m_SAxis; // the s axis for the decal in world coordinates
|
|
model_t* m_pModel; // the model the decal is going to be applied in
|
|
worldbrushdata_t *m_pBrush; // The shared brush data for this model
|
|
IMaterial* m_pMaterial; // The decal material
|
|
float m_Size; // Size of the decal (in world coords)
|
|
int m_Flags;
|
|
int m_Entity; // Entity the decal is applied to.
|
|
float m_scale;
|
|
float m_flFadeDuration;
|
|
float m_flFadeStartTime;
|
|
int m_decalWidth;
|
|
int m_decalHeight;
|
|
color32 m_Color;
|
|
Vector m_Basis[3];
|
|
void *m_pUserData;
|
|
const Vector *m_pNormal;
|
|
CUtlVector<SurfaceHandle_t> m_aApplySurfs;
|
|
};
|
|
|
|
typedef struct
|
|
{
|
|
CDecalVert decalVert[4];
|
|
} decalcache_t;
|
|
|
|
// UNDONE: Compress this??? 256K here?
|
|
static CClassMemoryPool<decal_t> g_DecalAllocator( 128 ); // 128 decals per block.
|
|
static int g_nDynamicDecals = 0;
|
|
static int g_nStaticDecals = 0;
|
|
static int g_iLastReplacedDynamic = -1;
|
|
|
|
CUtlVector<decal_t*> s_aDecalPool;
|
|
|
|
const int DECALCACHE_ENTRY_COUNT = 1024;
|
|
const int INVALID_CACHE_ENTRY = 0xFFFF;
|
|
|
|
class ALIGN16 CDecalVertCache
|
|
{
|
|
enum decalindex_ordinal
|
|
{
|
|
DECAL_INDEX = 0, // set this and use this to free the whole decal's list on compact
|
|
NEXT_VERT_BLOCK_INDEX = 1,
|
|
IS_FREE_INDEX = 2,
|
|
FRAME_COUNT_INDEX = 3,
|
|
};
|
|
public:
|
|
void Init();
|
|
CDecalVert *GetCachedVerts( decal_t *pDecal );
|
|
void FreeCachedVerts( decal_t *pDecal );
|
|
void StoreVertsInCache( decal_t *pDecal, CDecalVert *pList );
|
|
|
|
private:
|
|
inline int GetIndex( decalcache_t *pBlock, decalindex_ordinal index )
|
|
{
|
|
return pBlock->decalVert[index].m_decalIndex;
|
|
}
|
|
inline void SetIndex( decalcache_t *pBlock, decalindex_ordinal index, int value )
|
|
{
|
|
pBlock->decalVert[index].m_decalIndex = value;
|
|
}
|
|
|
|
inline void SetNext( int iCur, int iNext )
|
|
{
|
|
SetIndex(m_cache + iCur, NEXT_VERT_BLOCK_INDEX, iNext);
|
|
}
|
|
inline void SetFree( int iBlock, bool bFree )
|
|
{
|
|
SetIndex( m_cache + iBlock, IS_FREE_INDEX, bFree );
|
|
}
|
|
inline bool IsFree(int iBlock)
|
|
{
|
|
return GetIndex(m_cache+iBlock, IS_FREE_INDEX) != 0;
|
|
}
|
|
|
|
decalcache_t *NextBlock( decalcache_t *pCache );
|
|
void FreeBlock(int cacheIndex);
|
|
// search for blocks not used this frame and free them
|
|
// this way we don't manage an LRU but get similar behavior
|
|
void FindFreeBlocks( int blockCount );
|
|
int AllocBlock();
|
|
int AllocBlocks( int blockCount );
|
|
|
|
ALIGN16 decalcache_t m_cache[DECALCACHE_ENTRY_COUNT] ALIGN16_POST;
|
|
int m_freeBlockCount;
|
|
int m_firstFree;
|
|
int m_frameBlocks;
|
|
int m_lastFrameCount;
|
|
int m_freeTestIndex;
|
|
} ALIGN16_POST;
|
|
|
|
static CDecalVertCache ALIGN16 g_DecalVertCache;
|
|
static decal_t *s_pDecalDestroyList = NULL;
|
|
|
|
int g_nMaxDecals = 0;
|
|
|
|
//
|
|
// ConVars that control distance-based decal scaling
|
|
//
|
|
static ConVar r_dscale_nearscale( "r_dscale_nearscale", "1", FCVAR_CHEAT );
|
|
static ConVar r_dscale_neardist( "r_dscale_neardist", "100", FCVAR_CHEAT );
|
|
static ConVar r_dscale_farscale( "r_dscale_farscale", "4", FCVAR_CHEAT );
|
|
static ConVar r_dscale_fardist( "r_dscale_fardist", "2000", FCVAR_CHEAT );
|
|
static ConVar r_dscale_basefov( "r_dscale_basefov", "90", FCVAR_CHEAT );
|
|
|
|
ConVar r_spray_lifetime( "r_spray_lifetime", "2", 0, "Number of rounds player sprays are visible" );
|
|
ConVar r_queued_decals( "r_queued_decals", "0", 0, "Offloads a bit of decal rendering setup work to the material system queue when enabled." );
|
|
|
|
|
|
// This makes sure all the decals got freed before the engine is shutdown.
|
|
static class CDecalChecker
|
|
{
|
|
public:
|
|
~CDecalChecker()
|
|
{
|
|
Assert( g_nDynamicDecals == 0 );
|
|
}
|
|
} g_DecalChecker;
|
|
|
|
// used for decal LOD
|
|
VMatrix g_BrushToWorldMatrix;
|
|
|
|
static CUtlVector<SurfaceHandle_t> s_DecalSurfaces[ MAX_MAT_SORT_GROUPS + 1 ];
|
|
static ConVar r_drawdecals( "r_drawdecals", "1", FCVAR_CHEAT, "Render decals." );
|
|
static ConVar r_drawbatchdecals( "r_drawbatchdecals", "1", 0, "Render decals batched." );
|
|
|
|
#ifndef SWDS
|
|
static void R_DecalCreate( decalinfo_t* pDecalInfo, SurfaceHandle_t surfID, float x, float y, bool bForceForDisplacement );
|
|
static bool R_DecalUnProject( decal_t *pdecal, decallist_t *entry);
|
|
#endif
|
|
void R_DecalShoot( int textureIndex, int entity, const model_t *model, const Vector &position, const float *saxis, int flags, const color32 &rgbaColor, const Vector *pNormal );
|
|
void R_DecalSortInit( void );
|
|
|
|
static void r_printdecalinfo_f()
|
|
{
|
|
int nPermanent = 0;
|
|
int nDynamic = 0;
|
|
|
|
for ( int i=0; i < g_nMaxDecals; i++ )
|
|
{
|
|
if ( s_aDecalPool[i] )
|
|
{
|
|
if ( s_aDecalPool[i]->flags & FDECAL_PERMANENT )
|
|
++nPermanent;
|
|
else
|
|
++nDynamic;
|
|
}
|
|
}
|
|
|
|
Assert( nDynamic == g_nDynamicDecals );
|
|
Msg( "%d decals: %d permanent, %d dynamic\nr_decals: %d\n", nPermanent+nDynamic, nPermanent, nDynamic, r_decals.GetInt() );
|
|
}
|
|
|
|
static ConCommand r_printdecalinfo( "r_printdecalinfo", r_printdecalinfo_f );
|
|
|
|
|
|
void CDecalVertCache::StoreVertsInCache( decal_t *pDecal, CDecalVert *pList )
|
|
{
|
|
int vertCount = pDecal->clippedVertCount;
|
|
int blockCount = (vertCount+3)>>2;
|
|
FindFreeBlocks(blockCount);
|
|
if ( blockCount > m_freeBlockCount )
|
|
return;
|
|
int cacheHandle = AllocBlocks(blockCount);
|
|
pDecal->cacheHandle = cacheHandle;
|
|
decalcache_t *pCache = &m_cache[cacheHandle];
|
|
while ( blockCount )
|
|
{
|
|
Assert(GetIndex(pCache, DECAL_INDEX) == -1 );
|
|
// don't memcpy here it overwrites the indices we're storing in the m_decalIndex data
|
|
for ( int i = 0; i < 4; i++ )
|
|
{
|
|
pCache->decalVert[i].m_vPos = pList[i].m_vPos;
|
|
pCache->decalVert[i].m_ctCoords = pList[i].m_ctCoords;
|
|
pCache->decalVert[i].m_cLMCoords = pList[i].m_cLMCoords;
|
|
}
|
|
|
|
pList += 4;
|
|
blockCount--;
|
|
SetIndex( pCache, DECAL_INDEX, pDecal->m_iDecalPool );
|
|
SetIndex( pCache, FRAME_COUNT_INDEX, r_framecount );
|
|
pCache = NextBlock(pCache);
|
|
}
|
|
}
|
|
|
|
void CDecalVertCache::FreeCachedVerts( decal_t *pDecal )
|
|
{
|
|
// walk the list
|
|
int nextIndex = INVALID_CACHE_ENTRY;
|
|
for ( int cacheHandle = pDecal->cacheHandle; cacheHandle != INVALID_CACHE_ENTRY; cacheHandle = nextIndex )
|
|
{
|
|
decalcache_t *pCache = m_cache + cacheHandle;
|
|
nextIndex = GetIndex(pCache, NEXT_VERT_BLOCK_INDEX);
|
|
Assert(GetIndex(pCache,DECAL_INDEX)==pDecal->m_iDecalPool);
|
|
FreeBlock(cacheHandle);
|
|
}
|
|
pDecal->cacheHandle = INVALID_CACHE_ENTRY;
|
|
pDecal->clippedVertCount = 0;
|
|
}
|
|
|
|
CDecalVert *CDecalVertCache::GetCachedVerts( decal_t *pDecal )
|
|
{
|
|
int cacheHandle = pDecal->cacheHandle;
|
|
// track blocks used this frame to avoid thrashing
|
|
if ( r_framecount != m_lastFrameCount )
|
|
{
|
|
m_frameBlocks = 0;
|
|
m_lastFrameCount = r_framecount;
|
|
}
|
|
|
|
if ( cacheHandle == INVALID_CACHE_ENTRY )
|
|
return NULL;
|
|
decalcache_t *pCache = &m_cache[cacheHandle];
|
|
for ( int i = cacheHandle; i != INVALID_CACHE_ENTRY; i = GetIndex(&m_cache[i], NEXT_VERT_BLOCK_INDEX) )
|
|
{
|
|
SetIndex( pCache, FRAME_COUNT_INDEX, r_framecount );
|
|
Assert( GetIndex(pCache, DECAL_INDEX) == pDecal->m_iDecalPool);
|
|
}
|
|
|
|
int vertCount = pDecal->clippedVertCount;
|
|
int blockCount = (vertCount+3)>>2;
|
|
m_frameBlocks += blockCount;
|
|
|
|
// Make linked vert lists contiguous by copying to the clip buffer
|
|
if ( blockCount > 1 )
|
|
{
|
|
int indexOut = 0;
|
|
while ( blockCount )
|
|
{
|
|
V_memcpy( &g_DecalClipVerts[indexOut], pCache, sizeof(*pCache) );
|
|
indexOut += 4;
|
|
blockCount --;
|
|
pCache = NextBlock(pCache);
|
|
}
|
|
return g_DecalClipVerts;
|
|
}
|
|
// only one block, no need to copy
|
|
return pCache->decalVert;
|
|
}
|
|
|
|
void CDecalVertCache::Init()
|
|
{
|
|
m_firstFree = 0;
|
|
m_freeTestIndex = 0;
|
|
for ( int i = 0; i < DECALCACHE_ENTRY_COUNT; i++ )
|
|
{
|
|
SetNext( i, i+1 );
|
|
SetIndex( &m_cache[i], DECAL_INDEX, -1 );
|
|
SetFree( i, true );
|
|
}
|
|
SetNext( DECALCACHE_ENTRY_COUNT-1, INVALID_CACHE_ENTRY );
|
|
m_freeBlockCount = DECALCACHE_ENTRY_COUNT;
|
|
}
|
|
|
|
decalcache_t *CDecalVertCache::NextBlock( decalcache_t *pCache )
|
|
{
|
|
int nextIndex = GetIndex(pCache, NEXT_VERT_BLOCK_INDEX);
|
|
if ( nextIndex == INVALID_CACHE_ENTRY )
|
|
return NULL;
|
|
return m_cache + nextIndex;
|
|
}
|
|
void CDecalVertCache::FreeBlock(int cacheIndex)
|
|
{
|
|
SetFree( cacheIndex, true );
|
|
SetNext( cacheIndex, m_firstFree );
|
|
SetIndex( &m_cache[cacheIndex], DECAL_INDEX, -1 );
|
|
|
|
m_firstFree = cacheIndex;
|
|
m_freeBlockCount++;
|
|
}
|
|
|
|
// search for blocks not used this frame and free them
|
|
// this way we don't manage an LRU but get similar behavior
|
|
void CDecalVertCache::FindFreeBlocks( int blockCount )
|
|
{
|
|
if ( blockCount <= m_freeBlockCount )
|
|
return;
|
|
int possibleFree = DECALCACHE_ENTRY_COUNT - m_frameBlocks;
|
|
if ( blockCount > possibleFree )
|
|
return;
|
|
|
|
// limit the search for performance to 16 entries
|
|
int lastTest = (m_freeTestIndex + 16) & (DECALCACHE_ENTRY_COUNT-1);
|
|
|
|
for ( ; m_freeTestIndex != lastTest; m_freeTestIndex = (m_freeTestIndex+1)&(DECALCACHE_ENTRY_COUNT-1) )
|
|
{
|
|
if ( !IsFree(m_freeTestIndex) )
|
|
{
|
|
int lastFrame = GetIndex(&m_cache[m_freeTestIndex], FRAME_COUNT_INDEX);
|
|
if ( (r_framecount - lastFrame) > 1 )
|
|
{
|
|
int iDecal = GetIndex(&m_cache[m_freeTestIndex], DECAL_INDEX);
|
|
FreeCachedVerts(s_aDecalPool[iDecal]);
|
|
}
|
|
}
|
|
if ( m_freeBlockCount >= blockCount )
|
|
break;
|
|
}
|
|
}
|
|
|
|
int CDecalVertCache::AllocBlock()
|
|
{
|
|
if ( !m_freeBlockCount )
|
|
return INVALID_CACHE_ENTRY;
|
|
Assert(IsFree(m_firstFree));
|
|
int nextFree = GetIndex(m_cache+m_firstFree, NEXT_VERT_BLOCK_INDEX );
|
|
int cacheIndex = m_firstFree;
|
|
SetFree( cacheIndex, false );
|
|
m_firstFree = nextFree;
|
|
m_freeBlockCount--;
|
|
return cacheIndex;
|
|
}
|
|
int CDecalVertCache::AllocBlocks( int blockCount )
|
|
{
|
|
if ( blockCount > m_freeBlockCount )
|
|
return INVALID_CACHE_ENTRY;
|
|
int firstBlock = AllocBlock();
|
|
Assert(firstBlock!=INVALID_CACHE_ENTRY);
|
|
int blockHandle = firstBlock;
|
|
for ( int i = 1; i < blockCount; i++ )
|
|
{
|
|
int nextBlock = AllocBlock();
|
|
Assert(nextBlock!=INVALID_CACHE_ENTRY);
|
|
SetIndex( m_cache + blockHandle, NEXT_VERT_BLOCK_INDEX, nextBlock );
|
|
blockHandle = nextBlock;
|
|
}
|
|
SetIndex( m_cache + blockHandle, NEXT_VERT_BLOCK_INDEX, INVALID_CACHE_ENTRY );
|
|
return firstBlock;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the offset for a decal polygon
|
|
//-----------------------------------------------------------------------------
|
|
float ComputeDecalLightmapOffset( SurfaceHandle_t surfID )
|
|
{
|
|
float flOffset;
|
|
if ( MSurf_Flags( surfID ) & SURFDRAW_BUMPLIGHT )
|
|
{
|
|
int nWidth, nHeight;
|
|
materials->GetLightmapPageSize(
|
|
SortInfoToLightmapPage( MSurf_MaterialSortID( surfID ) ), &nWidth, &nHeight );
|
|
int nXExtent = ( MSurf_LightmapExtents( surfID )[0] ) + 1;
|
|
|
|
flOffset = ( nWidth != 0 ) ? (float)nXExtent / (float)nWidth : 0.0f;
|
|
}
|
|
else
|
|
{
|
|
flOffset = 0.0f;
|
|
}
|
|
return flOffset;
|
|
}
|
|
|
|
static VertexFormat_t GetUncompressedFormat( const IMaterial * pMaterial )
|
|
{
|
|
// FIXME: IMaterial::GetVertexFormat() should do this stripping (add a separate 'SupportsCompression' accessor)
|
|
return ( pMaterial->GetVertexFormat() & ~VERTEX_FORMAT_COMPRESSED );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Draws a decal polygon
|
|
//-----------------------------------------------------------------------------
|
|
void Shader_DecalDrawPoly( CDecalVert *v, IMaterial *pMaterial, SurfaceHandle_t surfID, int vertCount, decal_t *pdecal, float flFade )
|
|
{
|
|
#ifndef SWDS
|
|
int vertexFormat = 0;
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
#ifdef USE_CONVARS
|
|
if( ShouldDrawInWireFrameMode() )
|
|
{
|
|
pRenderContext->Bind( g_materialDecalWireframe );
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
Assert( MSurf_MaterialSortID( surfID ) >= 0 &&
|
|
MSurf_MaterialSortID( surfID ) < g_WorldStaticMeshes.Count() );
|
|
pRenderContext->BindLightmapPage( materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID );
|
|
pRenderContext->Bind( pMaterial, pdecal->userdata );
|
|
vertexFormat = GetUncompressedFormat( pMaterial );
|
|
}
|
|
|
|
IMesh *pMesh = pRenderContext->GetDynamicMesh( );
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_POLYGON, vertCount );
|
|
|
|
byte color[4] = {pdecal->color.r,pdecal->color.g,pdecal->color.b,pdecal->color.a};
|
|
if ( flFade != 1.0f )
|
|
{
|
|
color[3] = (byte)( color[3] * flFade );
|
|
}
|
|
|
|
// Deal with fading out... (should this be done in the shader?)
|
|
// Note that we do it with per-vertex color even though the translucency
|
|
// is constant so as to not change any rendering state (like the constant
|
|
// alpha value)
|
|
if (pdecal->flags & FDECAL_DYNAMIC)
|
|
{
|
|
float fadeval;
|
|
|
|
// Negative fadeDuration value means to fade in
|
|
if (pdecal->fadeDuration < 0)
|
|
{
|
|
fadeval = - (cl.GetTime() - pdecal->fadeStartTime) / pdecal->fadeDuration;
|
|
}
|
|
else
|
|
{
|
|
fadeval = 1.0 - (cl.GetTime() - pdecal->fadeStartTime) / pdecal->fadeDuration;
|
|
}
|
|
|
|
fadeval = clamp( fadeval, 0.0f, 1.0f );
|
|
color[3] = (byte) (color[3] * fadeval);
|
|
}
|
|
|
|
|
|
Vector normal(0,0,1), tangentS(1,0,0), tangentT(0,1,0);
|
|
|
|
if ( vertexFormat & (VERTEX_NORMAL|VERTEX_TANGENT_SPACE) )
|
|
{
|
|
normal = MSurf_Plane( surfID ).normal;
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
Vector tVect;
|
|
bool negate = TangentSpaceSurfaceSetup( surfID, tVect );
|
|
TangentSpaceComputeBasis( tangentS, tangentT, normal, tVect, negate );
|
|
}
|
|
}
|
|
|
|
float flOffset = pdecal->lightmapOffset;
|
|
|
|
for( int i = 0; i < vertCount; i++, v++ )
|
|
{
|
|
meshBuilder.Position3f( VectorExpand( v->m_vPos ) );
|
|
if ( vertexFormat & VERTEX_NORMAL )
|
|
{
|
|
meshBuilder.Normal3fv( normal.Base() );
|
|
}
|
|
meshBuilder.Color4ubv( color );
|
|
|
|
// Check to see if we are in a material page.
|
|
meshBuilder.TexCoord2f( 0, Vector2DExpand( v->m_ctCoords ) );
|
|
meshBuilder.TexCoord2f( 1, Vector2DExpand( v->m_cLMCoords ) );
|
|
meshBuilder.TexCoord1f( 2, flOffset );
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
meshBuilder.TangentS3fv( tangentS.Base() );
|
|
meshBuilder.TangentT3fv( tangentT.Base() );
|
|
}
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets the decal material and radius based on the decal index
|
|
//-----------------------------------------------------------------------------
|
|
void R_DecalGetMaterialAndSize( int decalIndex, IMaterial*& pDecalMaterial, float& w, float& h )
|
|
{
|
|
pDecalMaterial = Draw_DecalMaterial( decalIndex );
|
|
if (!pDecalMaterial)
|
|
return;
|
|
|
|
float scale = 1.0f;
|
|
|
|
// Compute scale of surface
|
|
// FIXME: cache this?
|
|
bool found;
|
|
IMaterialVar* pDecalScaleVar = pDecalMaterial->FindVar( "$decalScale", &found, false );
|
|
if( found )
|
|
{
|
|
scale = pDecalScaleVar->GetFloatValue();
|
|
}
|
|
|
|
// compute the decal dimensions in world space
|
|
w = pDecalMaterial->GetMappingWidth() * scale;
|
|
h = pDecalMaterial->GetMappingHeight() * scale;
|
|
}
|
|
|
|
#ifndef SWDS
|
|
|
|
|
|
|
|
static inline decal_t *MSurf_DecalPointer( SurfaceHandle_t surfID )
|
|
{
|
|
WorldDecalHandle_t handle = MSurf_Decals(surfID );
|
|
if ( handle == WORLD_DECAL_HANDLE_INVALID )
|
|
return NULL;
|
|
|
|
return s_aDecalPool[handle];
|
|
}
|
|
|
|
static WorldDecalHandle_t DecalToHandle( decal_t *pDecal )
|
|
{
|
|
if ( !pDecal )
|
|
return WORLD_DECAL_HANDLE_INVALID;
|
|
|
|
int decalIndex = pDecal->m_iDecalPool;
|
|
Assert( decalIndex >= 0 && decalIndex < g_nMaxDecals );
|
|
return static_cast<WorldDecalHandle_t> (decalIndex);
|
|
}
|
|
|
|
// Init the decal pool
|
|
void R_DecalInit( void )
|
|
{
|
|
g_nMaxDecals = Q_atoi( r_decals.GetDefault() );
|
|
g_nMaxDecals = MAX(64, g_nMaxDecals);
|
|
Assert( g_DecalAllocator.Count() == 0 );
|
|
g_nDynamicDecals = 0;
|
|
g_nStaticDecals = 0;
|
|
g_iLastReplacedDynamic = -1;
|
|
|
|
s_aDecalPool.Purge();
|
|
s_aDecalPool.SetSize( g_nMaxDecals );
|
|
|
|
int i;
|
|
|
|
// Traverse all surfaces of map and throw away current decals
|
|
//
|
|
// sort the surfaces into the sort arrays
|
|
if ( host_state.worldbrush )
|
|
{
|
|
for( i = 0; i < host_state.worldbrush->numsurfaces; i++ )
|
|
{
|
|
SurfaceHandle_t surfID = SurfaceHandleFromIndex(i);
|
|
MSurf_Decals( surfID ) = WORLD_DECAL_HANDLE_INVALID;
|
|
}
|
|
}
|
|
|
|
for( int iDecal = 0; iDecal < g_nMaxDecals; ++iDecal )
|
|
{
|
|
s_aDecalPool[iDecal] = NULL;
|
|
}
|
|
|
|
g_DecalVertCache.Init();
|
|
|
|
R_DecalSortInit();
|
|
}
|
|
|
|
void R_DecalTerm( worldbrushdata_t *pBrushData, bool term_permanent_decals )
|
|
{
|
|
if( !pBrushData )
|
|
return;
|
|
|
|
for( int i = 0; i < pBrushData->numsurfaces; i++ )
|
|
{
|
|
decal_t *pNext;
|
|
SurfaceHandle_t surfID = SurfaceHandleFromIndex( i, pBrushData );
|
|
for( decal_t *pDecal=MSurf_DecalPointer( surfID ); pDecal; pDecal=pNext )
|
|
{
|
|
pNext = pDecal->pnext;
|
|
if ( term_permanent_decals
|
|
|| (!(pDecal->flags & FDECAL_PERMANENT)
|
|
&& !(pDecal->flags & FDECAL_PLAYERSPRAY)) )
|
|
{
|
|
R_DecalUnlink( pDecal, pBrushData );
|
|
}
|
|
else if( pDecal->flags & FDECAL_PLAYERSPRAY )
|
|
{
|
|
// time out player spray after some number of rounds
|
|
pDecal->fadeStartTime += 1.0f;
|
|
if( pDecal->fadeStartTime >= r_spray_lifetime.GetFloat() )
|
|
{
|
|
R_DecalUnlink( pDecal, pBrushData );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( term_permanent_decals )
|
|
{
|
|
Assert( MSurf_DecalPointer( surfID ) == NULL );
|
|
}
|
|
}
|
|
}
|
|
|
|
void R_DecalTermAll()
|
|
{
|
|
s_pDecalDestroyList = NULL;
|
|
for ( int i = 0; i<s_aDecalPool.Count(); i++ )
|
|
{
|
|
R_DecalUnlink( s_aDecalPool[i], host_state.worldbrush );
|
|
}
|
|
}
|
|
|
|
|
|
static int R_DecalIndex( decal_t *pdecal )
|
|
{
|
|
return pdecal->m_iDecalPool;
|
|
}
|
|
|
|
|
|
// Release the cache entry for this decal
|
|
static void R_DecalCacheClear( decal_t *pdecal )
|
|
{
|
|
g_DecalVertCache.FreeCachedVerts( pdecal );
|
|
}
|
|
|
|
|
|
void R_DecalFlushDestroyList( void )
|
|
{
|
|
decal_t *pDecal = s_pDecalDestroyList;
|
|
while ( pDecal )
|
|
{
|
|
decal_t *pNext = pDecal->pDestroyList;
|
|
R_DecalUnlink( pDecal, host_state.worldbrush );
|
|
pDecal = pNext;
|
|
}
|
|
s_pDecalDestroyList = NULL;
|
|
}
|
|
|
|
static void R_DecalAddToDestroyList( decal_t *pDecal )
|
|
{
|
|
if ( !pDecal->pDestroyList )
|
|
{
|
|
pDecal->pDestroyList = s_pDecalDestroyList;
|
|
s_pDecalDestroyList = pDecal;
|
|
}
|
|
}
|
|
|
|
// Unlink pdecal from any surface it's attached to
|
|
void R_DecalUnlink( decal_t *pdecal, worldbrushdata_t *pData )
|
|
{
|
|
if ( !pdecal )
|
|
return;
|
|
|
|
decal_t *tmp;
|
|
|
|
R_DecalCacheClear( pdecal );
|
|
if ( IS_SURF_VALID( pdecal->surfID ) )
|
|
{
|
|
if ( MSurf_DecalPointer( pdecal->surfID ) == pdecal )
|
|
{
|
|
MSurf_Decals( pdecal->surfID ) = DecalToHandle( pdecal->pnext );
|
|
}
|
|
else
|
|
{
|
|
tmp = MSurf_DecalPointer( pdecal->surfID );
|
|
if ( !tmp )
|
|
Sys_Error("Bad decal list");
|
|
while ( tmp->pnext )
|
|
{
|
|
if ( tmp->pnext == pdecal )
|
|
{
|
|
tmp->pnext = pdecal->pnext;
|
|
break;
|
|
}
|
|
tmp = tmp->pnext;
|
|
}
|
|
}
|
|
|
|
// Tell the displacement surface.
|
|
if( SurfaceHasDispInfo( pdecal->surfID ) )
|
|
{
|
|
IDispInfo * pDispInfo = MSurf_DispInfo( pdecal->surfID, pData );
|
|
|
|
if ( pDispInfo )
|
|
pDispInfo->NotifyRemoveDecal( pdecal->m_DispDecal );
|
|
}
|
|
}
|
|
|
|
pdecal->surfID = SURFACE_HANDLE_INVALID;
|
|
|
|
if ( !(pdecal->flags & FDECAL_PERMANENT) )
|
|
{
|
|
--g_nDynamicDecals;
|
|
Assert( g_nDynamicDecals >= 0 );
|
|
}
|
|
else
|
|
{
|
|
--g_nStaticDecals;
|
|
Assert( g_nStaticDecals >= 0 );
|
|
}
|
|
|
|
// Free the decal.
|
|
Assert( s_aDecalPool[pdecal->m_iDecalPool] == pdecal );
|
|
s_aDecalPool[pdecal->m_iDecalPool] = NULL;
|
|
g_DecalAllocator.Free( pdecal );
|
|
}
|
|
|
|
|
|
int R_FindFreeDecalSlot()
|
|
{
|
|
for ( int i=0; i < g_nMaxDecals; i++ )
|
|
{
|
|
if ( !s_aDecalPool[i] )
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Uncomment this to spew decals if we run out of space!!!
|
|
// #define SPEW_DECALS
|
|
#if defined( SPEW_DECALS )
|
|
void SpewDecals()
|
|
{
|
|
static bool spewdecals = true;
|
|
|
|
if ( spewdecals )
|
|
{
|
|
spewdecals = false;
|
|
|
|
int i = 0;
|
|
for ( i = 0 ; i < g_nMaxDecals; ++i )
|
|
{
|
|
decal_t *decal = s_aDecalPool[ i ];
|
|
Assert( decal );
|
|
if ( decal )
|
|
{
|
|
bool permanent = ( decal->flags & FDECAL_PERMANENT ) ? true : false;
|
|
Msg( "%i == %s on %i perm %i at %.2f %.2f %.2f on surf %i (%.2f %.2f %2.f)\n",
|
|
i,
|
|
decal->material->GetName(),
|
|
(int)decal->entityIndex,
|
|
permanent ? 1 : 0,
|
|
decal->position.x, decal->position.y, decal->position.z,
|
|
(int)decal->surfID,
|
|
decal->dx,
|
|
decal->dy,
|
|
decal->scale );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
int R_FindDynamicDecalSlot( int iStartAt )
|
|
{
|
|
if ( (iStartAt >= g_nMaxDecals) || (iStartAt < 0) )
|
|
{
|
|
iStartAt = 0;
|
|
}
|
|
|
|
int i = iStartAt;
|
|
|
|
do
|
|
{
|
|
// don't deallocate player sprays or permanent decals
|
|
if ( s_aDecalPool[i] &&
|
|
!(s_aDecalPool[i]->flags & FDECAL_PERMANENT) &&
|
|
!(s_aDecalPool[i]->flags & FDECAL_PLAYERSPRAY) )
|
|
return i;
|
|
|
|
++i;
|
|
|
|
if ( i >= g_nMaxDecals )
|
|
i = 0;
|
|
}
|
|
while ( i != iStartAt );
|
|
|
|
DevMsg("R_FindDynamicDecalSlot: no slot available.\n");
|
|
|
|
#if defined( SPEW_DECALS )
|
|
SpewDecals();
|
|
#endif
|
|
|
|
return -1;
|
|
}
|
|
|
|
// Just reuse next decal in list
|
|
// A decal that spans multiple surfaces will use multiple decal_t pool entries, as each surface needs
|
|
// it's own.
|
|
static decal_t *R_DecalAlloc( int flags )
|
|
{
|
|
static bool bWarningOnce = false;
|
|
bool bPermanent = (flags & FDECAL_PERMANENT) != 0;
|
|
|
|
int dynamicDecalLimit = min( r_decals.GetInt(), g_nMaxDecals );
|
|
|
|
// Now find a slot. Unless it's dynamic and we're at the limit of dynamic decals,
|
|
// we can look for a free slot.
|
|
int iSlot = -1;
|
|
if ( bPermanent || (g_nDynamicDecals < dynamicDecalLimit) )
|
|
{
|
|
iSlot = R_FindFreeDecalSlot();
|
|
}
|
|
|
|
if ( iSlot == -1 )
|
|
{
|
|
iSlot = R_FindDynamicDecalSlot( g_iLastReplacedDynamic+1 );
|
|
if ( iSlot == -1 )
|
|
{
|
|
if ( !bWarningOnce )
|
|
{
|
|
// Can't find a free slot. Just kill the first one.
|
|
DevWarning( 1, "Exceeded MAX_DECALS (%d).\n", g_nMaxDecals );
|
|
bWarningOnce = true;
|
|
}
|
|
iSlot = 0;
|
|
}
|
|
|
|
R_DecalUnlink( s_aDecalPool[iSlot], host_state.worldbrush );
|
|
g_iLastReplacedDynamic = iSlot;
|
|
}
|
|
|
|
// Setup the new decal.
|
|
decal_t *pDecal = g_DecalAllocator.Alloc();
|
|
s_aDecalPool[iSlot] = pDecal;
|
|
pDecal->pDestroyList = NULL;
|
|
pDecal->m_iDecalPool = iSlot;
|
|
pDecal->surfID = SURFACE_HANDLE_INVALID;
|
|
pDecal->cacheHandle = INVALID_CACHE_ENTRY;
|
|
pDecal->clippedVertCount = 0;
|
|
|
|
if ( !bPermanent )
|
|
{
|
|
++g_nDynamicDecals;
|
|
}
|
|
else
|
|
{
|
|
++g_nStaticDecals;
|
|
}
|
|
|
|
return pDecal;
|
|
}
|
|
|
|
/*
|
|
// The world coordinate system is right handed with Z up.
|
|
//
|
|
// ^ Z
|
|
// |
|
|
// |
|
|
// |
|
|
//X<----|
|
|
// \
|
|
// \
|
|
// \ Y
|
|
*/
|
|
|
|
void R_DecalSurface( SurfaceHandle_t surfID, decalinfo_t *decalinfo, bool bForceForDisplacement )
|
|
{
|
|
if ( decalinfo->m_pNormal )
|
|
{
|
|
if ( DotProduct( MSurf_Plane( surfID ).normal, *(decalinfo->m_pNormal) ) < 0.0f )
|
|
return;
|
|
}
|
|
|
|
// Get the texture associated with this surface
|
|
mtexinfo_t* tex = MSurf_TexInfo( surfID );
|
|
|
|
Vector4D &textureU = tex->textureVecsTexelsPerWorldUnits[0];
|
|
Vector4D &textureV = tex->textureVecsTexelsPerWorldUnits[1];
|
|
|
|
// project decal center into the texture space of the surface
|
|
float s = DotProduct( decalinfo->m_Position, textureU.AsVector3D() ) +
|
|
textureU.w - MSurf_TextureMins( surfID )[0];
|
|
float t = DotProduct( decalinfo->m_Position, textureV.AsVector3D() ) +
|
|
textureV.w - MSurf_TextureMins( surfID )[1];
|
|
|
|
|
|
// Determine the decal basis (measured in world space)
|
|
// Note that the decal basis vectors 0 and 1 will always lie in the same
|
|
// plane as the texture space basis vectors textureVecsTexelsPerWorldUnits.
|
|
|
|
R_DecalComputeBasis( MSurf_Plane( surfID ).normal,
|
|
(decalinfo->m_Flags & FDECAL_USESAXIS) ? &decalinfo->m_SAxis : 0,
|
|
decalinfo->m_Basis );
|
|
|
|
// Compute an effective width and height (axis aligned) in the parent texture space
|
|
// How does this work? decalBasis[0] represents the u-direction (width)
|
|
// of the decal measured in world space, decalBasis[1] represents the
|
|
// v-direction (height) measured in world space.
|
|
// textureVecsTexelsPerWorldUnits[0] represents the u direction of
|
|
// the surface's texture space measured in world space (with the appropriate
|
|
// scale factor folded in), and textureVecsTexelsPerWorldUnits[1]
|
|
// represents the texture space v direction. We want to find the dimensions (w,h)
|
|
// of a square measured in texture space, axis aligned to that coordinate system.
|
|
// All we need to do is to find the components of the decal edge vectors
|
|
// (decalWidth * decalBasis[0], decalHeight * decalBasis[1])
|
|
// in texture coordinates:
|
|
|
|
float w = fabs( decalinfo->m_decalWidth * DotProduct( textureU.AsVector3D(), decalinfo->m_Basis[0] ) ) +
|
|
fabs( decalinfo->m_decalHeight * DotProduct( textureU.AsVector3D(), decalinfo->m_Basis[1] ) );
|
|
|
|
float h = fabs( decalinfo->m_decalWidth * DotProduct( textureV.AsVector3D(), decalinfo->m_Basis[0] ) ) +
|
|
fabs( decalinfo->m_decalHeight * DotProduct( textureV.AsVector3D(), decalinfo->m_Basis[1] ) );
|
|
|
|
// move s,t to upper left corner
|
|
s -= ( w * 0.5 );
|
|
t -= ( h * 0.5 );
|
|
|
|
// Is this rect within the surface? -- tex width & height are unsigned
|
|
if( !bForceForDisplacement )
|
|
{
|
|
if ( s <= -w || t <= -h ||
|
|
s > (MSurf_TextureExtents( surfID )[0]+w) || t > (MSurf_TextureExtents( surfID )[1]+h) )
|
|
{
|
|
return; // nope
|
|
}
|
|
}
|
|
|
|
// stamp it
|
|
R_DecalCreate( decalinfo, surfID, s, t, bForceForDisplacement );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// iterate over all surfaces on a node, looking for surfaces to decal
|
|
//-----------------------------------------------------------------------------
|
|
static void R_DecalNodeSurfaces( mnode_t* node, decalinfo_t *decalinfo )
|
|
{
|
|
// iterate over all surfaces in the node
|
|
SurfaceHandle_t surfID = SurfaceHandleFromIndex( node->firstsurface );
|
|
for ( int i=0; i<node->numsurfaces ; ++i, ++surfID)
|
|
{
|
|
if ( MSurf_Flags( surfID ) & SURFDRAW_NODECALS )
|
|
continue;
|
|
|
|
// Displacement surfaces get decals in R_DecalLeaf.
|
|
if ( SurfaceHasDispInfo( surfID ) )
|
|
continue;
|
|
|
|
R_DecalSurface( surfID, decalinfo, false );
|
|
}
|
|
}
|
|
|
|
|
|
void R_DecalLeaf( mleaf_t *pLeaf, decalinfo_t *decalinfo )
|
|
{
|
|
SurfaceHandle_t *pHandle = &host_state.worldbrush->marksurfaces[pLeaf->firstmarksurface];
|
|
for ( int i = 0; i < pLeaf->nummarksurfaces; i++ )
|
|
{
|
|
SurfaceHandle_t surfID = pHandle[i];
|
|
|
|
// only process leaf surfaces
|
|
if ( MSurf_Flags( surfID ) & (SURFDRAW_NODE|SURFDRAW_NODECALS) )
|
|
continue;
|
|
|
|
if ( decalinfo->m_aApplySurfs.Find( surfID ) != -1 )
|
|
continue;
|
|
|
|
Assert( !MSurf_DispInfo( surfID ) );
|
|
|
|
float dist = fabs( DotProduct(decalinfo->m_Position, MSurf_Plane( surfID ).normal) - MSurf_Plane( surfID ).dist);
|
|
if ( dist < DECAL_DISTANCE )
|
|
{
|
|
R_DecalSurface( surfID, decalinfo, false );
|
|
}
|
|
}
|
|
|
|
// Add the decal to each displacement in the leaf it touches.
|
|
for ( int i = 0; i < pLeaf->dispCount; i++ )
|
|
{
|
|
IDispInfo *pDispInfo = MLeaf_Disaplcement( pLeaf, i );
|
|
|
|
SurfaceHandle_t surfID = pDispInfo->GetParent();
|
|
|
|
if ( MSurf_Flags( surfID ) & SURFDRAW_NODECALS )
|
|
continue;
|
|
|
|
// Make sure the decal hasn't already been added to it.
|
|
if( pDispInfo->GetTag() )
|
|
continue;
|
|
|
|
pDispInfo->SetTag();
|
|
|
|
// Trivial bbox reject.
|
|
Vector bbMin, bbMax;
|
|
pDispInfo->GetBoundingBox( bbMin, bbMax );
|
|
if( decalinfo->m_Position.x - decalinfo->m_Size < bbMax.x && decalinfo->m_Position.x + decalinfo->m_Size > bbMin.x &&
|
|
decalinfo->m_Position.y - decalinfo->m_Size < bbMax.y && decalinfo->m_Position.y + decalinfo->m_Size > bbMin.y &&
|
|
decalinfo->m_Position.z - decalinfo->m_Size < bbMax.z && decalinfo->m_Position.z + decalinfo->m_Size > bbMin.z )
|
|
{
|
|
R_DecalSurface( pDispInfo->GetParent(), decalinfo, true );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Recursive routine to find surface to apply a decal to. World coordinates of
|
|
// the decal are passed in r_recalpos like the rest of the engine. This should
|
|
// be called through R_DecalShoot()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static void R_DecalNode( mnode_t *node, decalinfo_t* decalinfo )
|
|
{
|
|
cplane_t *splitplane;
|
|
float dist;
|
|
|
|
if (!node )
|
|
return;
|
|
if ( node->contents >= 0 )
|
|
{
|
|
R_DecalLeaf( (mleaf_t *)node, decalinfo );
|
|
return;
|
|
}
|
|
|
|
splitplane = node->plane;
|
|
dist = DotProduct (decalinfo->m_Position, splitplane->normal) - splitplane->dist;
|
|
|
|
// This is arbitrarily set to 10 right now. In an ideal world we'd have the
|
|
// exact surface but we don't so, this tells me which planes are "sort of
|
|
// close" to the gunshot -- the gunshot is actually 4 units in front of the
|
|
// wall (see dlls\weapons.cpp). We also need to check to see if the decal
|
|
// actually intersects the texture space of the surface, as this method tags
|
|
// parallel surfaces in the same node always.
|
|
// JAY: This still tags faces that aren't correct at edges because we don't
|
|
// have a surface normal
|
|
|
|
if (dist > decalinfo->m_Size)
|
|
{
|
|
R_DecalNode (node->children[0], decalinfo);
|
|
}
|
|
else if (dist < -decalinfo->m_Size)
|
|
{
|
|
R_DecalNode (node->children[1], decalinfo);
|
|
}
|
|
else
|
|
{
|
|
if ( dist < DECAL_DISTANCE && dist > -DECAL_DISTANCE )
|
|
R_DecalNodeSurfaces( node, decalinfo );
|
|
|
|
R_DecalNode (node->children[0], decalinfo);
|
|
R_DecalNode (node->children[1], decalinfo);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pList -
|
|
// count -
|
|
// Output : static int
|
|
//-----------------------------------------------------------------------------
|
|
static int DecalListAdd( decallist_t *pList, int count )
|
|
{
|
|
int i;
|
|
Vector tmp;
|
|
decallist_t *pdecal;
|
|
|
|
pdecal = pList + count;
|
|
for ( i = 0; i < count; i++ )
|
|
{
|
|
if ( !Q_strcmp( pdecal->name, pList[i].name ) &&
|
|
pdecal->entityIndex == pList[i].entityIndex )
|
|
{
|
|
VectorSubtract( pdecal->position, pList[i].position, tmp ); // Merge
|
|
if ( VectorLength( tmp ) < 2 ) // UNDONE: Tune this '2' constant
|
|
return count;
|
|
}
|
|
}
|
|
|
|
// This is a new decal
|
|
return count + 1;
|
|
}
|
|
|
|
|
|
typedef int (__cdecl *qsortFunc_t)( const void *, const void * );
|
|
|
|
static int __cdecl DecalDepthCompare( const decallist_t *elem1, const decallist_t *elem2 )
|
|
{
|
|
if ( elem1->depth > elem2->depth )
|
|
return -1;
|
|
if ( elem1->depth < elem2->depth )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called by CSaveRestore::SaveClientState
|
|
// Input : *pList -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int DecalListCreate( decallist_t *pList )
|
|
{
|
|
int total = 0;
|
|
int i, depth;
|
|
|
|
if ( host_state.worldmodel )
|
|
{
|
|
for ( i = 0; i < g_nMaxDecals; i++ )
|
|
{
|
|
decal_t *decal = s_aDecalPool[i];
|
|
|
|
// Decal is in use and is not a custom decal
|
|
if ( !decal || !IS_SURF_VALID( decal->surfID ) || (decal->flags & ( FDECAL_CUSTOM | FDECAL_DONTSAVE ) ) )
|
|
continue;
|
|
|
|
decal_t *pdecals;
|
|
IMaterial *pMaterial;
|
|
|
|
// compute depth
|
|
depth = 0;
|
|
pdecals = MSurf_DecalPointer( decal->surfID );
|
|
while ( pdecals && pdecals != decal )
|
|
{
|
|
depth++;
|
|
pdecals = pdecals->pnext;
|
|
}
|
|
pList[total].depth = depth;
|
|
pList[total].flags = decal->flags;
|
|
|
|
R_DecalUnProject( decal, &pList[total] );
|
|
|
|
pMaterial = decal->material;
|
|
Q_strncpy( pList[total].name, pMaterial->GetName(), sizeof( pList[total].name ) );
|
|
|
|
// Check to see if the decal should be added
|
|
total = DecalListAdd( pList, total );
|
|
}
|
|
}
|
|
|
|
// Sort the decals lowest depth first, so they can be re-applied in order
|
|
qsort( pList, total, sizeof(decallist_t), ( qsortFunc_t )DecalDepthCompare );
|
|
|
|
return total;
|
|
}
|
|
// ---------------------------------------------------------
|
|
|
|
static bool R_DecalUnProject( decal_t *pdecal, decallist_t *entry )
|
|
{
|
|
if ( !pdecal || !IS_SURF_VALID( pdecal->surfID ) )
|
|
return false;
|
|
|
|
VectorCopy( pdecal->position, entry->position );
|
|
entry->entityIndex = pdecal->entityIndex;
|
|
|
|
// Grab surface plane equation
|
|
cplane_t plane = MSurf_Plane( pdecal->surfID );
|
|
|
|
VectorCopy( plane.normal, entry->impactPlaneNormal );
|
|
return true;
|
|
}
|
|
|
|
|
|
// Shoots a decal onto the surface of the BSP. position is the center of the decal in world coords
|
|
static void R_DecalShoot_( IMaterial *pMaterial, int entity, const model_t *model,
|
|
const Vector &position, const Vector *saxis, int flags, const color32 &rgbaColor, const Vector *pNormal, void *userdata = 0 )
|
|
{
|
|
decalinfo_t decalInfo;
|
|
decalInfo.m_flFadeDuration = 0;
|
|
decalInfo.m_flFadeStartTime = 0;
|
|
|
|
VectorCopy( position, decalInfo.m_Position ); // Pass position in global
|
|
|
|
if ( !model || model->type != mod_brush || !pMaterial )
|
|
return;
|
|
|
|
decalInfo.m_pModel = (model_t *)model;
|
|
decalInfo.m_pBrush = model->brush.pShared;
|
|
|
|
// Deal with the s axis if one was passed in
|
|
if (saxis)
|
|
{
|
|
flags |= FDECAL_USESAXIS;
|
|
VectorCopy( *saxis, decalInfo.m_SAxis );
|
|
}
|
|
|
|
// More state used by R_DecalNode()
|
|
decalInfo.m_pMaterial = pMaterial;
|
|
decalInfo.m_pUserData = userdata;
|
|
|
|
decalInfo.m_Flags = flags;
|
|
decalInfo.m_Entity = entity;
|
|
decalInfo.m_Size = pMaterial->GetMappingWidth() >> 1;
|
|
if ( (int)(pMaterial->GetMappingHeight() >> 1) > decalInfo.m_Size )
|
|
decalInfo.m_Size = pMaterial->GetMappingHeight() >> 1;
|
|
|
|
// Compute scale of surface
|
|
// FIXME: cache this?
|
|
IMaterialVar *decalScaleVar;
|
|
bool found;
|
|
decalScaleVar = decalInfo.m_pMaterial->FindVar( "$decalScale", &found, false );
|
|
if( found )
|
|
{
|
|
decalInfo.m_scale = 1.0f / decalScaleVar->GetFloatValue();
|
|
decalInfo.m_Size *= decalScaleVar->GetFloatValue();
|
|
}
|
|
else
|
|
{
|
|
decalInfo.m_scale = 1.0f;
|
|
}
|
|
|
|
// compute the decal dimensions in world space
|
|
decalInfo.m_decalWidth = pMaterial->GetMappingWidth() / decalInfo.m_scale;
|
|
decalInfo.m_decalHeight = pMaterial->GetMappingHeight() / decalInfo.m_scale;
|
|
decalInfo.m_Color = rgbaColor;
|
|
decalInfo.m_pNormal = pNormal;
|
|
decalInfo.m_aApplySurfs.Purge();
|
|
|
|
// Clear the displacement tags because we use them in R_DecalNode.
|
|
DispInfo_ClearAllTags( decalInfo.m_pBrush->hDispInfos );
|
|
|
|
mnode_t *pnodes = decalInfo.m_pBrush->nodes + decalInfo.m_pModel->brush.firstnode;
|
|
R_DecalNode( pnodes, &decalInfo );
|
|
}
|
|
|
|
// Shoots a decal onto the surface of the BSP. position is the center of the decal in world coords
|
|
// This is called from cl_parse.cpp, cl_tent.cpp
|
|
void R_DecalShoot( int textureIndex, int entity, const model_t *model, const Vector &position, const Vector *saxis, int flags, const color32 &rgbaColor, const Vector *pNormal )
|
|
{
|
|
IMaterial* pMaterial = Draw_DecalMaterial( textureIndex );
|
|
R_DecalShoot_( pMaterial, entity, model, position, saxis, flags, rgbaColor, pNormal );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *material -
|
|
// playerIndex -
|
|
// entity -
|
|
// *model -
|
|
// position -
|
|
// *saxis -
|
|
// flags -
|
|
// &rgbaColor -
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void R_PlayerDecalShoot( IMaterial *material, void *userdata, int entity, const model_t *model,
|
|
const Vector& position, const Vector *saxis, int flags, const color32 &rgbaColor )
|
|
{
|
|
// The userdata that is passed in is actually
|
|
// the player number (integer), not sure why it can't be zero.
|
|
Assert( userdata != 0 );
|
|
|
|
//
|
|
// Linear search through decal pool to retire any other decals this
|
|
// player has sprayed. It appears that multiple decals can be
|
|
// allocated for a single spray due to the way they are mapped to
|
|
// surfaces. We need to run through and clean them all up. This
|
|
// seems like the cleanest way to manage this - especially since
|
|
// it doesn't happen that often.
|
|
//
|
|
int i;
|
|
CUtlVector<decal_t *> decalVec;
|
|
|
|
for ( i = 0; i<s_aDecalPool.Count(); i++ )
|
|
{
|
|
decal_t * decal = s_aDecalPool[i];
|
|
|
|
if( decal && (decal->flags & FDECAL_PLAYERSPRAY) && (decal->userdata == userdata) )
|
|
{
|
|
decalVec.AddToTail( decal );
|
|
}
|
|
}
|
|
|
|
// remove all the sprays we found
|
|
for ( i = 0; i < decalVec.Count(); i++ )
|
|
{
|
|
R_DecalUnlink( decalVec[i], host_state.worldbrush );
|
|
}
|
|
|
|
// set this to be a player spray so it is timed out appropriately.
|
|
flags |= FDECAL_PLAYERSPRAY;
|
|
|
|
R_DecalShoot_( material, entity, model, position, saxis, flags, rgbaColor, NULL, userdata );
|
|
}
|
|
|
|
struct decalcontext_t
|
|
{
|
|
Vector vModelOrg;
|
|
Vector sAxis;
|
|
float sOffset;
|
|
Vector tAxis;
|
|
float tOffset;
|
|
float sScale;
|
|
float tScale;
|
|
IMatRenderContext *pRenderContext;
|
|
SurfaceHandle_t pSurf;
|
|
|
|
decalcontext_t( IMatRenderContext *pContext, const Vector &vModelorg )
|
|
{
|
|
pRenderContext = pContext;
|
|
vModelOrg = vModelorg;
|
|
pSurf = NULL;
|
|
|
|
}
|
|
|
|
void InitSurface( SurfaceHandle_t surfID )
|
|
{
|
|
if ( pSurf == surfID )
|
|
return;
|
|
pSurf = surfID;
|
|
mtexinfo_t* pTexInfo = MSurf_TexInfo( surfID );
|
|
|
|
int lightmapPageWidth, lightmapPageHeight;
|
|
materials->GetLightmapPageSize( SortInfoToLightmapPage(MSurf_MaterialSortID( surfID )),&lightmapPageWidth, &lightmapPageHeight );
|
|
|
|
sScale = 1.0f / float(lightmapPageWidth);
|
|
tScale = 1.0f / float(lightmapPageHeight);
|
|
msurfacelighting_t *pSurfacelighting = SurfaceLighting(surfID);
|
|
sOffset = pTexInfo->lightmapVecsLuxelsPerWorldUnits[0][3] - pSurfacelighting->m_LightmapMins[0] +
|
|
pSurfacelighting->m_OffsetIntoLightmapPage[0] + 0.5f;
|
|
tOffset = pTexInfo->lightmapVecsLuxelsPerWorldUnits[1][3] - pSurfacelighting->m_LightmapMins[1] +
|
|
pSurfacelighting->m_OffsetIntoLightmapPage[1] + 0.5f;
|
|
sAxis = pTexInfo->lightmapVecsLuxelsPerWorldUnits[0].AsVector3D();
|
|
tAxis = pTexInfo->lightmapVecsLuxelsPerWorldUnits[1].AsVector3D();
|
|
|
|
}
|
|
inline float ComputeS( const Vector &pos ) const
|
|
{
|
|
return sScale * (DotProduct(pos, sAxis) + sOffset);
|
|
}
|
|
inline float ComputeT( const Vector &pos ) const
|
|
{
|
|
return tScale * (DotProduct(pos, tAxis) + tOffset);
|
|
}
|
|
};
|
|
|
|
// Generate lighting coordinates at each vertex for decal vertices v[] on surface psurf
|
|
static void R_DecalVertsLight( CDecalVert* v, const decalcontext_t &context, SurfaceHandle_t surfID, int vertCount )
|
|
{
|
|
for ( int j = 0; j < vertCount; j++, v++ )
|
|
{
|
|
v->m_cLMCoords.x = context.ComputeS(v->m_vPos);
|
|
v->m_cLMCoords.y = context.ComputeT(v->m_vPos);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check for intersecting decals on this surface
|
|
// Input : *psurf -
|
|
// *pcount -
|
|
// x -
|
|
// y -
|
|
// Output : static decal_t
|
|
//-----------------------------------------------------------------------------
|
|
// UNDONE: This probably doesn't work quite right any more
|
|
// we should base overlap on the new decal basis matrix
|
|
// decal basis is constant per plane, perhaps we should store it (unscaled) in the shared plane struct
|
|
// BRJ: Note, decal basis is not constant when decals need to specify an s direction
|
|
// but that certainly isn't the majority case
|
|
static decal_t *R_DecalFindOverlappingDecals( decalinfo_t* decalinfo, SurfaceHandle_t surfID )
|
|
{
|
|
decal_t *plast = NULL;
|
|
|
|
// (Same as R_SetupDecalClip).
|
|
IMaterial *pMaterial = decalinfo->m_pMaterial;
|
|
|
|
int count = 0;
|
|
|
|
// Precalculate the extents of decalinfo's decal in world space.
|
|
int mapSize[2] = {pMaterial->GetMappingWidth(), pMaterial->GetMappingHeight()};
|
|
Vector decalExtents[2];
|
|
// this is half the width in world space of the decal.
|
|
float minProjectedWidth = (mapSize[0] / decalinfo->m_scale) * 0.5;
|
|
decalExtents[0] = decalinfo->m_Basis[0] * minProjectedWidth;
|
|
decalExtents[1] = decalinfo->m_Basis[1] * (mapSize[1] / decalinfo->m_scale) * 0.5f;
|
|
|
|
float areaThreshold = r_decal_overlap_area.GetFloat();
|
|
float lastArea = 0;
|
|
bool bFullMatch = false;
|
|
decal_t *pDecal = MSurf_DecalPointer( surfID );
|
|
CUtlVectorFixedGrowable<decal_t *,32> coveredList;
|
|
while ( pDecal )
|
|
{
|
|
pMaterial = pDecal->material;
|
|
|
|
// Don't steal bigger decals and replace them with smaller decals
|
|
// Don't steal permanent decals, or player sprays
|
|
if ( !(pDecal->flags & FDECAL_PERMANENT) &&
|
|
!(pDecal->flags & FDECAL_PLAYERSPRAY) && pMaterial )
|
|
{
|
|
Vector testBasis[3];
|
|
float testWorldScale[2];
|
|
R_SetupDecalTextureSpaceBasis( pDecal, MSurf_Plane( surfID ).normal, pMaterial, testBasis, testWorldScale );
|
|
|
|
// Here, we project the min and max extents of the decal that got passed in into
|
|
// this decal's (pDecal's) [0,0,1,1] clip space, just like we would if we were
|
|
// clipping a triangle into pDecal's clip space.
|
|
Vector2D vDecalMin(
|
|
DotProduct( decalinfo->m_Position - decalExtents[0], testBasis[0] ) - pDecal->dx + 0.5f,
|
|
DotProduct( decalinfo->m_Position - decalExtents[1], testBasis[1] ) - pDecal->dy + 0.5f );
|
|
|
|
Vector2D vDecalMax(
|
|
DotProduct( decalinfo->m_Position + decalExtents[0], testBasis[0] ) - pDecal->dx + 0.5f,
|
|
DotProduct( decalinfo->m_Position + decalExtents[1], testBasis[1] ) - pDecal->dy + 0.5f );
|
|
|
|
// Now figure out the part of the projection that intersects pDecal's
|
|
// clip box [0,0,1,1].
|
|
Vector2D vUnionMin( fpmax( vDecalMin.x, 0.0f ), fpmax( vDecalMin.y, 0.0f ) );
|
|
Vector2D vUnionMax( fpmin( vDecalMax.x, 1.0f ), fpmin( vDecalMax.y, 1.0f ) );
|
|
|
|
// if the decal is less than half the width of the one we're applying, don't test for overlap
|
|
// test for complete coverage
|
|
float projectWidthTestedDecal = pDecal->material->GetMappingWidth() / pDecal->scale;
|
|
|
|
float sizex = vUnionMax.x - vUnionMin.x;
|
|
float sizey = vUnionMax.y - vUnionMin.y;
|
|
if( sizex >= 0 && sizey >= 0)
|
|
{
|
|
// Figure out how much of this intersects the (0,0) - (1,1) bbox.
|
|
float flArea = sizex * sizey;
|
|
|
|
if ( projectWidthTestedDecal < minProjectedWidth )
|
|
{
|
|
if ( flArea > 0.999f )
|
|
{
|
|
coveredList.AddToTail(pDecal);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( flArea > areaThreshold )
|
|
{
|
|
// once you pass the threshold, scale the area by the decal size to select the largest
|
|
// decal above the threshold
|
|
float flAreaScaled = flArea * projectWidthTestedDecal;
|
|
count++;
|
|
if ( !plast || flAreaScaled > lastArea )
|
|
{
|
|
plast = pDecal;
|
|
lastArea = flAreaScaled;
|
|
// go ahead and remove even if you're not at the max overlap count yet because this is a very similar decal
|
|
bFullMatch = ( flArea >= 0.9f ) ? true : false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pDecal = pDecal->pnext;
|
|
}
|
|
|
|
if ( plast )
|
|
{
|
|
if ( count < r_decal_overlap_count.GetInt() && !bFullMatch )
|
|
{
|
|
plast = NULL;
|
|
}
|
|
}
|
|
if ( coveredList.Count() > r_decal_cover_count.GetInt() )
|
|
{
|
|
int last = coveredList.Count() - r_decal_cover_count.GetInt();
|
|
for ( int i = 0; i < last; i++ )
|
|
{
|
|
R_DecalUnlink( coveredList[i], host_state.worldbrush );
|
|
}
|
|
}
|
|
|
|
return plast;
|
|
}
|
|
|
|
|
|
// Add the decal to the surface's list of decals.
|
|
// If the surface is a displacement, let the displacement precalculate data for the decal.
|
|
static void R_AddDecalToSurface(
|
|
decal_t *pdecal,
|
|
SurfaceHandle_t surfID,
|
|
decalinfo_t *decalinfo )
|
|
{
|
|
pdecal->pnext = NULL;
|
|
decal_t *pold = MSurf_DecalPointer( surfID );
|
|
if ( pold )
|
|
{
|
|
while ( pold->pnext )
|
|
pold = pold->pnext;
|
|
pold->pnext = pdecal;
|
|
}
|
|
else
|
|
{
|
|
MSurf_Decals( surfID ) = DecalToHandle(pdecal);
|
|
}
|
|
|
|
// Tag surface
|
|
pdecal->surfID = surfID;
|
|
pdecal->flSize = decalinfo->m_Size;
|
|
pdecal->lightmapOffset = ComputeDecalLightmapOffset( surfID );
|
|
// Let the dispinfo reclip the decal if need be.
|
|
if( SurfaceHasDispInfo( surfID ) )
|
|
{
|
|
pdecal->m_DispDecal = MSurf_DispInfo( surfID )->NotifyAddDecal( pdecal, decalinfo->m_Size );
|
|
}
|
|
|
|
// Add surface to list.
|
|
decalinfo->m_aApplySurfs.AddToTail( surfID );
|
|
}
|
|
|
|
//=============================================================================
|
|
//
|
|
// Decal batches for rendering.
|
|
//
|
|
CUtlVector<DecalSortVertexFormat_t> g_aDecalFormats;
|
|
|
|
CUtlVector<DecalSortTrees_t> g_aDecalSortTrees;
|
|
CUtlFixedLinkedList<decal_t*> g_aDecalSortPool;
|
|
int g_nDecalSortCheckCount;
|
|
int g_nBrushModelDecalSortCheckCount;
|
|
|
|
CUtlFixedLinkedList<decal_t*> g_aDispDecalSortPool;
|
|
CUtlVector<DecalSortTrees_t> g_aDispDecalSortTrees;
|
|
int g_nDispDecalSortCheckCount;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void R_DecalSortInit( void )
|
|
{
|
|
g_aDecalFormats.Purge();
|
|
|
|
g_aDecalSortTrees.Purge();
|
|
g_aDecalSortPool.Purge();
|
|
g_aDecalSortPool.EnsureCapacity( g_nMaxDecals );
|
|
g_aDecalSortPool.SetGrowSize( 128 );
|
|
g_nDecalSortCheckCount = 0;
|
|
g_nBrushModelDecalSortCheckCount = 0;
|
|
|
|
g_aDispDecalSortTrees.Purge();
|
|
g_aDispDecalSortPool.Purge();
|
|
g_aDispDecalSortPool.EnsureCapacity( g_nMaxDecals );
|
|
g_aDispDecalSortPool.SetGrowSize( 128 );
|
|
g_nDispDecalSortCheckCount = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void DecalSurfacesInit( bool bBrushModel )
|
|
{
|
|
if ( !bBrushModel )
|
|
{
|
|
// Only clear the pool once per frame.
|
|
g_aDecalSortPool.RemoveAll();
|
|
// Retire decals on opaque brushmodel surfaces
|
|
R_DecalFlushDestroyList();
|
|
++g_nDecalSortCheckCount;
|
|
}
|
|
else
|
|
{
|
|
++g_nBrushModelDecalSortCheckCount;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
static void R_DecalMaterialSort( decal_t *pDecal, SurfaceHandle_t surfID )
|
|
{
|
|
// Setup the decal material sort data.
|
|
DecalMaterialSortData_t sort;
|
|
if ( pDecal->material->InMaterialPage() )
|
|
{
|
|
sort.m_pMaterial = pDecal->material->GetMaterialPage();
|
|
}
|
|
else
|
|
{
|
|
sort.m_pMaterial = pDecal->material;
|
|
}
|
|
sort.m_iLightmapPage = materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID;
|
|
|
|
// Does this vertex type exist?
|
|
VertexFormat_t vertexFormat = GetUncompressedFormat( sort.m_pMaterial );
|
|
int iFormat = 0;
|
|
int nFormatCount = g_aDecalFormats.Count();
|
|
for ( ; iFormat < nFormatCount; ++iFormat )
|
|
{
|
|
if ( g_aDecalFormats[iFormat].m_VertexFormat == vertexFormat )
|
|
break;
|
|
}
|
|
|
|
// A new vertex format type.
|
|
if ( iFormat == nFormatCount )
|
|
{
|
|
iFormat = g_aDecalFormats.AddToTail();
|
|
g_aDecalFormats[iFormat].m_VertexFormat = vertexFormat;
|
|
int iSortTree = g_aDecalSortTrees.AddToTail();
|
|
g_aDispDecalSortTrees.AddToTail();
|
|
g_aDecalFormats[iFormat].m_iSortTree = iSortTree;
|
|
}
|
|
|
|
// Get an index for the current sort tree.
|
|
int iSortTree = g_aDecalFormats[iFormat].m_iSortTree;
|
|
int iTreeType = -1;
|
|
|
|
// Lightmapped.
|
|
if ( sort.m_pMaterial->GetPropertyFlag( MATERIAL_PROPERTY_NEEDS_LIGHTMAP ) )
|
|
{
|
|
// Permanent lightmapped decals.
|
|
if ( pDecal->flags & FDECAL_PERMANENT )
|
|
{
|
|
iTreeType = PERMANENT_LIGHTMAP;
|
|
}
|
|
// Non-permanent lightmapped decals.
|
|
else
|
|
{
|
|
iTreeType = LIGHTMAP;
|
|
}
|
|
}
|
|
// Non-lightmapped decals.
|
|
else
|
|
{
|
|
iTreeType = NONLIGHTMAP;
|
|
sort.m_iLightmapPage = -1;
|
|
}
|
|
|
|
int iSort = g_aDecalSortTrees[iSortTree].m_pTrees[iTreeType]->Find( sort );
|
|
if ( iSort == -1 )
|
|
{
|
|
int iBucket = g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[0][iTreeType].AddToTail();
|
|
g_aDispDecalSortTrees[iSortTree].m_aDecalSortBuckets[0][iTreeType].AddToTail();
|
|
|
|
g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[0][iTreeType].Element( iBucket ).m_nCheckCount = -1;
|
|
g_aDispDecalSortTrees[iSortTree].m_aDecalSortBuckets[0][iTreeType].Element( iBucket ).m_nCheckCount = -1;
|
|
|
|
for ( int iGroup = 1; iGroup < ( MAX_MAT_SORT_GROUPS + 1 ); ++iGroup )
|
|
{
|
|
g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].AddToTail();
|
|
g_aDispDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].AddToTail();
|
|
|
|
g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket ).m_nCheckCount = -1;
|
|
g_aDispDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket ).m_nCheckCount = -1;
|
|
}
|
|
|
|
sort.m_iBucket = iBucket;
|
|
g_aDecalSortTrees[iSortTree].m_pTrees[iTreeType]->Insert( sort );
|
|
g_aDispDecalSortTrees[iSortTree].m_pTrees[iTreeType]->Insert( sort );
|
|
|
|
pDecal->m_iSortTree = iSortTree;
|
|
pDecal->m_iSortMaterial = sort.m_iBucket;
|
|
}
|
|
else
|
|
{
|
|
pDecal->m_iSortTree = iSortTree;
|
|
pDecal->m_iSortMaterial = g_aDecalSortTrees[iSortTree].m_pTrees[iTreeType]->Element( iSort ).m_iBucket;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void R_DecalReSortMaterials( void ) //X
|
|
{
|
|
R_DecalSortInit();
|
|
|
|
int nDecalCount = s_aDecalPool.Count();
|
|
for ( int iDecal = 0; iDecal < nDecalCount; ++iDecal )
|
|
{
|
|
decal_t *pDecal = s_aDecalPool.Element( iDecal );
|
|
if ( pDecal )
|
|
{
|
|
SurfaceHandle_t surfID = pDecal->surfID;
|
|
R_DecalMaterialSort( pDecal, surfID );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Allocate and initialize a decal from the pool, on surface with offsets x, y
|
|
// UNDONE: offsets are not really meaningful in new decal coordinate system
|
|
// the clipping code will recalc the offsets
|
|
static void R_DecalCreate( decalinfo_t* decalinfo, SurfaceHandle_t surfID, float x, float y, bool bForceForDisplacement )
|
|
{
|
|
decal_t *pdecal;
|
|
|
|
if( !IS_SURF_VALID( surfID ) )
|
|
{
|
|
ConMsg( "psurface NULL in R_DecalCreate!\n" );
|
|
return;
|
|
}
|
|
|
|
decal_t *pold = R_DecalFindOverlappingDecals( decalinfo, surfID );
|
|
if ( pold )
|
|
{
|
|
R_DecalUnlink( pold, host_state.worldbrush );
|
|
pold = NULL;
|
|
}
|
|
|
|
pdecal = R_DecalAlloc( decalinfo->m_Flags );
|
|
|
|
pdecal->flags = decalinfo->m_Flags;
|
|
pdecal->color = decalinfo->m_Color;
|
|
VectorCopy( decalinfo->m_Position, pdecal->position );
|
|
if (pdecal->flags & FDECAL_USESAXIS)
|
|
VectorCopy( decalinfo->m_SAxis, pdecal->saxis );
|
|
pdecal->dx = x;
|
|
pdecal->dy = y;
|
|
pdecal->material = decalinfo->m_pMaterial;
|
|
Assert( pdecal->material );
|
|
pdecal->userdata = decalinfo->m_pUserData;
|
|
|
|
// Set scaling
|
|
pdecal->scale = decalinfo->m_scale;
|
|
pdecal->entityIndex = decalinfo->m_Entity;
|
|
|
|
// Get dynamic information from the material (fade start, fade time)
|
|
if ( decalinfo->m_flFadeDuration > 0.0f )
|
|
{
|
|
pdecal->flags |= FDECAL_DYNAMIC;
|
|
pdecal->fadeDuration = decalinfo->m_flFadeDuration;
|
|
pdecal->fadeStartTime = decalinfo->m_flFadeStartTime;
|
|
pdecal->fadeStartTime += cl.GetTime();
|
|
}
|
|
|
|
// check for a player spray
|
|
if( pdecal->flags & FDECAL_PLAYERSPRAY )
|
|
{
|
|
// reset the number of rounds this should be visible for
|
|
pdecal->fadeStartTime = 0.0f;
|
|
|
|
// Force the scale to 1 for player sprays.
|
|
pdecal->scale = 1.0f;
|
|
}
|
|
|
|
if( !bForceForDisplacement )
|
|
{
|
|
// Check to see if the decal actually intersects the surface
|
|
// if not, then remove the decal
|
|
R_DecalVertsClip( NULL, pdecal, surfID, decalinfo->m_pMaterial );
|
|
if ( !pdecal->clippedVertCount )
|
|
{
|
|
R_DecalUnlink( pdecal, host_state.worldbrush );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Add to the surface's list
|
|
R_AddDecalToSurface( pdecal, surfID, decalinfo );
|
|
|
|
// Add decal material/lightmap to sort list.
|
|
R_DecalMaterialSort( pdecal, surfID );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Updates all decals, returns true if the decal should be retired
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool DecalUpdate( decal_t* pDecal )
|
|
{
|
|
// retire the decal if it's time has come
|
|
if (pDecal->fadeDuration > 0)
|
|
{
|
|
return (cl.GetTime() >= pDecal->fadeStartTime + pDecal->fadeDuration);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#define NEXT_MULTIPLE_OF_4(P) ( ((P) + ((4)-1)) & (~((4)-1)) )
|
|
|
|
// Build the vertex list for a decal on a surface and clip it to the surface.
|
|
// This is a template so it can work on world surfaces and dynamic displacement
|
|
// triangles the same way.
|
|
CDecalVert* R_DecalSetupVerts( decalcontext_t &context, decal_t *pDecal, SurfaceHandle_t surfID, IMaterial *pMaterial )
|
|
{
|
|
//
|
|
// Do not scale playersprays
|
|
//
|
|
if( pDecal->flags & FDECAL_DISTANCESCALE )
|
|
{
|
|
if( !(pDecal->flags & FDECAL_PLAYERSPRAY) )
|
|
{
|
|
float scaleFactor = 1.0f;
|
|
float nearScale, farScale, nearDist, farDist;
|
|
|
|
nearScale = r_dscale_nearscale.GetFloat();
|
|
nearDist = r_dscale_neardist.GetFloat();
|
|
farScale = r_dscale_farscale.GetFloat();
|
|
farDist = r_dscale_fardist.GetFloat();
|
|
|
|
Vector playerOrigin = CurrentViewOrigin();
|
|
|
|
float dist = 0;
|
|
|
|
if ( pDecal->entityIndex == 0 )
|
|
{
|
|
dist = (playerOrigin - pDecal->position).Length();
|
|
}
|
|
else
|
|
{
|
|
Vector worldSpaceCenter;
|
|
Vector3DMultiplyPosition(g_BrushToWorldMatrix, pDecal->position, worldSpaceCenter );
|
|
dist = (playerOrigin - worldSpaceCenter).Length();
|
|
}
|
|
float fov = g_EngineRenderer->GetFov();
|
|
|
|
//
|
|
// If the player is zoomed in, we adjust the nearScale and farScale
|
|
//
|
|
if ( fov != r_dscale_basefov.GetFloat() && fov > 0 && r_dscale_basefov.GetFloat() > 0 )
|
|
{
|
|
float fovScale = fov / r_dscale_basefov.GetFloat();
|
|
nearScale *= fovScale;
|
|
farScale *= fovScale;
|
|
|
|
if ( nearScale < 1.0f )
|
|
nearScale = 1.0f;
|
|
if ( farScale < 1.0f )
|
|
farScale = 1.0f;
|
|
}
|
|
|
|
//
|
|
// Scaling works like this:
|
|
//
|
|
// 0->nearDist scale = 1.0
|
|
// nearDist -> farDist scale = LERP(nearScale, farScale)
|
|
// farDist->inf scale = farScale
|
|
//
|
|
// scaling in the rest of the code appears to be more of an
|
|
// attenuation factor rather than a scale, so we compute 1/scale
|
|
// to account for this.
|
|
//
|
|
if ( dist < nearDist )
|
|
scaleFactor = 1.0f;
|
|
else if( dist >= farDist )
|
|
scaleFactor = farScale;
|
|
else
|
|
{
|
|
float percent = (dist - nearDist) / (farDist - nearDist);
|
|
scaleFactor = nearScale + percent * (farScale - nearScale);
|
|
}
|
|
|
|
//
|
|
// scaling in the rest of the code appears to be more of an
|
|
// attenuation factor rather than a scale, so we compute 1/scale
|
|
// to account for this.
|
|
//
|
|
scaleFactor = 1.0f / scaleFactor;
|
|
float originalScale = pDecal->scale;
|
|
float scaledScale = pDecal->scale * scaleFactor;
|
|
pDecal->scale = scaledScale;
|
|
|
|
context.InitSurface( pDecal->surfID );
|
|
|
|
CDecalVert *v = R_DecalVertsClip( NULL, pDecal, surfID, pMaterial );
|
|
if ( v )
|
|
{
|
|
R_DecalVertsLight( v, context, surfID, pDecal->clippedVertCount );
|
|
}
|
|
pDecal->scale = originalScale;
|
|
return v;
|
|
}
|
|
}
|
|
|
|
// find in cache?
|
|
CDecalVert *v = g_DecalVertCache.GetCachedVerts(pDecal);
|
|
if ( !v )
|
|
{
|
|
// not in cache, clip & light
|
|
context.InitSurface( pDecal->surfID );
|
|
v = R_DecalVertsClip( NULL, pDecal, surfID, pMaterial );
|
|
if ( pDecal->clippedVertCount )
|
|
{
|
|
|
|
#if _DEBUG
|
|
// squash vector copy asserts in debug
|
|
int nextVert = NEXT_MULTIPLE_OF_4(pDecal->clippedVertCount);
|
|
if ( (nextVert - pDecal->clippedVertCount) < 4 )
|
|
{
|
|
for ( int i = pDecal->clippedVertCount; i < nextVert; i++ )
|
|
{
|
|
v[i].m_cLMCoords.Init();
|
|
v[i].m_ctCoords.Init();
|
|
v[i].m_vPos.Init();
|
|
}
|
|
}
|
|
#endif
|
|
R_DecalVertsLight( v, context, surfID, pDecal->clippedVertCount );
|
|
g_DecalVertCache.StoreVertsInCache( pDecal, v );
|
|
}
|
|
}
|
|
return v;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Renders a single decal, *could retire the decal!!*
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void DecalUpdateAndDrawSingle( decalcontext_t &context, SurfaceHandle_t surfID, decal_t* pDecal )
|
|
{
|
|
if( !pDecal->material )
|
|
return;
|
|
|
|
// Update dynamic decals
|
|
bool retire = false;
|
|
if ( pDecal->flags & FDECAL_DYNAMIC )
|
|
retire = DecalUpdate( pDecal );
|
|
|
|
if( SurfaceHasDispInfo( surfID ) )
|
|
{
|
|
// Dispinfos generate lists of tris for decals when the decal is first
|
|
// created.
|
|
}
|
|
else
|
|
{
|
|
CDecalVert *v = R_DecalSetupVerts( context, pDecal, surfID, pDecal->material );
|
|
|
|
if ( v )
|
|
Shader_DecalDrawPoly( v, pDecal->material, surfID, pDecal->clippedVertCount, pDecal, 1.0f );
|
|
}
|
|
|
|
if( retire )
|
|
{
|
|
R_DecalUnlink( pDecal, host_state.worldbrush );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Renders all decals on a single surface
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void DrawDecalsOnSingleSurface_NonQueued( IMatRenderContext *pRenderContext, SurfaceHandle_t surfID, const Vector &vModelOrg)
|
|
{
|
|
decal_t* plist = MSurf_DecalPointer( surfID );
|
|
decalcontext_t context(pRenderContext, vModelOrg);
|
|
context.InitSurface(surfID);
|
|
while ( plist )
|
|
{
|
|
// Store off the next pointer, DecalUpdateAndDrawSingle could unlink
|
|
decal_t* pnext = plist->pnext;
|
|
|
|
if (!(plist->flags & FDECAL_SECONDPASS))
|
|
{
|
|
DecalUpdateAndDrawSingle( context, surfID, plist );
|
|
}
|
|
plist = pnext;
|
|
}
|
|
while ( plist )
|
|
{
|
|
// Store off the next pointer, DecalUpdateAndDrawSingle could unlink
|
|
decal_t* pnext = plist->pnext;
|
|
|
|
if ((plist->flags & FDECAL_SECONDPASS))
|
|
{
|
|
DecalUpdateAndDrawSingle( context, surfID, plist );
|
|
}
|
|
plist = pnext;
|
|
}
|
|
}
|
|
|
|
void DrawDecalsOnSingleSurface_QueueHelper( SurfaceHandle_t surfID, Vector vModelOrg )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
DrawDecalsOnSingleSurface_NonQueued( pRenderContext, surfID, vModelOrg );
|
|
}
|
|
|
|
void DrawDecalsOnSingleSurface( IMatRenderContext *pRenderContext, SurfaceHandle_t surfID )
|
|
{
|
|
ICallQueue *pCallQueue;
|
|
if ( r_queued_decals.GetBool() && (pCallQueue = pRenderContext->GetCallQueue()) != NULL )
|
|
{
|
|
//queue available and desired
|
|
pCallQueue->QueueCall( DrawDecalsOnSingleSurface_QueueHelper, surfID, modelorg );
|
|
}
|
|
else
|
|
{
|
|
//non-queued mode
|
|
DrawDecalsOnSingleSurface_NonQueued( pRenderContext, surfID, modelorg );
|
|
}
|
|
}
|
|
|
|
void R_DrawDecalsAllImmediate_GatherDecals( IMatRenderContext *pRenderContext, int iGroup, int iTreeType, CUtlVector<decal_t *> &DrawDecals )
|
|
{
|
|
int nCheckCount = g_nDecalSortCheckCount;
|
|
if ( iGroup == MAX_MAT_SORT_GROUPS )
|
|
{
|
|
// Brush Model
|
|
nCheckCount = g_nBrushModelDecalSortCheckCount;
|
|
}
|
|
|
|
int nSortTreeCount = g_aDecalSortTrees.Count();
|
|
for ( int iSortTree = 0; iSortTree < nSortTreeCount; ++iSortTree )
|
|
{
|
|
int nBucketCount = g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Count();
|
|
for ( int iBucket = 0; iBucket < nBucketCount; ++iBucket )
|
|
{
|
|
if ( g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket ).m_nCheckCount != nCheckCount )
|
|
continue;
|
|
|
|
int iHead = g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket ).m_iHead;
|
|
|
|
int iElement = iHead;
|
|
while ( iElement != g_aDecalSortPool.InvalidIndex() )
|
|
{
|
|
decal_t *pDecal = g_aDecalSortPool.Element( iElement );
|
|
iElement = g_aDecalSortPool.Next( iElement );
|
|
|
|
if ( !pDecal )
|
|
continue;
|
|
|
|
DrawDecals.AddToTail( pDecal );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void R_DrawDecalsAllImmediate_Gathered( IMatRenderContext *pRenderContext, decal_t **ppDecals, int iDecalCount, const Vector &vModelOrg, float flFade )
|
|
{
|
|
SurfaceHandle_t lastSurf = NULL;
|
|
decalcontext_t context( pRenderContext, vModelOrg );
|
|
bool bWireframe = ShouldDrawInWireFrameMode() || (r_drawdecals.GetInt() == 2);
|
|
for( int i = 0; i != iDecalCount; ++i )
|
|
{
|
|
decal_t * pDecal = ppDecals[i];
|
|
|
|
Assert( pDecal != NULL );
|
|
|
|
// Add the decal to the list of decals to be destroyed if need be.
|
|
if ( ( pDecal->flags & FDECAL_DYNAMIC ) && !( pDecal->flags & FDECAL_HASUPDATED ) )
|
|
{
|
|
pDecal->flags |= FDECAL_HASUPDATED;
|
|
if ( DecalUpdate( pDecal ) )
|
|
{
|
|
R_DecalAddToDestroyList( pDecal );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( pDecal->surfID != lastSurf )
|
|
{
|
|
lastSurf = pDecal->surfID;
|
|
}
|
|
CDecalVert *pVerts = R_DecalSetupVerts( context, pDecal, pDecal->surfID, pDecal->material );
|
|
if ( !pVerts )
|
|
continue;
|
|
int nCount = pDecal->clippedVertCount;
|
|
|
|
// Bind texture.
|
|
VertexFormat_t vertexFormat = 0;
|
|
if( bWireframe )
|
|
{
|
|
pRenderContext->Bind( g_materialDecalWireframe );
|
|
}
|
|
else
|
|
{
|
|
pRenderContext->BindLightmapPage( materialSortInfoArray[MSurf_MaterialSortID( pDecal->surfID )].lightmapPageID );
|
|
pRenderContext->Bind( pDecal->material, pDecal->userdata );
|
|
vertexFormat = GetUncompressedFormat( pDecal->material );
|
|
}
|
|
|
|
IMesh *pMesh = NULL;
|
|
pMesh = pRenderContext->GetDynamicMesh();
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nCount, ( ( nCount - 2 ) * 3 ) );
|
|
|
|
// Set base color.
|
|
byte color[4] = { pDecal->color.r, pDecal->color.g, pDecal->color.b, pDecal->color.a };
|
|
if ( flFade != 1.0f )
|
|
{
|
|
color[3] = (byte)( color[3] * flFade );
|
|
}
|
|
|
|
// Dynamic decals - fading.
|
|
if ( pDecal->flags & FDECAL_DYNAMIC )
|
|
{
|
|
float flFadeValue;
|
|
|
|
// Negative fadeDuration value means to fade in
|
|
if ( pDecal->fadeDuration < 0 )
|
|
{
|
|
flFadeValue = -( cl.GetTime() - pDecal->fadeStartTime ) / pDecal->fadeDuration;
|
|
}
|
|
else
|
|
{
|
|
flFadeValue = 1.0 - ( cl.GetTime() - pDecal->fadeStartTime ) / pDecal->fadeDuration;
|
|
}
|
|
|
|
flFadeValue = clamp( flFadeValue, 0.0f, 1.0f );
|
|
|
|
color[3] = ( byte )( color[3] * flFadeValue );
|
|
}
|
|
|
|
// Compute normal and tangent space if necessary.
|
|
Vector vecNormal( 0.0f, 0.0f, 1.0f ), vecTangentS( 1.0f, 0.0f, 0.0f ), vecTangentT( 0.0f, 1.0f, 0.0f );
|
|
if ( vertexFormat & ( VERTEX_NORMAL | VERTEX_TANGENT_SPACE ) )
|
|
{
|
|
vecNormal = MSurf_Plane( pDecal->surfID ).normal;
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
Vector tVect;
|
|
bool bNegate = TangentSpaceSurfaceSetup( pDecal->surfID, tVect );
|
|
TangentSpaceComputeBasis( vecTangentS, vecTangentT, vecNormal, tVect, bNegate );
|
|
}
|
|
}
|
|
|
|
// Setup verts.
|
|
float flOffset = pDecal->lightmapOffset;
|
|
for ( int iVert = 0; iVert < nCount; ++iVert, ++pVerts )
|
|
{
|
|
meshBuilder.Position3fv( pVerts->m_vPos.Base() );
|
|
if ( vertexFormat & VERTEX_NORMAL )
|
|
{
|
|
meshBuilder.Normal3fv( vecNormal.Base() );
|
|
}
|
|
meshBuilder.Color4ubv( color );
|
|
meshBuilder.TexCoord2f( 0, pVerts->m_ctCoords.x, pVerts->m_ctCoords.y );
|
|
meshBuilder.TexCoord2f( 1, pVerts->m_cLMCoords.x, pVerts->m_cLMCoords.y );
|
|
meshBuilder.TexCoord1f( 2, flOffset );
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
meshBuilder.TangentS3fv( vecTangentS.Base() );
|
|
meshBuilder.TangentT3fv( vecTangentT.Base() );
|
|
}
|
|
|
|
meshBuilder.AdvanceVertexF<VTX_HAVEPOS|VTX_HAVENORMAL|VTX_HAVECOLOR,3>();
|
|
}
|
|
|
|
// Setup indices.
|
|
CIndexBuilder &indexBuilder = meshBuilder;
|
|
indexBuilder.FastPolygon( 0, nCount - 2 );
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void R_DrawDecalsAllImmediate( IMatRenderContext *pRenderContext, int iGroup, int iTreeType, const Vector &vModelOrg, int nCheckCount, float flFade )
|
|
{
|
|
SurfaceHandle_t lastSurf = NULL;
|
|
decalcontext_t context(pRenderContext, vModelOrg);
|
|
int nSortTreeCount = g_aDecalSortTrees.Count();
|
|
bool bWireframe = ShouldDrawInWireFrameMode() || (r_drawdecals.GetInt() == 2);
|
|
for ( int iSortTree = 0; iSortTree < nSortTreeCount; ++iSortTree )
|
|
{
|
|
int nBucketCount = g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Count();
|
|
for ( int iBucket = 0; iBucket < nBucketCount; ++iBucket )
|
|
{
|
|
if ( g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket ).m_nCheckCount != nCheckCount )
|
|
continue;
|
|
|
|
int iHead = g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket ).m_iHead;
|
|
|
|
int nCount;
|
|
int iElement = iHead;
|
|
while ( iElement != g_aDecalSortPool.InvalidIndex() )
|
|
{
|
|
decal_t *pDecal = g_aDecalSortPool.Element( iElement );
|
|
iElement = g_aDecalSortPool.Next( iElement );
|
|
|
|
if ( !pDecal )
|
|
continue;
|
|
|
|
// Add the decal to the list of decals to be destroyed if need be.
|
|
if ( ( pDecal->flags & FDECAL_DYNAMIC ) && !( pDecal->flags & FDECAL_HASUPDATED ) )
|
|
{
|
|
pDecal->flags |= FDECAL_HASUPDATED;
|
|
if ( DecalUpdate( pDecal ) )
|
|
{
|
|
R_DecalAddToDestroyList( pDecal );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( pDecal->surfID != lastSurf )
|
|
{
|
|
lastSurf = pDecal->surfID;
|
|
}
|
|
CDecalVert *pVerts = R_DecalSetupVerts( context, pDecal, pDecal->surfID, pDecal->material );
|
|
if ( !pVerts )
|
|
continue;
|
|
nCount = pDecal->clippedVertCount;
|
|
|
|
// Bind texture.
|
|
VertexFormat_t vertexFormat = 0;
|
|
if( bWireframe )
|
|
{
|
|
pRenderContext->Bind( g_materialDecalWireframe );
|
|
}
|
|
else
|
|
{
|
|
pRenderContext->BindLightmapPage( materialSortInfoArray[MSurf_MaterialSortID( pDecal->surfID )].lightmapPageID );
|
|
pRenderContext->Bind( pDecal->material, pDecal->userdata );
|
|
vertexFormat = GetUncompressedFormat( pDecal->material );
|
|
}
|
|
|
|
IMesh *pMesh = NULL;
|
|
pMesh = pRenderContext->GetDynamicMesh();
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nCount, ( ( nCount - 2 ) * 3 ) );
|
|
|
|
// Set base color.
|
|
byte color[4] = { pDecal->color.r, pDecal->color.g, pDecal->color.b, pDecal->color.a };
|
|
if ( flFade != 1.0f )
|
|
{
|
|
color[3] = (byte)( color[3] * flFade );
|
|
}
|
|
|
|
// Dynamic decals - fading.
|
|
if ( pDecal->flags & FDECAL_DYNAMIC )
|
|
{
|
|
float flFadeValue;
|
|
|
|
// Negative fadeDuration value means to fade in
|
|
if ( pDecal->fadeDuration < 0 )
|
|
{
|
|
flFadeValue = -( cl.GetTime() - pDecal->fadeStartTime ) / pDecal->fadeDuration;
|
|
}
|
|
else
|
|
{
|
|
flFadeValue = 1.0 - ( cl.GetTime() - pDecal->fadeStartTime ) / pDecal->fadeDuration;
|
|
}
|
|
|
|
flFadeValue = clamp( flFadeValue, 0.0f, 1.0f );
|
|
|
|
color[3] = ( byte )( color[3] * flFadeValue );
|
|
}
|
|
|
|
// Compute normal and tangent space if necessary.
|
|
Vector vecNormal( 0.0f, 0.0f, 1.0f ), vecTangentS( 1.0f, 0.0f, 0.0f ), vecTangentT( 0.0f, 1.0f, 0.0f );
|
|
if ( vertexFormat & ( VERTEX_NORMAL | VERTEX_TANGENT_SPACE ) )
|
|
{
|
|
vecNormal = MSurf_Plane( pDecal->surfID ).normal;
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
Vector tVect;
|
|
bool bNegate = TangentSpaceSurfaceSetup( pDecal->surfID, tVect );
|
|
TangentSpaceComputeBasis( vecTangentS, vecTangentT, vecNormal, tVect, bNegate );
|
|
}
|
|
}
|
|
|
|
// Setup verts.
|
|
float flOffset = pDecal->lightmapOffset;
|
|
for ( int iVert = 0; iVert < nCount; ++iVert, ++pVerts )
|
|
{
|
|
meshBuilder.Position3fv( pVerts->m_vPos.Base() );
|
|
if ( vertexFormat & VERTEX_NORMAL )
|
|
{
|
|
meshBuilder.Normal3fv( vecNormal.Base() );
|
|
}
|
|
meshBuilder.Color4ubv( color );
|
|
meshBuilder.TexCoord2f( 0, pVerts->m_ctCoords.x, pVerts->m_ctCoords.y );
|
|
meshBuilder.TexCoord2f( 1, pVerts->m_cLMCoords.x, pVerts->m_cLMCoords.y );
|
|
meshBuilder.TexCoord1f( 2, flOffset );
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
meshBuilder.TangentS3fv( vecTangentS.Base() );
|
|
meshBuilder.TangentT3fv( vecTangentT.Base() );
|
|
}
|
|
|
|
meshBuilder.AdvanceVertexF<VTX_HAVEPOS|VTX_HAVENORMAL|VTX_HAVECOLOR,3>();
|
|
}
|
|
|
|
// Setup indices.
|
|
int nTriCount = ( nCount - 2 );
|
|
CIndexBuilder &indexBuilder = meshBuilder;
|
|
indexBuilder.FastPolygon( 0, nTriCount );
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
inline void R_DrawDecalMeshList( DecalMeshList_t &meshList )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
int nBatchCount = meshList.m_aBatches.Count();
|
|
for ( int iBatch = 0; iBatch < nBatchCount; ++iBatch )
|
|
{
|
|
if ( g_pMaterialSystemConfig->nFullbright == 1 )
|
|
{
|
|
pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE );
|
|
}
|
|
else
|
|
{
|
|
pRenderContext->BindLightmapPage( meshList.m_aBatches[iBatch].m_iLightmapPage );
|
|
}
|
|
|
|
pRenderContext->Bind( meshList.m_aBatches[iBatch].m_pMaterial, meshList.m_aBatches[iBatch].m_pProxy );
|
|
meshList.m_pMesh->Draw( meshList.m_aBatches[iBatch].m_iStartIndex, meshList.m_aBatches[iBatch].m_nIndexCount );
|
|
}
|
|
}
|
|
|
|
#define DECALMARKERS_SWITCHSORTTREE ((decal_t *)0x00000000)
|
|
#define DECALMARKERS_SWITCHBUCKET ((decal_t *)0xFFFFFFFF)
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void R_DrawDecalsAll_GatherDecals( IMatRenderContext *pRenderContext, int iGroup, int iTreeType, CUtlVector<decal_t *> &DrawDecals )
|
|
{
|
|
int nCheckCount = g_nDecalSortCheckCount;
|
|
if ( iGroup == MAX_MAT_SORT_GROUPS )
|
|
{
|
|
// Brush Model
|
|
nCheckCount = g_nBrushModelDecalSortCheckCount;
|
|
}
|
|
|
|
int nSortTreeCount = g_aDecalSortTrees.Count();
|
|
for ( int iSortTree = 0; iSortTree < nSortTreeCount; ++iSortTree )
|
|
{
|
|
DrawDecals.AddToTail( DECALMARKERS_SWITCHSORTTREE );
|
|
|
|
DecalSortTrees_t &sortTree = g_aDecalSortTrees[iSortTree];
|
|
int nBucketCount = sortTree.m_aDecalSortBuckets[iGroup][iTreeType].Count();
|
|
for ( int iBucket = 0; iBucket < nBucketCount; ++iBucket )
|
|
{
|
|
DecalMaterialBucket_t &bucket = sortTree.m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket );
|
|
if ( bucket.m_nCheckCount != nCheckCount )
|
|
continue;
|
|
|
|
int iHead = bucket.m_iHead;
|
|
if ( !g_aDecalSortPool.IsValidIndex( iHead ) )
|
|
continue;
|
|
|
|
decal_t *pDecalHead = g_aDecalSortPool.Element( iHead );
|
|
Assert( pDecalHead->material );
|
|
if ( !pDecalHead->material )
|
|
continue;
|
|
|
|
// Vertex format.
|
|
VertexFormat_t vertexFormat = GetUncompressedFormat( pDecalHead->material );
|
|
if ( vertexFormat == 0 )
|
|
continue;
|
|
|
|
DrawDecals.AddToTail( DECALMARKERS_SWITCHBUCKET );
|
|
|
|
int iElement = iHead;
|
|
while ( iElement != g_aDecalSortPool.InvalidIndex() )
|
|
{
|
|
decal_t *pDecal = g_aDecalSortPool.Element( iElement );
|
|
iElement = g_aDecalSortPool.Next( iElement );
|
|
|
|
if ( !pDecal )
|
|
continue;
|
|
|
|
DrawDecals.AddToTail( pDecal );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void R_DecalsGetMaxMesh( IMatRenderContext *pRenderContext, int &nDecalSortMaxVerts, int &nDecalSortMaxIndices )
|
|
{
|
|
nDecalSortMaxVerts = g_nMaxDecals * 5;
|
|
nDecalSortMaxIndices = nDecalSortMaxVerts * 3;
|
|
int nMaxIndices = pRenderContext->GetMaxIndicesToRender();
|
|
nDecalSortMaxIndices = MIN(nDecalSortMaxIndices, nMaxIndices);
|
|
nDecalSortMaxVerts = MIN(nDecalSortMaxVerts, 8192); // just a guess, you should be able to do 8K dynamic verts in any material and this is no big loss on batching
|
|
}
|
|
|
|
void R_DrawDecalsAll_Gathered( IMatRenderContext *pRenderContext, decal_t **ppDecals, int iDecalCount, const Vector &vModelOrg, float flFade )
|
|
{
|
|
DecalMeshList_t meshList;
|
|
CMeshBuilder meshBuilder;
|
|
|
|
int nVertCount = 0;
|
|
int nIndexCount = 0;
|
|
|
|
int nCount;
|
|
|
|
int nDecalSortMaxVerts;
|
|
int nDecalSortMaxIndices;
|
|
R_DecalsGetMaxMesh( pRenderContext, nDecalSortMaxVerts, nDecalSortMaxIndices );
|
|
|
|
bool bMeshInit = true;
|
|
bool bBatchInit = true;
|
|
|
|
DecalBatchList_t *pBatch = NULL;
|
|
VertexFormat_t vertexFormat = 0;
|
|
decal_t *pDecalHead = NULL;
|
|
SurfaceHandle_t lastSurf = NULL;
|
|
decalcontext_t context(pRenderContext, vModelOrg);
|
|
bool bWireframe = ShouldDrawInWireFrameMode() || (r_drawdecals.GetInt() == 2);
|
|
|
|
for( int i = 0; i != iDecalCount; ++i )
|
|
{
|
|
decal_t *pDecal = ppDecals[i];
|
|
if( (pDecal == DECALMARKERS_SWITCHSORTTREE) || (pDecal == DECALMARKERS_SWITCHBUCKET) )
|
|
{
|
|
if ( pBatch )
|
|
{
|
|
pBatch->m_nIndexCount = ( nIndexCount - pBatch->m_iStartIndex );
|
|
}
|
|
|
|
if ( pDecal == DECALMARKERS_SWITCHSORTTREE )
|
|
{
|
|
if ( !bMeshInit )
|
|
{
|
|
meshBuilder.End();
|
|
R_DrawDecalMeshList( meshList );
|
|
bMeshInit = true;
|
|
}
|
|
}
|
|
|
|
bBatchInit = true;
|
|
pBatch = NULL;
|
|
|
|
if ( pDecal == DECALMARKERS_SWITCHBUCKET )
|
|
{
|
|
//find the new head decal
|
|
for( int j = i + 1; j != iDecalCount; ++j )
|
|
{
|
|
pDecalHead = ppDecals[j];
|
|
if( (pDecalHead != DECALMARKERS_SWITCHSORTTREE) && (pDecalHead != DECALMARKERS_SWITCHBUCKET) )
|
|
break;
|
|
}
|
|
|
|
vertexFormat = GetUncompressedFormat( pDecalHead->material );
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Add the decal to the list of decals to be destroyed if need be.
|
|
if ( ( pDecal->flags & FDECAL_DYNAMIC ) && !( pDecal->flags & FDECAL_HASUPDATED ) )
|
|
{
|
|
pDecal->flags |= FDECAL_HASUPDATED;
|
|
if ( DecalUpdate( pDecal ) )
|
|
{
|
|
R_DecalAddToDestroyList( pDecal );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( pDecal->surfID != lastSurf )
|
|
{
|
|
lastSurf = pDecal->surfID;
|
|
}
|
|
CDecalVert *pVerts = R_DecalSetupVerts( context, pDecal, pDecal->surfID, pDecal->material );
|
|
if ( !pVerts )
|
|
continue;
|
|
nCount = pDecal->clippedVertCount;
|
|
|
|
// Overflow - new mesh, batch.
|
|
if ( ( ( nVertCount + nCount ) > nDecalSortMaxVerts ) || ( nIndexCount + ( nCount - 2 ) > nDecalSortMaxIndices ) )
|
|
{
|
|
// Finish this batch.
|
|
if ( pBatch )
|
|
{
|
|
pBatch->m_nIndexCount = ( nIndexCount - pBatch->m_iStartIndex );
|
|
}
|
|
|
|
// End the mesh building phase and render.
|
|
meshBuilder.End();
|
|
R_DrawDecalMeshList( meshList );
|
|
|
|
// Reset.
|
|
bMeshInit = true;
|
|
pBatch = NULL;
|
|
bBatchInit = true;
|
|
}
|
|
|
|
// Create the mesh.
|
|
if ( bMeshInit )
|
|
{
|
|
// Reset the mesh list.
|
|
meshList.m_pMesh = NULL;
|
|
meshList.m_aBatches.RemoveAll();
|
|
|
|
// Create a mesh for this vertex format (vertex format per SortTree).
|
|
if ( bWireframe )
|
|
{
|
|
meshList.m_pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, g_materialDecalWireframe );
|
|
}
|
|
else
|
|
{
|
|
meshList.m_pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, pDecalHead->material );
|
|
}
|
|
meshBuilder.Begin( meshList.m_pMesh, MATERIAL_TRIANGLES, nDecalSortMaxVerts, nDecalSortMaxIndices );
|
|
|
|
nVertCount = 0;
|
|
nIndexCount = 0;
|
|
|
|
bMeshInit = false;
|
|
}
|
|
|
|
// Create the batch.
|
|
if ( bBatchInit )
|
|
{
|
|
// Create a batch for this bucket = material/lightmap pair.
|
|
// Todo: we also could flush it right here and continue.
|
|
if ( meshList.m_aBatches.Size() + 1 > meshList.m_aBatches.NumAllocated() )
|
|
{
|
|
Warning( "R_DrawDecalsAll: overflowing m_aBatches. Reduce %d decals in the scene.\n", nDecalSortMaxVerts * meshList.m_aBatches.NumAllocated() );
|
|
meshBuilder.End();
|
|
R_DrawDecalMeshList( meshList );
|
|
return;
|
|
}
|
|
|
|
int iBatchList = meshList.m_aBatches.AddToTail();
|
|
pBatch = &meshList.m_aBatches[iBatchList];
|
|
pBatch->m_iStartIndex = nIndexCount;
|
|
|
|
if ( bWireframe )
|
|
{
|
|
pBatch->m_pMaterial = g_materialDecalWireframe;
|
|
}
|
|
else
|
|
{
|
|
pBatch->m_pMaterial = pDecalHead->material;
|
|
pBatch->m_pProxy = pDecalHead->userdata;
|
|
pBatch->m_iLightmapPage = materialSortInfoArray[MSurf_MaterialSortID( pDecalHead->surfID )].lightmapPageID;
|
|
}
|
|
|
|
bBatchInit = false;
|
|
}
|
|
Assert ( pBatch );
|
|
|
|
// Set base color.
|
|
byte color[4] = { pDecal->color.r, pDecal->color.g, pDecal->color.b, pDecal->color.a };
|
|
if ( flFade != 1.0f )
|
|
{
|
|
color[3] = (byte)( color[3] * flFade );
|
|
}
|
|
|
|
// Dynamic decals - fading.
|
|
if ( pDecal->flags & FDECAL_DYNAMIC )
|
|
{
|
|
float flFadeValue;
|
|
|
|
// Negative fadeDuration value means to fade in
|
|
if ( pDecal->fadeDuration < 0 )
|
|
{
|
|
flFadeValue = -( cl.GetTime() - pDecal->fadeStartTime ) / pDecal->fadeDuration;
|
|
}
|
|
else
|
|
{
|
|
flFadeValue = 1.0 - ( cl.GetTime() - pDecal->fadeStartTime ) / pDecal->fadeDuration;
|
|
}
|
|
|
|
flFadeValue = clamp( flFadeValue, 0.0f, 1.0f );
|
|
|
|
color[3] = ( byte )( color[3] * flFadeValue );
|
|
}
|
|
|
|
// Compute normal and tangent space if necessary.
|
|
Vector vecNormal( 0.0f, 0.0f, 1.0f ), vecTangentS( 1.0f, 0.0f, 0.0f ), vecTangentT( 0.0f, 1.0f, 0.0f );
|
|
if ( vertexFormat & ( VERTEX_NORMAL | VERTEX_TANGENT_SPACE ) )
|
|
{
|
|
vecNormal = MSurf_Plane( pDecal->surfID ).normal;
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
Vector tVect;
|
|
bool bNegate = TangentSpaceSurfaceSetup( pDecal->surfID, tVect );
|
|
TangentSpaceComputeBasis( vecTangentS, vecTangentT, vecNormal, tVect, bNegate );
|
|
}
|
|
}
|
|
|
|
// Setup verts.
|
|
float flOffset = pDecal->lightmapOffset;
|
|
|
|
for ( int iVert = 0; iVert < nCount; ++iVert, ++pVerts )
|
|
{
|
|
meshBuilder.Position3fv( pVerts->m_vPos.Base() );
|
|
if ( vertexFormat & VERTEX_NORMAL )
|
|
{
|
|
meshBuilder.Normal3fv( vecNormal.Base() );
|
|
}
|
|
meshBuilder.Color4ubv( color );
|
|
meshBuilder.TexCoord2f( 0, pVerts->m_ctCoords.x, pVerts->m_ctCoords.y );
|
|
meshBuilder.TexCoord2f( 1, pVerts->m_cLMCoords.x, pVerts->m_cLMCoords.y );
|
|
meshBuilder.TexCoord1f( 2, flOffset );
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
meshBuilder.TangentS3fv( vecTangentS.Base() );
|
|
meshBuilder.TangentT3fv( vecTangentT.Base() );
|
|
}
|
|
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
|
|
// Setup indices.
|
|
int nTriCount = ( nCount - 2 );
|
|
CIndexBuilder &indexBuilder = meshBuilder;
|
|
indexBuilder.FastPolygon( nVertCount, nTriCount );
|
|
|
|
// Update counters.
|
|
nVertCount += nCount;
|
|
nIndexCount += ( nTriCount * 3 );
|
|
}
|
|
|
|
if ( pBatch )
|
|
{
|
|
pBatch->m_nIndexCount = ( nIndexCount - pBatch->m_iStartIndex );
|
|
}
|
|
|
|
if ( !bMeshInit )
|
|
{
|
|
meshBuilder.End();
|
|
R_DrawDecalMeshList( meshList );
|
|
}
|
|
}
|
|
|
|
|
|
void R_DrawDecalsAll( IMatRenderContext *pRenderContext, int iGroup, int iTreeType, const Vector &vModelOrg, int nCheckCount, float flFade )
|
|
{
|
|
DecalMeshList_t meshList;
|
|
CMeshBuilder meshBuilder;
|
|
SurfaceHandle_t lastSurf = NULL;
|
|
decalcontext_t context(pRenderContext, vModelOrg);
|
|
Vector vecNormal( 0.0f, 0.0f, 1.0f ), vecTangentS( 1.0f, 0.0f, 0.0f ), vecTangentT( 0.0f, 1.0f, 0.0f );
|
|
|
|
int nVertCount = 0;
|
|
int nIndexCount = 0;
|
|
|
|
int nDecalSortMaxVerts;
|
|
int nDecalSortMaxIndices;
|
|
R_DecalsGetMaxMesh( pRenderContext, nDecalSortMaxVerts, nDecalSortMaxIndices );
|
|
|
|
bool bWireframe = ShouldDrawInWireFrameMode() || (r_drawdecals.GetInt() == 2);
|
|
float localClientTime = cl.GetTime();
|
|
|
|
int nSortTreeCount = g_aDecalSortTrees.Count();
|
|
|
|
for ( int iSortTree = 0; iSortTree < nSortTreeCount; ++iSortTree )
|
|
{
|
|
// Reset the mesh list.
|
|
bool bMeshInit = true;
|
|
|
|
DecalSortTrees_t &sortTree = g_aDecalSortTrees[iSortTree];
|
|
int nBucketCount = sortTree.m_aDecalSortBuckets[iGroup][iTreeType].Count();
|
|
for ( int iBucket = 0; iBucket < nBucketCount; ++iBucket )
|
|
{
|
|
DecalMaterialBucket_t &bucket = sortTree.m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket );
|
|
if ( bucket.m_nCheckCount != nCheckCount )
|
|
continue;
|
|
|
|
int iHead = bucket.m_iHead;
|
|
if ( !g_aDecalSortPool.IsValidIndex( iHead ) )
|
|
continue;
|
|
|
|
decal_t *pDecalHead = g_aDecalSortPool.Element( iHead );
|
|
Assert( pDecalHead->material );
|
|
if ( !pDecalHead->material )
|
|
continue;
|
|
|
|
// Vertex format.
|
|
VertexFormat_t vertexFormat = GetUncompressedFormat( pDecalHead->material );
|
|
if ( vertexFormat == 0 )
|
|
continue;
|
|
|
|
// New bucket = new batch.
|
|
DecalBatchList_t *pBatch = NULL;
|
|
bool bBatchInit = true;
|
|
|
|
int nCount;
|
|
int iElement = iHead;
|
|
while ( iElement != g_aDecalSortPool.InvalidIndex() )
|
|
{
|
|
decal_t *pDecal = g_aDecalSortPool.Element( iElement );
|
|
iElement = g_aDecalSortPool.Next( iElement );
|
|
|
|
if ( !pDecal || !pDecal->surfID )
|
|
continue;
|
|
|
|
// Add the decal to the list of decals to be destroyed if need be.
|
|
if ( ( pDecal->flags & FDECAL_DYNAMIC ) && !( pDecal->flags & FDECAL_HASUPDATED ) )
|
|
{
|
|
pDecal->flags |= FDECAL_HASUPDATED;
|
|
if ( DecalUpdate( pDecal ) )
|
|
{
|
|
R_DecalAddToDestroyList( pDecal );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
float flOffset = 0;
|
|
if ( pDecal->surfID != lastSurf )
|
|
{
|
|
lastSurf = pDecal->surfID;
|
|
flOffset = pDecal->lightmapOffset;
|
|
// Compute normal and tangent space if necessary.
|
|
if ( vertexFormat & ( VERTEX_NORMAL | VERTEX_TANGENT_SPACE ) )
|
|
{
|
|
vecNormal = MSurf_Plane( pDecal->surfID ).normal;
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
Vector tVect;
|
|
bool bNegate = TangentSpaceSurfaceSetup( pDecal->surfID, tVect );
|
|
TangentSpaceComputeBasis( vecTangentS, vecTangentT, vecNormal, tVect, bNegate );
|
|
}
|
|
}
|
|
}
|
|
CDecalVert *pVerts = R_DecalSetupVerts( context, pDecal, pDecal->surfID, pDecal->material );
|
|
if ( !pVerts )
|
|
continue;
|
|
nCount = pDecal->clippedVertCount;
|
|
|
|
// Overflow - new mesh, batch.
|
|
if ( ( ( nVertCount + nCount ) > nDecalSortMaxVerts ) || ( nIndexCount + ( nCount - 2 ) > nDecalSortMaxIndices ) )
|
|
{
|
|
// Finish this batch.
|
|
if ( pBatch )
|
|
{
|
|
pBatch->m_nIndexCount = ( nIndexCount - pBatch->m_iStartIndex );
|
|
}
|
|
|
|
// End the mesh building phase and render.
|
|
meshBuilder.End();
|
|
R_DrawDecalMeshList( meshList );
|
|
|
|
// Reset.
|
|
bMeshInit = true;
|
|
pBatch = NULL;
|
|
bBatchInit = true;
|
|
}
|
|
|
|
// Create the mesh.
|
|
if ( bMeshInit )
|
|
{
|
|
// Reset the mesh list.
|
|
meshList.m_pMesh = NULL;
|
|
meshList.m_aBatches.RemoveAll();
|
|
|
|
// Create a mesh for this vertex format (vertex format per SortTree).
|
|
if ( bWireframe )
|
|
{
|
|
meshList.m_pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, g_materialDecalWireframe );
|
|
}
|
|
else
|
|
{
|
|
meshList.m_pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, pDecalHead->material );
|
|
}
|
|
meshBuilder.Begin( meshList.m_pMesh, MATERIAL_TRIANGLES, nDecalSortMaxVerts, nDecalSortMaxIndices );
|
|
|
|
nVertCount = 0;
|
|
nIndexCount = 0;
|
|
|
|
bMeshInit = false;
|
|
}
|
|
// Create the batch.
|
|
if ( bBatchInit )
|
|
{
|
|
// Create a batch for this bucket = material/lightmap pair.
|
|
// Todo: we also could flush it right here and continue.
|
|
if ( meshList.m_aBatches.Size() + 1 > meshList.m_aBatches.NumAllocated() )
|
|
{
|
|
Warning( "R_DrawDecalsAll: overflowing m_aBatches. Reduce %d decals in the scene.\n", nDecalSortMaxVerts * meshList.m_aBatches.NumAllocated() );
|
|
meshBuilder.End();
|
|
R_DrawDecalMeshList( meshList );
|
|
return;
|
|
}
|
|
|
|
int iBatchList = meshList.m_aBatches.AddToTail();
|
|
pBatch = &meshList.m_aBatches[iBatchList];
|
|
pBatch->m_iStartIndex = nIndexCount;
|
|
|
|
if ( bWireframe )
|
|
{
|
|
pBatch->m_pMaterial = g_materialDecalWireframe;
|
|
}
|
|
else
|
|
{
|
|
pBatch->m_pMaterial = pDecalHead->material;
|
|
pBatch->m_pProxy = pDecalHead->userdata;
|
|
pBatch->m_iLightmapPage = materialSortInfoArray[MSurf_MaterialSortID( pDecalHead->surfID )].lightmapPageID;
|
|
}
|
|
|
|
bBatchInit = false;
|
|
}
|
|
Assert ( pBatch );
|
|
|
|
// Set base color.
|
|
byte color[4] = { pDecal->color.r, pDecal->color.g, pDecal->color.b, pDecal->color.a };
|
|
if ( flFade != 1.0f )
|
|
{
|
|
color[3] = (byte)( color[3] * flFade );
|
|
}
|
|
|
|
// Dynamic decals - fading.
|
|
if ( pDecal->flags & FDECAL_DYNAMIC )
|
|
{
|
|
float flFadeValue;
|
|
|
|
// Negative fadeDuration value means to fade in
|
|
if ( pDecal->fadeDuration < 0 )
|
|
{
|
|
flFadeValue = -( localClientTime - pDecal->fadeStartTime ) / pDecal->fadeDuration;
|
|
}
|
|
else
|
|
{
|
|
flFadeValue = 1.0 - ( localClientTime - pDecal->fadeStartTime ) / pDecal->fadeDuration;
|
|
}
|
|
|
|
flFadeValue = clamp( flFadeValue, 0.0f, 1.0f );
|
|
|
|
color[3] = ( byte )( color[3] * flFadeValue );
|
|
}
|
|
|
|
// Setup verts.
|
|
for ( int iVert = 0; iVert < nCount; ++iVert, ++pVerts )
|
|
{
|
|
meshBuilder.Position3fv( pVerts->m_vPos.Base() );
|
|
if ( vertexFormat & VERTEX_NORMAL )
|
|
{
|
|
meshBuilder.Normal3fv( vecNormal.Base() );
|
|
}
|
|
meshBuilder.Color4ubv( color );
|
|
meshBuilder.TexCoord2f( 0, pVerts->m_ctCoords.x, pVerts->m_ctCoords.y );
|
|
meshBuilder.TexCoord2f( 1, pVerts->m_cLMCoords.x, pVerts->m_cLMCoords.y );
|
|
meshBuilder.TexCoord1f( 2, flOffset );
|
|
if ( vertexFormat & VERTEX_TANGENT_SPACE )
|
|
{
|
|
meshBuilder.TangentS3fv( vecTangentS.Base() );
|
|
meshBuilder.TangentT3fv( vecTangentT.Base() );
|
|
}
|
|
|
|
meshBuilder.AdvanceVertexF<VTX_HAVEALL, 3>();
|
|
}
|
|
|
|
// Setup indices.
|
|
int nTriCount = nCount - 2;
|
|
CIndexBuilder &indexBuilder = meshBuilder;
|
|
indexBuilder.FastPolygon( nVertCount, nTriCount );
|
|
|
|
// Update counters.
|
|
nVertCount += nCount;
|
|
nIndexCount += ( nTriCount * 3 );
|
|
}
|
|
|
|
if ( pBatch )
|
|
{
|
|
pBatch->m_nIndexCount = ( nIndexCount - pBatch->m_iStartIndex );
|
|
}
|
|
}
|
|
|
|
if ( !bMeshInit )
|
|
{
|
|
meshBuilder.End();
|
|
R_DrawDecalMeshList( meshList );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void DecalSurfaceDraw_NonQueued( IMatRenderContext *pRenderContext, int renderGroup, const Vector &vModelOrg, int nCheckCount, float flFade )
|
|
{
|
|
if ( r_drawbatchdecals.GetBool() )
|
|
{
|
|
// Draw world decals.
|
|
R_DrawDecalsAll( pRenderContext, renderGroup, PERMANENT_LIGHTMAP, vModelOrg, nCheckCount, flFade );
|
|
|
|
// Draw lightmapped non-world decals.
|
|
R_DrawDecalsAll( pRenderContext, renderGroup, LIGHTMAP, vModelOrg, nCheckCount, flFade );
|
|
|
|
// Draw non-lit(mod2x) decals.
|
|
R_DrawDecalsAll( pRenderContext, renderGroup, NONLIGHTMAP, vModelOrg, nCheckCount, flFade );
|
|
}
|
|
else
|
|
{
|
|
// Draw world decals.
|
|
R_DrawDecalsAllImmediate( pRenderContext, renderGroup, PERMANENT_LIGHTMAP, vModelOrg, nCheckCount, flFade );
|
|
|
|
// Draw lightmapped non-world decals.
|
|
R_DrawDecalsAllImmediate( pRenderContext, renderGroup, LIGHTMAP, vModelOrg, nCheckCount, flFade );
|
|
|
|
// Draw non-lit(mod2x) decals.
|
|
R_DrawDecalsAllImmediate( pRenderContext, renderGroup, NONLIGHTMAP, vModelOrg, nCheckCount, flFade );
|
|
}
|
|
}
|
|
|
|
void DecalSurfaceDraw_QueueHelper( bool bBatched, int renderGroup, Vector vModelOrg, int nCheckCount, decal_t **ppDecals, int iPermanentLightmap, int iLightmap, int iNonLightmap, float flFade )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
if( bBatched )
|
|
{
|
|
R_DrawDecalsAll_Gathered( pRenderContext, ppDecals, iPermanentLightmap, vModelOrg, flFade );
|
|
ppDecals += iPermanentLightmap;
|
|
R_DrawDecalsAll_Gathered( pRenderContext, ppDecals, iLightmap, vModelOrg, flFade );
|
|
ppDecals += iLightmap;
|
|
R_DrawDecalsAll_Gathered( pRenderContext, ppDecals, iNonLightmap, vModelOrg, flFade );
|
|
}
|
|
else
|
|
{
|
|
R_DrawDecalsAllImmediate_Gathered( pRenderContext, ppDecals, iPermanentLightmap, vModelOrg, flFade );
|
|
ppDecals += iPermanentLightmap;
|
|
R_DrawDecalsAllImmediate_Gathered( pRenderContext, ppDecals, iLightmap, vModelOrg, flFade );
|
|
ppDecals += iLightmap;
|
|
R_DrawDecalsAllImmediate_Gathered( pRenderContext, ppDecals, iNonLightmap, vModelOrg, flFade );
|
|
}
|
|
}
|
|
|
|
void DecalSurfaceDraw( IMatRenderContext *pRenderContext, int renderGroup, float flFade )
|
|
{
|
|
// VPROF_BUDGET( "Decals", "Decals" );
|
|
VPROF( "DecalsDraw" );
|
|
|
|
if( !r_drawdecals.GetBool() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
int nCheckCount = g_nDecalSortCheckCount;
|
|
if ( renderGroup == MAX_MAT_SORT_GROUPS )
|
|
{
|
|
// Brush Model
|
|
nCheckCount = g_nBrushModelDecalSortCheckCount;
|
|
}
|
|
|
|
ICallQueue *pCallQueue;
|
|
if( r_queued_decals.GetBool() && (pCallQueue = pRenderContext->GetCallQueue()) != NULL )
|
|
{
|
|
//queue available and desired
|
|
bool bBatched = r_drawbatchdecals.GetBool();
|
|
static CUtlVector<decal_t *> DrawDecals;
|
|
|
|
int iPermanentLightmap, iLightmap, iNonLightmap;
|
|
if( bBatched )
|
|
{
|
|
R_DrawDecalsAll_GatherDecals( pRenderContext, renderGroup, PERMANENT_LIGHTMAP, DrawDecals );
|
|
iPermanentLightmap = DrawDecals.Count();
|
|
R_DrawDecalsAll_GatherDecals( pRenderContext, renderGroup, LIGHTMAP, DrawDecals );
|
|
iLightmap = DrawDecals.Count() - iPermanentLightmap;
|
|
R_DrawDecalsAll_GatherDecals( pRenderContext, renderGroup, NONLIGHTMAP, DrawDecals );
|
|
iNonLightmap = DrawDecals.Count() - (iPermanentLightmap + iLightmap);
|
|
}
|
|
else
|
|
{
|
|
R_DrawDecalsAllImmediate_GatherDecals( pRenderContext, renderGroup, PERMANENT_LIGHTMAP, DrawDecals );
|
|
iPermanentLightmap = DrawDecals.Count();
|
|
R_DrawDecalsAllImmediate_GatherDecals( pRenderContext, renderGroup, LIGHTMAP, DrawDecals );
|
|
iLightmap = DrawDecals.Count() - iPermanentLightmap;
|
|
R_DrawDecalsAllImmediate_GatherDecals( pRenderContext, renderGroup, NONLIGHTMAP, DrawDecals );
|
|
iNonLightmap = DrawDecals.Count() - (iPermanentLightmap + iLightmap);
|
|
}
|
|
|
|
if( DrawDecals.Count() )
|
|
{
|
|
size_t memSize = DrawDecals.Count() * sizeof( decal_t * );
|
|
CMatRenderData< byte > rd(pRenderContext, memSize);
|
|
memcpy( rd.Base(), DrawDecals.Base(), DrawDecals.Count() * sizeof( decal_t * ) );
|
|
pCallQueue->QueueCall( DecalSurfaceDraw_QueueHelper, bBatched, renderGroup, modelorg, nCheckCount, (decal_t **)rd.Base(), iPermanentLightmap, iLightmap, iNonLightmap, flFade );
|
|
|
|
DrawDecals.RemoveAll();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//non-queued mode
|
|
DecalSurfaceDraw_NonQueued( pRenderContext, renderGroup, modelorg, nCheckCount, flFade );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Add decals to sorted decal list.
|
|
//-----------------------------------------------------------------------------
|
|
void DecalSurfaceAdd( SurfaceHandle_t surfID, int iGroup )
|
|
{
|
|
// Performance analysis.
|
|
// VPROF_BUDGET( "Decals", "Decals" );
|
|
VPROF( "DecalsBatch" );
|
|
|
|
// Go through surfaces decal list and add them to the correct lists.
|
|
decal_t *pDecalList = MSurf_DecalPointer( surfID );
|
|
if ( !pDecalList )
|
|
return;
|
|
|
|
int nCheckCount = g_nDecalSortCheckCount;
|
|
if ( iGroup == MAX_MAT_SORT_GROUPS )
|
|
{
|
|
// Brush Model
|
|
nCheckCount = g_nBrushModelDecalSortCheckCount;
|
|
}
|
|
|
|
int iTreeType = -1;
|
|
decal_t *pNext = NULL;
|
|
for ( decal_t *pDecal = pDecalList; pDecal; pDecal = pNext )
|
|
{
|
|
// Get the next pointer.
|
|
pNext = pDecal->pnext;
|
|
|
|
// Lightmap decals.
|
|
if ( pDecal->material->GetPropertyFlag( MATERIAL_PROPERTY_NEEDS_LIGHTMAP ) )
|
|
{
|
|
// Permanent lightmapped decals.
|
|
if ( pDecal->flags & FDECAL_PERMANENT )
|
|
{
|
|
iTreeType = PERMANENT_LIGHTMAP;
|
|
}
|
|
// Non-permanent lightmapped decals.
|
|
else
|
|
{
|
|
iTreeType = LIGHTMAP;
|
|
}
|
|
}
|
|
// Non-lightmapped decals.
|
|
else
|
|
{
|
|
iTreeType = NONLIGHTMAP;
|
|
}
|
|
|
|
pDecal->flags &= ~FDECAL_HASUPDATED;
|
|
int iPool = g_aDecalSortPool.Alloc( true );
|
|
if ( iPool != g_aDecalSortPool.InvalidIndex() )
|
|
{
|
|
g_aDecalSortPool[iPool] = pDecal;
|
|
|
|
DecalSortTrees_t &sortTree = g_aDecalSortTrees[ pDecal->m_iSortTree ];
|
|
DecalMaterialBucket_t &bucket = sortTree.m_aDecalSortBuckets[iGroup][iTreeType].Element( pDecal->m_iSortMaterial );
|
|
if ( bucket.m_nCheckCount == nCheckCount )
|
|
{
|
|
int iHead = bucket.m_iHead;
|
|
g_aDecalSortPool.LinkBefore( iHead, iPool );
|
|
}
|
|
|
|
bucket.m_iHead = iPool;
|
|
bucket.m_nCheckCount = nCheckCount;
|
|
}
|
|
}
|
|
}
|
|
|
|
#pragma check_stack(off)
|
|
#endif // SWDS
|