//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ //=====================================================================================// #include "render_pch.h" #include "decal_private.h" #include "disp_defs.h" #include "disp.h" #include "gl_model_private.h" #include "gl_matsysiface.h" #include "gl_cvars.h" #include "gl_rsurf.h" #include "gl_lightmap.h" #include "con_nprint.h" #include "surfinfo.h" #include "Overlay.h" #include "cl_main.h" #include "r_decal.h" #include "materialsystem/materialsystem_config.h" #include "tier0/vprof.h" // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" // ----------------------------------------------------------------------------- // // Shadow decals + fragments // ----------------------------------------------------------------------------- // static CUtlLinkedList< CDispShadowDecal, DispShadowHandle_t, true > s_DispShadowDecals; static CUtlLinkedList< CDispShadowFragment, DispShadowFragmentHandle_t, true > s_DispShadowFragments; static CUtlLinkedList< CDispDecal, DispShadowHandle_t, true > s_DispDecals; static CUtlLinkedList< CDispDecalFragment, DispShadowFragmentHandle_t, true > s_DispDecalFragments; void CDispInfo::GetIntersectingSurfaces( GetIntersectingSurfaces_Struct *pStruct ) { if ( !m_Verts.Count() || !m_nIndices ) return; // Walk through all of our triangles and add them one by one. SurfInfo *pOut = &pStruct->m_pInfos[ pStruct->m_nSetInfos ]; for ( int iVert=0; iVert < m_MeshReader.NumIndices(); iVert += 3 ) { // Is the list going to overflow? if ( pStruct->m_nSetInfos >= pStruct->m_nMaxInfos ) break; Vector const &a = m_MeshReader.Position( m_MeshReader.Index(iVert+0) - m_iVertOffset ); Vector const &b = m_MeshReader.Position( m_MeshReader.Index(iVert+1) - m_iVertOffset ); Vector const &c = m_MeshReader.Position( m_MeshReader.Index(iVert+2) - m_iVertOffset ); // Get the boundaries. Vector vMin; VectorMin( a, b, vMin ); VectorMin( c, vMin, vMin ); Vector vMax; VectorMax( a, b, vMax ); VectorMax( c, vMax, vMax ); // See if it touches the sphere. int iDim; for ( iDim=0; iDim < 3; iDim++ ) { if ( ((*pStruct->m_pCenter)[iDim]+pStruct->m_Radius) < vMin[iDim] || ((*pStruct->m_pCenter)[iDim]-pStruct->m_Radius) > vMax[iDim] ) { break; } } if ( iDim == 3 ) { // Couldn't reject the sphere in the loop above, so add this surface. pOut->m_nVerts = 3; pOut->m_Verts[0] = a; pOut->m_Verts[1] = b; pOut->m_Verts[2] = c; pOut->m_Plane.m_Normal = ( c - a ).Cross( b - a ); VectorNormalize( pOut->m_Plane.m_Normal ); pOut->m_Plane.m_Dist = pOut->m_Plane.m_Normal.Dot( a ); ++pStruct->m_nSetInfos; ++pOut; } } } // ----------------------------------------------------------------------------- // // CDispInfo implementation of IDispInfo. // ----------------------------------------------------------------------------- // void CDispInfo::RenderWireframeInLightmapPage( int pageId ) { #ifndef SWDS // render displacement as wireframe into lightmap pages SurfaceHandle_t surfID = GetParent(); Assert( ( MSurf_MaterialSortID( surfID ) >= 0 ) && ( MSurf_MaterialSortID( surfID ) < g_WorldStaticMeshes.Count() ) ); if( materialSortInfoArray[MSurf_MaterialSortID( surfID ) ].lightmapPageID != pageId ) return; Shader_DrawLightmapPageSurface( surfID, 0.0f, 0.0f, 1.0f ); #endif } void CDispInfo::GetBoundingBox( Vector& bbMin, Vector& bbMax ) { bbMin = m_BBoxMin; bbMax = m_BBoxMax; } void CDispInfo::SetParent( SurfaceHandle_t surfID ) { m_ParentSurfID = surfID; } // returns surfID SurfaceHandle_t CDispInfo::GetParent( void ) { return m_ParentSurfID; } unsigned int CDispInfo::ComputeDynamicLightMask( dlight_t *pLights ) { int lightMask = 0; #ifndef SWDS if( !IS_SURF_VALID( m_ParentSurfID ) ) { Assert( !"CDispInfo::ComputeDynamicLightMask: no parent surface" ); return 0; } for ( int lnum = 0, testBit = 1, mask = r_dlightactive; lnum < MAX_DLIGHTS && mask != 0; lnum++, mask >>= 1, testBit <<= 1 ) { if ( mask & 1 ) { // not lit by this light if ( !(MSurf_DLightBits( m_ParentSurfID ) & testBit ) ) continue; // This light doesn't affect the world if ( pLights[lnum].flags & DLIGHT_NO_WORLD_ILLUMINATION) continue; // This is used to ensure a maximum number of dlights in a frame if ( !R_CanUseVisibleDLight( lnum ) ) continue; lightMask |= testBit; } } #endif return lightMask; } void CDispInfo::AddDynamicLights( dlight_t *pLights, unsigned int mask ) { #ifndef SWDS if( !IS_SURF_VALID( m_ParentSurfID ) ) { Assert( !"CDispInfo::AddDynamicLights: no parent surface" ); return; } for ( int lnum = 0; lnum < MAX_DLIGHTS && mask != 0; lnum++, mask >>= 1 ) { if ( mask & 1 ) { if ( (pLights[lnum].flags & DLIGHT_DISPLACEMENT_MASK) == 0) { if( NumLightMaps() == 1 ) { AddSingleDynamicLight( pLights[lnum] ); } else { AddSingleDynamicLightBumped( pLights[lnum] ); } } else { AddSingleDynamicAlphaLight( pLights[lnum]); } } } #endif } //----------------------------------------------------------------------------- // Allocates fragments... //----------------------------------------------------------------------------- CDispDecalFragment* CDispInfo::AllocateDispDecalFragment( DispDecalHandle_t h, int nVerts ) { DispDecalFragmentHandle_t f = s_DispDecalFragments.Alloc(true); s_DispDecalFragments.LinkBefore( s_DispDecals[h].m_FirstFragment, f ); s_DispDecals[h].m_FirstFragment = f; CDispDecalFragment* pf = &s_DispDecalFragments[f]; // Initialize the vert count: pf->m_nVerts = nVerts; pf->m_pVerts = new CDecalVert[nVerts]; return pf; } //----------------------------------------------------------------------------- // Clears decal fragment lists //----------------------------------------------------------------------------- void CDispInfo::ClearDecalFragments( DispDecalHandle_t h ) { // Iterate over all fragments associated with each shadow decal CDispDecal& decal = s_DispDecals[h]; DispDecalFragmentHandle_t f = decal.m_FirstFragment; DispDecalFragmentHandle_t next; while( f != DISP_DECAL_FRAGMENT_HANDLE_INVALID ) { next = s_DispDecalFragments.Next(f); s_DispDecalFragments.Free(f); // Destructs the decal, freeing the memory. f = next; } // Blat out the list decal.m_FirstFragment = DISP_DECAL_FRAGMENT_HANDLE_INVALID; // Mark is as not computed decal.m_Flags &= ~CDispDecalBase::FRAGMENTS_COMPUTED; // Update the number of triangles in the decal decal.m_nTris = 0; decal.m_nVerts = 0; } void CDispInfo::ClearAllDecalFragments() { // Iterate over all shadow decals on the displacement DispDecalHandle_t h = m_FirstDecal; while( h != DISP_SHADOW_HANDLE_INVALID ) { ClearDecalFragments( h ); h = s_DispDecals.Next(h); } } // ----------------------------------------------------------------------------- // // Add/remove decals // ----------------------------------------------------------------------------- // DispDecalHandle_t CDispInfo::NotifyAddDecal( decal_t *pDecal, float flSize ) { // Create a new decal, link it in DispDecalHandle_t h = s_DispDecals.Alloc( true ); if ( h != s_DispDecals.InvalidIndex() ) { int nDecalCount = 0; int iDecal = m_FirstDecal; int iLastDecal = s_DispDecals.InvalidIndex(); while( iDecal != s_DispDecals.InvalidIndex() ) { iLastDecal = iDecal; iDecal = s_DispDecals.Next( iDecal ); ++nDecalCount; } #ifndef SWDS if ( nDecalCount >= MAX_DISP_DECALS ) { R_DecalUnlink( s_DispDecals[iLastDecal].m_pDecal, host_state.worldbrush ); } #endif s_DispDecals.LinkBefore( m_FirstDecal, h ); m_FirstDecal = h; CDispDecal *pDispDecal = &s_DispDecals[h]; pDispDecal->m_pDecal = pDecal; pDispDecal->m_FirstFragment = DISP_DECAL_FRAGMENT_HANDLE_INVALID; pDispDecal->m_nVerts = 0; pDispDecal->m_nTris = 0; pDispDecal->m_flSize = flSize; // Setup a basis for it. CDecalVert *pOutVerts = NULL; R_SetupDecalClip( pOutVerts, pDispDecal->m_pDecal, MSurf_Plane( m_ParentSurfID ).normal, pDispDecal->m_pDecal->material, pDispDecal->m_TextureSpaceBasis, pDispDecal->m_DecalWorldScale ); // Recurse and precalculate which nodes this thing can touch. SetupDecalNodeIntersect( m_pPowerInfo->m_RootNode, 0, pDispDecal, 0 ); } return h; } void CDispInfo::NotifyRemoveDecal( DispDecalHandle_t h ) { // Any fragments we got we don't need ClearDecalFragments(h); // Reset the head of the list if (m_FirstDecal == h) m_FirstDecal = s_DispDecals.Next(h); // Blow away the decal s_DispDecals.Free( h ); } //----------------------------------------------------------------------------- // Allocates fragments... //----------------------------------------------------------------------------- CDispShadowFragment* CDispInfo::AllocateShadowDecalFragment( DispShadowHandle_t h, int nCount ) { DispShadowFragmentHandle_t f = s_DispShadowFragments.Alloc(true); s_DispShadowFragments.LinkBefore( s_DispShadowDecals[h].m_FirstFragment, f ); s_DispShadowDecals[h].m_FirstFragment = f; CDispShadowFragment* pf = &s_DispShadowFragments[f]; pf->m_nVerts = nCount; pf->m_ShadowVerts = new ShadowVertex_t[nCount]; return pf; } //----------------------------------------------------------------------------- // Clears shadow decal fragment lists //----------------------------------------------------------------------------- void CDispInfo::ClearShadowDecalFragments( DispShadowHandle_t h ) { // Iterate over all fragments associated with each shadow decal CDispShadowDecal& decal = s_DispShadowDecals[h]; DispShadowFragmentHandle_t f = decal.m_FirstFragment; DispShadowFragmentHandle_t next; while( f != DISP_SHADOW_FRAGMENT_HANDLE_INVALID ) { next = s_DispShadowFragments.Next(f); s_DispShadowFragments.Free(f); f = next; } // Blat out the list decal.m_FirstFragment = DISP_SHADOW_FRAGMENT_HANDLE_INVALID; // Mark is as not computed decal.m_Flags &= ~CDispDecalBase::FRAGMENTS_COMPUTED; // Update the number of triangles in the decal decal.m_nTris = 0; decal.m_nVerts = 0; } void CDispInfo::ClearAllShadowDecalFragments() { // Iterate over all shadow decals on the displacement DispShadowHandle_t h = m_FirstShadowDecal; while( h != DISP_SHADOW_HANDLE_INVALID ) { ClearShadowDecalFragments( h ); h = s_DispShadowDecals.Next(h); } } // ----------------------------------------------------------------------------- // // Add/remove shadow decals // ----------------------------------------------------------------------------- // DispShadowHandle_t CDispInfo::AddShadowDecal( ShadowHandle_t shadowHandle ) { // Create a new shadow decal, link it in DispShadowHandle_t h = s_DispShadowDecals.Alloc( true ); s_DispShadowDecals.LinkBefore( m_FirstShadowDecal, h ); m_FirstShadowDecal = h; CDispShadowDecal* pShadowDecal = &s_DispShadowDecals[h]; pShadowDecal->m_nTris = 0; pShadowDecal->m_nVerts = 0; pShadowDecal->m_Shadow = shadowHandle; pShadowDecal->m_FirstFragment = DISP_SHADOW_FRAGMENT_HANDLE_INVALID; return h; } void CDispInfo::RemoveShadowDecal( DispShadowHandle_t h ) { // Any fragments we got we don't need ClearShadowDecalFragments(h); // Reset the head of the list if (m_FirstShadowDecal == h) m_FirstShadowDecal = s_DispShadowDecals.Next(h); // Blow away the decal s_DispShadowDecals.Free( h ); } // ----------------------------------------------------------------------------- // // This little beastie generate decal fragments // ----------------------------------------------------------------------------- // void CDispInfo::GenerateDecalFragments_R( CVertIndex const &nodeIndex, int iNodeBitIndex, unsigned short decalHandle, CDispDecalBase *pDispDecal, int iLevel ) { // Get the node info for this node... Assert( iNodeBitIndex < m_pPowerInfo->m_NodeCount ); DispNodeInfo_t const& nodeInfo = m_pNodeInfo[iNodeBitIndex]; int iNodeIndex = VertIndex( nodeIndex ); // Don't bother adding decals if the node doesn't have decal info. if( !pDispDecal->m_NodeIntersect.Get( iNodeBitIndex ) ) return; // Recurse into child nodes, but only if they have triangles. if ( ( iLevel+1 < m_Power ) && (nodeInfo.m_Flags & DispNodeInfo_t::CHILDREN_HAVE_TRIANGLES) ) { int iChildNodeBit = iNodeBitIndex + 1; for( int iChild=0; iChild < 4; iChild++ ) { CVertIndex const &childNode = m_pPowerInfo->m_pChildVerts[iNodeIndex].m_Verts[iChild]; bool bActiveChild = m_ActiveVerts.Get( VertIndex( childNode ) ) != 0; if ( bActiveChild ) GenerateDecalFragments_R( childNode, iChildNodeBit, decalHandle, pDispDecal, iLevel + 1 ); iChildNodeBit += m_pPowerInfo->m_NodeIndexIncrements[iLevel]; } } // Create the decal fragments on the node triangles bool isShadow = (pDispDecal->m_Flags & CDispDecalBase::DECAL_SHADOW) != 0; int index = nodeInfo.m_FirstTesselationIndex; for ( int i = 0; i < nodeInfo.m_Count; i += 3 ) { if (isShadow) TestAddDecalTri( index + i, decalHandle, static_cast(pDispDecal) ); else TestAddDecalTri( index + i, decalHandle, static_cast(pDispDecal) ); } } void CDispInfo::GenerateDecalFragments( CVertIndex const &nodeIndex, int iNodeBitIndex, unsigned short decalHandle, CDispDecalBase *pDispDecal ) { GenerateDecalFragments_R( nodeIndex, iNodeBitIndex, decalHandle, pDispDecal, 0 ); pDispDecal->m_Flags |= CDispDecalBase::FRAGMENTS_COMPUTED; } // ----------------------------------------------------------------------------- // // Compute shadow fragments for a particular shadow // ----------------------------------------------------------------------------- // bool CDispInfo::ComputeShadowFragments( DispShadowHandle_t h, int& vertexCount, int& indexCount ) { CDispShadowDecal* pShadowDecal = &s_DispShadowDecals[h]; // If we already have fragments, that means the data's already cached. if ((pShadowDecal->m_Flags & CDispDecalBase::FRAGMENTS_COMPUTED) != 0) { vertexCount = pShadowDecal->m_nVerts; indexCount = 3 * pShadowDecal->m_nTris; return true; } // Check to see if the bitfield wasn't computed. If so, compute it. // This should happen whenever the shadow moves #ifndef SWDS if ((pShadowDecal->m_Flags & CDispDecalBase::NODE_BITFIELD_COMPUTED ) == 0) { // First, determine the nodes that the shadow decal should affect ShadowInfo_t const& info = g_pShadowMgr->GetInfo( pShadowDecal->m_Shadow ); SetupDecalNodeIntersect( m_pPowerInfo->m_RootNode, 0, // node bit index into CDispDecal::m_NodeIntersects pShadowDecal, &info ); } #endif // Check to see if there are any bits set in the bitfield, If not, // this displacement should be taken out of the list of potential displacements if (pShadowDecal->m_Flags & CDispDecalBase::NO_INTERSECTION) return false; // Now that we have the bitfield, compute the fragments // It may happen that we have invalid fragments but valid bitfield. // This can happen when a retesselation occurs Assert( pShadowDecal->m_nTris == 0); Assert( pShadowDecal->m_FirstFragment == DISP_SHADOW_FRAGMENT_HANDLE_INVALID); GenerateDecalFragments( m_pPowerInfo->m_RootNode, 0, h, pShadowDecal ); // Compute the index + vertex counts vertexCount = pShadowDecal->m_nVerts; indexCount = 3 * pShadowDecal->m_nTris; return true; } //----------------------------------------------------------------------------- // Generate vertex lists //----------------------------------------------------------------------------- bool CDispInfo::GetTag() { return m_Tag == m_pDispArray->m_CurTag; } void CDispInfo::SetTag() { m_Tag = m_pDispArray->m_CurTag; } //----------------------------------------------------------------------------- // Helpers for global functions. //----------------------------------------------------------------------------- // This function crashes in release without this pragma. #if !defined( _X360 ) #pragma optimize( "g", off ) #endif #pragma optimize( "", on ) void DispInfo_BuildPrimLists( int nSortGroup, SurfaceHandle_t *pList, int listCount, bool bDepthOnly, CDispInfo *visibleDisps[MAX_MAP_DISPINFO], int &nVisibleDisps ) { VPROF("DispInfo_BuildPrimLists"); nVisibleDisps = 0; bool bDebugConvars = !bDepthOnly ? DispInfoRenderDebugModes() : false; for( int i = 0; i < listCount; i++ ) { CDispInfo *pDisp = static_cast( pList[i]->pDispInfo ); if( !pDisp->Render( pDisp->m_pMesh, bDebugConvars ) ) continue; // Add it to the list of visible displacements. if( nVisibleDisps < MAX_MAP_DISPINFO ) { visibleDisps[nVisibleDisps++] = pDisp; } if ( bDepthOnly ) continue; #ifndef SWDS OverlayMgr()->AddFragmentListToRenderList( nSortGroup, MSurf_OverlayFragmentList( pList[i] ), true ); #endif } } ConVar disp_dynamic( "disp_dynamic", "0" ); void DispInfo_DrawPrimLists( ERenderDepthMode DepthMode ) { #ifndef SWDS VPROF("DispInfo_DrawPrimLists"); int nDispGroupsSize = g_DispGroups.Size(); int nFullbright = g_pMaterialSystemConfig->nFullbright; CMatRenderContextPtr pRenderContext( materials ); for( int iGroup=0; iGroup < nDispGroupsSize; iGroup++ ) { CDispGroup *pGroup = g_DispGroups[iGroup]; if( pGroup->m_nVisible == 0 ) continue; if ( DepthMode != DEPTH_MODE_NORMAL ) { // Select proper override material int nAlphaTest = (int) pGroup->m_pMaterial->IsAlphaTested(); int nNoCull = (int) pGroup->m_pMaterial->IsTwoSided(); IMaterial *pDepthWriteMaterial; if ( DepthMode == DEPTH_MODE_SHADOW ) { pDepthWriteMaterial = g_pMaterialDepthWrite[nAlphaTest][nNoCull]; } else { pDepthWriteMaterial = g_pMaterialSSAODepthWrite[nAlphaTest][nNoCull]; } if ( nAlphaTest == 1 ) { static unsigned int originalTextureVarCache = 0; IMaterialVar *pOriginalTextureVar = pGroup->m_pMaterial->FindVarFast( "$basetexture", &originalTextureVarCache ); static unsigned int originalTextureFrameVarCache = 0; IMaterialVar *pOriginalTextureFrameVar = pGroup->m_pMaterial->FindVarFast( "$frame", &originalTextureFrameVarCache ); static unsigned int originalAlphaRefCache = 0; IMaterialVar *pOriginalAlphaRefVar = pGroup->m_pMaterial->FindVarFast( "$AlphaTestReference", &originalAlphaRefCache ); static unsigned int textureVarCache = 0; IMaterialVar *pTextureVar = pDepthWriteMaterial->FindVarFast( "$basetexture", &textureVarCache ); static unsigned int textureFrameVarCache = 0; IMaterialVar *pTextureFrameVar = pDepthWriteMaterial->FindVarFast( "$frame", &textureFrameVarCache ); static unsigned int alphaRefCache = 0; IMaterialVar *pAlphaRefVar = pDepthWriteMaterial->FindVarFast( "$AlphaTestReference", &alphaRefCache ); if( pTextureVar && pOriginalTextureVar ) { pTextureVar->SetTextureValue( pOriginalTextureVar->GetTextureValue() ); } if( pTextureFrameVar && pOriginalTextureFrameVar ) { pTextureFrameVar->SetIntValue( pOriginalTextureFrameVar->GetIntValue() ); } if( pAlphaRefVar && pOriginalAlphaRefVar ) { pAlphaRefVar->SetFloatValue( pOriginalAlphaRefVar->GetFloatValue() ); } } pRenderContext->Bind( pDepthWriteMaterial ); } else { pRenderContext->Bind( pGroup->m_pMaterial ); } if( nFullbright != 1 && DepthMode == DEPTH_MODE_NORMAL ) { pRenderContext->BindLightmapPage( pGroup->m_LightmapPageID ); } else { // If this code gets removed again, I'm chopping fingers off! if( pGroup->m_pMaterial->GetPropertyFlag( MATERIAL_PROPERTY_NEEDS_BUMPED_LIGHTMAPS ) ) { pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP ); } else { pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE ); } } int nMeshesSize = pGroup->m_Meshes.Size(); for( int iMesh=0; iMesh < nMeshesSize; iMesh++ ) { CGroupMesh *pMesh = pGroup->m_Meshes[iMesh]; if( pMesh->m_nVisible == 0 ) continue; if ( disp_dynamic.GetInt() ) { for ( int iVisible=0; iVisible < pMesh->m_nVisible; iVisible++ ) { pMesh->m_VisibleDisps[iVisible]->SpecifyDynamicMesh(); } } else { pMesh->m_pMesh->Draw( pMesh->m_Visible.Base(), pMesh->m_nVisible ); } pMesh->m_nVisible = 0; } } #endif } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void DecalDispSurfacesInit( void ) { #ifndef SWDS g_aDispDecalSortPool.RemoveAll(); ++g_nDispDecalSortCheckCount; #endif } //----------------------------------------------------------------------------- // Purpose: Batch up visible displacement decals and build them if necessary. //----------------------------------------------------------------------------- void DispInfo_BatchDecals( CDispInfo **pVisibleDisps, int nVisibleDisps ) { #ifndef SWDS // Performance analysis. VPROF( "DispInfo_BatchDecals" ); // Increment the decal sort check count and clear the pool. DecalDispSurfacesInit(); // Do we have any visible displacements? if( !nVisibleDisps ) return; for( int iDisp = 0; iDisp < nVisibleDisps; ++iDisp ) { // Get the current visible displacement and see if it has any decals. CDispInfo *pDisp = pVisibleDisps[iDisp]; if( pDisp->m_FirstDecal == DISP_DECAL_HANDLE_INVALID ) continue; DispDecalHandle_t hDecal = pDisp->m_FirstDecal; while ( hDecal != DISP_DECAL_HANDLE_INVALID ) { CDispDecal &decal = s_DispDecals[hDecal]; // Create the displacement fragment if necessary. if ( ( decal.m_Flags & CDispDecalBase::FRAGMENTS_COMPUTED ) == 0 ) { pDisp->GenerateDecalFragments( pDisp->m_pPowerInfo->m_RootNode, 0, hDecal, &decal ); } // Don't draw if there's no triangles. if ( decal.m_nTris == 0 ) { hDecal = s_DispDecals.Next( hDecal ); continue; } // Get the decal material. IMaterial *pMaterial = decal.m_pDecal->material; if ( !pMaterial ) { DevMsg( "DispInfo_BatchDecals: material is NULL, decal %i.\n", hDecal ); hDecal = s_DispDecals.Next( hDecal ); continue; } // Lightmap decals. int iTreeType = -1; if ( pMaterial->GetPropertyFlag( MATERIAL_PROPERTY_NEEDS_LIGHTMAP ) ) { // Permanent lightmapped decals. if ( decal.m_pDecal->flags & FDECAL_PERMANENT ) { iTreeType = PERMANENT_LIGHTMAP; } // Non-permanent lightmapped decals. else { iTreeType = LIGHTMAP; } } // Non-lightmapped decals. else { iTreeType = NONLIGHTMAP; } // There is only one group at a time. int iGroup = 0; int iPool = g_aDispDecalSortPool.Alloc( true ); g_aDispDecalSortPool[iPool] = decal.m_pDecal; int iSortTree = decal.m_pDecal->m_iSortTree; int iSortMaterial = decal.m_pDecal->m_iSortMaterial; DecalMaterialBucket_t &materialBucket = g_aDispDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType].Element( iSortMaterial ); if ( materialBucket.m_nCheckCount == g_nDispDecalSortCheckCount ) { int iHead = materialBucket.m_iHead; g_aDispDecalSortPool.LinkBefore( iHead, iPool ); } materialBucket.m_iHead = iPool; materialBucket.m_nCheckCount = g_nDispDecalSortCheckCount; hDecal = s_DispDecals.Next( hDecal ); } } #endif } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- inline void DispInfo_DrawDecalMeshList( DecalMeshList_t &meshList ) { CMatRenderContextPtr pRenderContext( materials ); bool bMatFullbright = ( g_pMaterialSystemConfig->nFullbright == 1 ); int nBatchCount = meshList.m_aBatches.Count(); for ( int iBatch = 0; iBatch < nBatchCount; ++iBatch ) { const DecalBatchList_t &batch = meshList.m_aBatches[iBatch]; if ( !bMatFullbright ) { pRenderContext->BindLightmapPage( batch.m_iLightmapPage ); } else { pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE ); } pRenderContext->Bind( batch.m_pMaterial, batch.m_pProxy ); meshList.m_pMesh->Draw( batch.m_iStartIndex, batch.m_nIndexCount ); } } void DispInfo_DrawDecalsGroup( int iGroup, int iTreeType ) { #ifndef SWDS CMatRenderContextPtr pRenderContext( materials ); DecalMeshList_t meshList; CMeshBuilder meshBuilder; int nVertCount = 0; int nIndexCount = 0; int nDecalSortMaxVerts; int nDecalSortMaxIndices; R_DecalsGetMaxMesh( pRenderContext, nDecalSortMaxVerts, nDecalSortMaxIndices ); bool bMatWireframe = ShouldDrawInWireFrameMode(); int nSortTreeCount = g_aDispDecalSortTrees.Count(); for ( int iSortTree = 0; iSortTree < nSortTreeCount; ++iSortTree ) { bool bMeshInit = true; const CUtlVector &materialBucketList = g_aDispDecalSortTrees[iSortTree].m_aDecalSortBuckets[iGroup][iTreeType]; int nBucketCount = materialBucketList.Count(); for ( int iBucket = 0; iBucket < nBucketCount; ++iBucket ) { if ( materialBucketList.Element( iBucket ).m_nCheckCount != g_nDispDecalSortCheckCount ) continue; int iHead = materialBucketList.Element( iBucket ).m_iHead; if ( !g_aDispDecalSortPool.IsValidIndex( iHead ) ) continue; decal_t *pDecalHead = g_aDispDecalSortPool.Element( iHead ); Assert( pDecalHead->material ); if ( !pDecalHead->material ) continue; // Vertex format. VertexFormat_t vertexFormat = pDecalHead->material->GetVertexFormat(); if ( vertexFormat == 0 ) continue; // New bucket = new batch. DecalBatchList_t *pBatch = NULL; bool bBatchInit = true; int nCount; int iElement = iHead; while ( iElement != g_aDispDecalSortPool.InvalidIndex() ) { decal_t *pDecal = g_aDispDecalSortPool.Element( iElement ); iElement = g_aDispDecalSortPool.Next( iElement ); CDispDecal &decal = s_DispDecals[pDecal->m_DispDecal]; // Now draw all the fragments with this material. IMaterial* pMaterial = decal.m_pDecal->material; if ( !pMaterial ) { DevMsg( "DispInfo_DrawDecalsGroup: material is NULL decal %i.\n", pDecal->m_DispDecal ); continue; } DispDecalFragmentHandle_t hFrag = decal.m_FirstFragment; while ( hFrag != DISP_DECAL_FRAGMENT_HANDLE_INVALID ) { CDispDecalFragment &fragment = s_DispDecalFragments[hFrag]; hFrag = s_DispDecalFragments.Next( hFrag ); nCount = fragment.m_nVerts; // 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(); DispInfo_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(); if ( !bMatWireframe ) { meshList.m_pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, pDecalHead->material ); } else { meshList.m_pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, g_materialDecalWireframe ); } 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. int iBatchList = meshList.m_aBatches.AddToTail(); pBatch = &meshList.m_aBatches[iBatchList]; pBatch->m_iStartIndex = nIndexCount; if ( !bMatWireframe ) { pBatch->m_pMaterial = pDecalHead->material; pBatch->m_pProxy = pDecalHead->userdata; pBatch->m_iLightmapPage = materialSortInfoArray[MSurf_MaterialSortID( pDecalHead->surfID )].lightmapPageID; } else { pBatch->m_pMaterial = g_materialDecalWireframe; } bBatchInit = false; } Assert ( pBatch ); // Setup verts. float flOffset = fragment.m_pDecal->lightmapOffset; for ( int iVert = 0; iVert < fragment.m_nVerts; ++iVert ) { const CDecalVert &vert = fragment.m_pVerts[iVert]; meshBuilder.Position3fv( vert.m_vPos.Base() ); // FIXME!! Really want the normal from the displacement, not from the base surface. Vector &normal = MSurf_Plane( fragment.m_pDecal->surfID ).normal; meshBuilder.Normal3fv( normal.Base() ); meshBuilder.Color4ub( fragment.m_pDecal->color.r, fragment.m_pDecal->color.g, fragment.m_pDecal->color.b, fragment.m_pDecal->color.a ); meshBuilder.TexCoord2f( 0, vert.m_ctCoords.x, vert.m_ctCoords.y ); meshBuilder.TexCoord2f( 1, vert.m_cLMCoords.x, vert.m_cLMCoords.y ); meshBuilder.TexCoord1f( 2, flOffset ); 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(); DispInfo_DrawDecalMeshList( meshList ); } } #endif } void DispInfo_DrawDecals( CDispInfo **visibleDisps, int nVisibleDisps ) { #ifndef SWDS VPROF( "DispInfo_DrawDecals" ); int iGroup = 0; // Draw world decals. DispInfo_DrawDecalsGroup( iGroup, PERMANENT_LIGHTMAP ); // Draw lightmapped non-world decals. DispInfo_DrawDecalsGroup( iGroup, LIGHTMAP ); // Draw non-lit(mod2x) decals. DispInfo_DrawDecalsGroup( iGroup, NONLIGHTMAP ); #endif } void DispInfo_DrawDecals_Old( CDispInfo *visibleDisps[MAX_MAP_DISPINFO], int nVisibleDisps ) { #ifndef SWDS // VPROF("DispInfo_DrawDecals"); if( !nVisibleDisps ) return; int nTrisDrawn = 0; CMatRenderContextPtr pRenderContext( materials ); // FIXME: We should bucket all decals (displacement + otherwise) // and sort them by material enum id + lightmap // To do this, we need to associate a sort index from 0-n for all // decals we've seen this level. Then we add those decals to the // appropriate search list, (sorted by lightmap id)? for( int i=0; i < nVisibleDisps; i++ ) { CDispInfo *pDisp = visibleDisps[i]; // Don't bother if there's no decals if( pDisp->m_FirstDecal == DISP_DECAL_HANDLE_INVALID ) continue; pRenderContext->BindLightmapPage( pDisp->m_pMesh->m_pGroup->m_LightmapPageID ); // At the moment, all decals in a single displacement are sorted by material // so we get a little batching at least DispDecalHandle_t d = pDisp->m_FirstDecal; while( d != DISP_DECAL_HANDLE_INVALID ) { CDispDecal& decal = s_DispDecals[d]; // Compute decal fragments if we haven't already.... if ((decal.m_Flags & CDispDecalBase::FRAGMENTS_COMPUTED) == 0) { pDisp->GenerateDecalFragments( pDisp->m_pPowerInfo->m_RootNode, 0, d, &decal ); } // Don't draw if there's no triangles if (decal.m_nTris == 0) { d = s_DispDecals.Next(d); continue; } // Now draw all the fragments with this material. IMaterial* pMaterial = decal.m_pDecal->material; if ( !pMaterial ) { DevMsg("DrawDecals: material is NULL fro decal %i.\n", d ); d = s_DispDecals.Next(d); continue; } IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial ); float matOffset[2], matScale[2]; pMaterial->GetMaterialOffset( matOffset ); pMaterial->GetMaterialScale( matScale ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, decal.m_nVerts, decal.m_nTris * 3 ); int baseIndex = 0; DispDecalFragmentHandle_t f = decal.m_FirstFragment; while (f != DISP_DECAL_FRAGMENT_HANDLE_INVALID) { CDispDecalFragment& fragment = s_DispDecalFragments[f]; int v; for ( v = 0; v < fragment.m_nVerts - 2; ++v) { meshBuilder.Position3fv( fragment.m_pVerts[v].m_vPos.Base() ); meshBuilder.Color4ub( 255, 255, 255, 255 ); if ( pMaterial->InMaterialPage() ) { meshBuilder.TexCoordSubRect2f( 0, fragment.m_pVerts[v].m_ctCoords.x, fragment.m_pVerts[v].m_ctCoords.y, matOffset[0], matOffset[1], matScale[0], matScale[1] ); } else { meshBuilder.TexCoord2f( 0, fragment.m_pVerts[v].m_ctCoords.x, fragment.m_pVerts[v].m_ctCoords.y ); } meshBuilder.TexCoord2f( 1, fragment.m_pVerts[v].m_cLMCoords.x, fragment.m_pVerts[v].m_cLMCoords.y ); meshBuilder.AdvanceVertex(); meshBuilder.Index( baseIndex ); meshBuilder.AdvanceIndex(); meshBuilder.Index( v + baseIndex + 1 ); meshBuilder.AdvanceIndex(); meshBuilder.Index( v + baseIndex + 2 ); meshBuilder.AdvanceIndex(); } meshBuilder.Position3fv( fragment.m_pVerts[v].m_vPos.Base() ); meshBuilder.Color4ub( 255, 255, 255, 255 ); if ( pMaterial->InMaterialPage() ) { meshBuilder.TexCoordSubRect2f( 0, fragment.m_pVerts[v].m_ctCoords.x, fragment.m_pVerts[v].m_ctCoords.y, matOffset[0], matOffset[1], matScale[0], matScale[1] ); } else { meshBuilder.TexCoord2f( 0, fragment.m_pVerts[v].m_ctCoords.x, fragment.m_pVerts[v].m_ctCoords.y ); } meshBuilder.TexCoord2f( 1, fragment.m_pVerts[v].m_cLMCoords.x, fragment.m_pVerts[v].m_cLMCoords.y ); meshBuilder.AdvanceVertex(); ++v; meshBuilder.Position3fv( fragment.m_pVerts[v].m_vPos.Base() ); meshBuilder.Color4ub( 255, 255, 255, 255 ); if ( pMaterial->InMaterialPage() ) { meshBuilder.TexCoordSubRect2f( 0, fragment.m_pVerts[v].m_ctCoords.x, fragment.m_pVerts[v].m_ctCoords.y, matOffset[0], matOffset[1], matScale[0], matScale[1] ); } else { meshBuilder.TexCoord2f( 0, fragment.m_pVerts[v].m_ctCoords.x, fragment.m_pVerts[v].m_ctCoords.y ); } meshBuilder.TexCoord2f( 1, fragment.m_pVerts[v].m_cLMCoords.x, fragment.m_pVerts[v].m_cLMCoords.y ); meshBuilder.AdvanceVertex(); baseIndex += fragment.m_nVerts; f = s_DispDecalFragments.Next(f); } meshBuilder.End( false, true ); nTrisDrawn += decal.m_nTris * pMaterial->GetNumPasses(); d = s_DispDecals.Next(d); } } #endif } // ----------------------------------------------------------------------------- // // Adds shadow rendering data to a particular mesh builder // ----------------------------------------------------------------------------- // int DispInfo_AddShadowsToMeshBuilder( CMeshBuilder& meshBuilder, DispShadowHandle_t h, int baseIndex ) { #ifdef SWDS return 0; #else ShadowDecalRenderInfo_t info; CDispShadowDecal* pShadowDecal = &s_DispShadowDecals[h]; g_pShadowMgr->ComputeRenderInfo( &info, pShadowDecal->m_Shadow ); // It had better be computed by now... Assert( pShadowDecal->m_Flags & CDispDecalBase::FRAGMENTS_COMPUTED ); #ifdef _DEBUG int triCount = 0; int vertCount = 0; #endif Vector2D texCoord; unsigned char c; DispShadowFragmentHandle_t f = pShadowDecal->m_FirstFragment; while ( f != DISP_SHADOW_FRAGMENT_HANDLE_INVALID ) { const CDispShadowFragment& fragment = s_DispShadowFragments[f]; const ShadowVertex_t *pShadowVert = fragment.m_ShadowVerts; // Add in the vertices + indices, use two loops to minimize tests... int i; for ( i = 0; i < fragment.m_nVerts - 2; ++i, ++pShadowVert ) { // Transform + offset the texture coords Vector2DMultiply( pShadowVert->m_ShadowSpaceTexCoord.AsVector2D(), info.m_vTexSize, texCoord ); texCoord += info.m_vTexOrigin; c = g_pShadowMgr->ComputeDarkness( pShadowVert->m_ShadowSpaceTexCoord.z, info ); meshBuilder.Position3fv( pShadowVert->m_Position.Base() ); meshBuilder.Color4ub( c, c, c, c ); meshBuilder.TexCoord2fv( 0, texCoord.Base() ); meshBuilder.AdvanceVertex(); meshBuilder.FastIndex( baseIndex ); meshBuilder.FastIndex( i + baseIndex + 1 ); meshBuilder.FastIndex( i + baseIndex + 2 ); } Vector2DMultiply( pShadowVert->m_ShadowSpaceTexCoord.AsVector2D(), info.m_vTexSize, texCoord ); texCoord += info.m_vTexOrigin; c = g_pShadowMgr->ComputeDarkness( pShadowVert->m_ShadowSpaceTexCoord.z, info ); meshBuilder.Position3fv( pShadowVert->m_Position.Base() ); meshBuilder.Color4ub( c, c, c, c ); meshBuilder.TexCoord2fv( 0, texCoord.Base() ); meshBuilder.AdvanceVertex(); ++pShadowVert; Vector2DMultiply( pShadowVert->m_ShadowSpaceTexCoord.AsVector2D(), info.m_vTexSize, texCoord ); texCoord += info.m_vTexOrigin; c = g_pShadowMgr->ComputeDarkness( pShadowVert->m_ShadowSpaceTexCoord.z, info ); meshBuilder.Position3fv( pShadowVert->m_Position.Base() ); meshBuilder.Color4ub( c, c, c, c ); meshBuilder.TexCoord2fv( 0, texCoord.Base() ); meshBuilder.AdvanceVertex(); baseIndex += fragment.m_nVerts; f = s_DispShadowFragments.Next(f); #ifdef _DEBUG triCount += fragment.m_nVerts - 2; vertCount += fragment.m_nVerts; #endif } #ifdef _DEBUG Assert( triCount == pShadowDecal->m_nTris ); Assert( vertCount == pShadowDecal->m_nVerts ); #endif return baseIndex; #endif } // ----------------------------------------------------------------------------- // // IDispInfo globals implementation. // ----------------------------------------------------------------------------- // void DispInfo_InitMaterialSystem() { } void DispInfo_ShutdownMaterialSystem() { } HDISPINFOARRAY DispInfo_CreateArray( int nElements ) { CDispArray *pRet = new CDispArray; pRet->m_CurTag = 1; pRet->m_nDispInfos = nElements; if ( nElements ) { pRet->m_pDispInfos = new CDispInfo[nElements]; } else { pRet->m_pDispInfos = NULL; } for( int i=0; i < nElements; i++ ) pRet->m_pDispInfos[i].m_pDispArray = pRet; return (HDISPINFOARRAY)pRet; } void DispInfo_DeleteArray( HDISPINFOARRAY hArray ) { CDispArray *pArray = static_cast( hArray ); if( !pArray ) return; delete [] pArray->m_pDispInfos; delete pArray; } IDispInfo* DispInfo_IndexArray( HDISPINFOARRAY hArray, int iElement ) { CDispArray *pArray = static_cast( hArray ); if( !pArray ) return NULL; Assert( iElement >= 0 && iElement < pArray->m_nDispInfos ); return &pArray->m_pDispInfos[iElement]; } int DispInfo_ComputeIndex( HDISPINFOARRAY hArray, IDispInfo* pInfo ) { CDispArray *pArray = static_cast( hArray ); if( !pArray ) return NULL; int iElement = ((int)pInfo - (int)(pArray->m_pDispInfos)) / sizeof(CDispInfo); Assert( iElement >= 0 && iElement < pArray->m_nDispInfos ); return iElement; } void DispInfo_ClearAllTags( HDISPINFOARRAY hArray ) { CDispArray *pArray = static_cast( hArray ); if( !pArray ) return; ++pArray->m_CurTag; if( pArray->m_CurTag == 0xFFFF ) { // Reset all the tags. pArray->m_CurTag = 1; for( int i=0; i < pArray->m_nDispInfos; i++ ) pArray->m_pDispInfos[i].m_Tag = 0; } } //----------------------------------------------------------------------------- // Renders normals for the displacements //----------------------------------------------------------------------------- static void DispInfo_DrawChainNormals( SurfaceHandle_t *pList, int listCount ) { #ifndef SWDS #ifdef _DEBUG CMatRenderContextPtr pRenderContext( materials ); // Only do it in debug because we're only storing the info then Vector p; pRenderContext->Bind( g_pMaterialWireframeVertexColor ); for ( int i = 0; i < listCount; i++ ) { CDispInfo *pDisp = static_cast( pList[i]->pDispInfo ); int nVerts = pDisp->NumVerts(); IMesh *pMesh = pRenderContext->GetDynamicMesh( ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_LINES, nVerts * 3 ); for( int iVert=0; iVert < nVerts; iVert++ ) { CDispRenderVert* pVert = pDisp->GetVertex(iVert); meshBuilder.Position3fv( pVert->m_vPos.Base() ); meshBuilder.Color3ub( 255, 0, 0 ); meshBuilder.AdvanceVertex(); VectorMA( pVert->m_vPos, 5.0f, pVert->m_vNormal, p ); meshBuilder.Position3fv( p.Base() ); meshBuilder.Color3ub( 255, 0, 0 ); meshBuilder.AdvanceVertex(); meshBuilder.Position3fv( pVert->m_vPos.Base() ); meshBuilder.Color3ub( 0, 255, 0 ); meshBuilder.AdvanceVertex(); VectorMA( pVert->m_vPos, 5.0f, pVert->m_vSVector, p ); meshBuilder.Position3fv( p.Base() ); meshBuilder.Color3ub( 0, 255, 0 ); meshBuilder.AdvanceVertex(); meshBuilder.Position3fv( pVert->m_vPos.Base() ); meshBuilder.Color3ub( 0, 0, 255 ); meshBuilder.AdvanceVertex(); VectorMA( pVert->m_vPos, 5.0f, pVert->m_vTVector, p ); meshBuilder.Position3fv( p.Base() ); meshBuilder.Color3ub( 0, 0, 255 ); meshBuilder.AdvanceVertex(); } meshBuilder.End(); pMesh->Draw(); } #endif #endif } //----------------------------------------------------------------------------- // Renders debugging information for displacements //----------------------------------------------------------------------------- static void DispInfo_DrawDebugInformation( SurfaceHandle_t *pList, int listCount ) { #ifndef SWDS VPROF("DispInfo_DrawDebugInformation"); // Overlay with normals if we're in that mode if( mat_normals.GetInt() ) { DispInfo_DrawChainNormals(pList, listCount); } #endif } //----------------------------------------------------------------------------- // Renders all displacements in sorted order //----------------------------------------------------------------------------- void DispInfo_RenderList( int nSortGroup, SurfaceHandle_t *pList, int listCount, bool bOrtho, unsigned long flags, ERenderDepthMode DepthMode ) { #ifndef SWDS if( !r_DrawDisp.GetInt() || !listCount ) return; g_bDispOrthoRender = bOrtho; // Build up the CPrimLists for all the displacements. CDispInfo *visibleDisps[MAX_MAP_DISPINFO]; int nVisibleDisps; DispInfo_BuildPrimLists( nSortGroup, pList, listCount, ( DepthMode != DEPTH_MODE_NORMAL ), visibleDisps, nVisibleDisps ); // Draw.. DispInfo_DrawPrimLists( DepthMode ); // Skip the rest if this is a shadow depth map pass if ( ( DepthMode != DEPTH_MODE_NORMAL ) ) return; // Add all displacements to the shadow render list for ( int i = 0; i < listCount; i++ ) { SurfaceHandle_t pCur = pList[i]; ShadowDecalHandle_t decalHandle = MSurf_ShadowDecals( pCur ); if (decalHandle != SHADOW_DECAL_HANDLE_INVALID) { g_pShadowMgr->AddShadowsOnSurfaceToRenderList( decalHandle ); } } bool bFlashlightMask = !( (flags & DRAWWORLDLISTS_DRAW_REFRACTION ) || (flags & DRAWWORLDLISTS_DRAW_REFLECTION )); // Draw flashlight lighting for displacements g_pShadowMgr->RenderFlashlights( bFlashlightMask ); // Draw overlays OverlayMgr()->RenderOverlays( nSortGroup ); // Draw flashlight overlays g_pShadowMgr->DrawFlashlightOverlays( nSortGroup, bFlashlightMask ); OverlayMgr()->ClearRenderLists( nSortGroup ); // Draw decals DispInfo_BatchDecals( visibleDisps, nVisibleDisps ); DispInfo_DrawDecals( visibleDisps, nVisibleDisps ); // Draw flashlight decals g_pShadowMgr->DrawFlashlightDecalsOnDisplacements( nSortGroup, visibleDisps, nVisibleDisps, bFlashlightMask ); // draw shadows g_pShadowMgr->RenderShadows(); g_pShadowMgr->ClearShadowRenderList(); // Debugging rendering.. DispInfo_DrawDebugInformation( pList, listCount ); #endif }