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

3039 lines
88 KiB
Raw Normal View History Unescape

1
5 years ago
//========= 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;
arm64 : fix intptr_t size
3 years ago
intp iHead = g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket ).m_iHead;
1
5 years ago
arm64 : fix intptr_t size
3 years ago
intp iElement = iHead;
1
5 years ago
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;
arm64 : fix intptr_t size
3 years ago
intp iHead = g_aDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Element( iBucket ).m_iHead;
1
5 years ago
int nCount;
arm64 : fix intptr_t size
3 years ago
intp iElement = iHead;
1
5 years ago
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;
arm64 : fix intptr_t size
3 years ago
intp iHead = bucket.m_iHead;
1
5 years ago
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 );
arm64 : fix intptr_t size
3 years ago
intp iElement = iHead;
1
5 years ago
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;
arm64 : fix intptr_t size
3 years ago
intp iPool = g_aDecalSortPool.Alloc( true );
1
5 years ago
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 )
{
arm64 : fix intptr_t size
3 years ago
intp iHead = bucket.m_iHead;
1
5 years ago
g_aDecalSortPool.LinkBefore( iHead, iPool );
}
bucket.m_iHead = iPool;
bucket.m_nCheckCount = nCheckCount;
}
}
}
#pragma check_stack(off)
#endif // SWDS