diff options
Diffstat (limited to 'engine/r_decal.cpp')
| -rw-r--r-- | engine/r_decal.cpp | 3038 |
1 files changed, 3038 insertions, 0 deletions
diff --git a/engine/r_decal.cpp b/engine/r_decal.cpp new file mode 100644 index 0000000..95f8c8e --- /dev/null +++ b/engine/r_decal.cpp @@ -0,0 +1,3038 @@ +//========= 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 |