//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: Model loading / unloading interface // // $NoKeywords: $ //=============================================================================// #include "render_pch.h" #include "Overlay.h" #include "bspfile.h" #include "modelloader.h" #include "materialsystem/imesh.h" #include "disp.h" #include "collisionutils.h" #include "tier0/vprof.h" #include "render.h" #include "r_decal.h" #include "fmtstr.h" // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" //----------------------------------------------------------------------------- // Externs //----------------------------------------------------------------------------- int g_OverlayRenderFrameID; //----------------------------------------------------------------------------- // Convars //----------------------------------------------------------------------------- static ConVar r_renderoverlayfragment("r_renderoverlayfragment", "1"); static ConVar r_overlaywireframe( "r_overlaywireframe", "0" ); static ConVar r_overlayfadeenable( "r_overlayfadeenable", "0" ); static ConVar r_overlayfademin( "r_overlayfademin", "1750.0f" ); static ConVar r_overlayfademax( "r_overlayfademax", "2000.0f" ); //----------------------------------------------------------------------------- // Structures used to represent the overlay //----------------------------------------------------------------------------- typedef unsigned short OverlayFragmentList_t; enum { OVERLAY_FRAGMENT_LIST_INVALID = (OverlayFragmentList_t)~0, }; enum { NUM_OVERLAY_TEXCOORDS = 2, }; struct overlayvert_t { Vector pos; Vector normal; Vector2D texCoord[NUM_OVERLAY_TEXCOORDS]; // texcoord 0 = the mapped tex coord from worldcraft // texcoord 1 is used for alpha and maps the whole texture into the whole overlay float lightCoord[2]; float flAlpha; overlayvert_t() { pos.Init(); normal.Init(); texCoord[0].Init(); texCoord[1].Init(); lightCoord[0] = lightCoord[1] = 0.0f; flAlpha = 1.0f; } }; struct moverlayfragment_t { int m_nRenderFrameID; // So we only render a fragment once a frame! SurfaceHandle_t m_SurfId; // Surface Id int m_iOverlay; // Overlay Id OverlayFragmentHandle_t m_hNextRender; unsigned short m_nMaterialSortID; CUtlVector m_aPrimVerts; }; struct moverlay_t { int m_nId; short m_nTexInfo; short m_nRenderOrder; // 0 - MAX_OVERLAY_RENDER_ORDERS OverlayFragmentList_t m_hFirstFragment; CUtlVector m_aFaces; float m_flU[2]; float m_flV[2]; Vector m_vecUVPoints[4]; Vector m_vecOrigin; Vector m_vecBasis[3]; // 0 = u, 1 = v, 2 = normal void *m_pBindProxy; // client renderable for an overlay's material proxy to bind to float m_flFadeDistMinSq; // Distance from the overlay's origin at which we start fading (-1 = use max dist) float m_flFadeDistMaxSq; // Distance from the overlay's origin at which we fade out completely float m_flInvFadeRangeSq; // Precomputed 1.0f / ( m_flFadeDistMaxSq - m_flFadeDistMinSq ) }; // Going away! void Overlay_BuildBasisOrigin( Vector &vecBasisOrigin, SurfaceHandle_t surfID ); void Overlay_BuildBasis( const Vector &vecBasisNormal, Vector &vecBasisU, Vector &vecBasisV, bool bFlip ); void Overlay_OverlayUVToOverlayPlane( const Vector &vecBasisOrigin, const Vector &vecBasisU, const Vector &vecBasisV, const Vector &vecUVPoint, Vector &vecPlanePoint ); void Overlay_WorldToOverlayPlane( const Vector &vecBasisOrigin, const Vector &vecBasisNormal, const Vector &vecWorldPoint, Vector &vecPlanePoint ); void Overlay_OverlayPlaneToWorld( const Vector &vecBasisNormal, SurfaceHandle_t surfID, const Vector &vecPlanePoint, Vector &vecWorldPoint ); void Overlay_DispUVToWorld( CDispInfo *pDisp, CMeshReader *pReader, const Vector2D &vecUV, Vector &vecWorld, moverlayfragment_t &surfaceFrag ); void Overlay_TriTLToBR( CDispInfo *pDisp, Vector &vecWorld, float flU, float flV, int nSnapU, int nSnapV, int nWidth, int nHeight ); void Overlay_TriBLToTR( CDispInfo *pDisp, Vector &vecWorld, float flU, float flV, int nSnapU, int nSnapV, int nWidth, int nHeight ); //----------------------------------------------------------------------------- // Overlay manager class //----------------------------------------------------------------------------- class COverlayMgr : public IOverlayMgr { public: typedef CUtlVector OverlayFragmentVector_t; public: COverlayMgr(); ~COverlayMgr(); // Implementation of IOverlayMgr interface virtual bool LoadOverlays( ); virtual void UnloadOverlays( ); virtual void CreateFragments( void ); virtual void ReSortMaterials( void ); virtual void ClearRenderLists(); virtual void ClearRenderLists( int nSortGroup ); virtual void AddFragmentListToRenderList( int nSortGroup, OverlayFragmentHandle_t iFragment, bool bDisp ); virtual void RenderOverlays( int nSortGroup ); virtual void SetOverlayBindProxy( int iOverlayID, void *pBindProxy ); private: // Create, destroy material sort order ids... int GetMaterialSortID( IMaterial* pMaterial, int nLightmapPage ); void CleanupMaterial( unsigned short nSortOrder ); moverlay_t *GetOverlay( int iOverlay ); moverlayfragment_t *GetOverlayFragment( OverlayFragmentHandle_t iFragment ); // Surfaces void Surf_CreateFragments( moverlay_t *pOverlay, SurfaceHandle_t surfID ); bool Surf_PreClipFragment( moverlay_t *pOverlay, moverlayfragment_t &overlayFrag, SurfaceHandle_t surfID, moverlayfragment_t &surfaceFrag ); void Surf_PostClipFragment( moverlay_t *pOverlay, moverlayfragment_t &overlayFrag, SurfaceHandle_t surfID ); void Surf_ClipFragment( moverlay_t *pOverlay, moverlayfragment_t &overlayFrag, SurfaceHandle_t surfID, moverlayfragment_t &surfaceFrag ); // Displacements void Disp_CreateFragments( moverlay_t *pOverlay, SurfaceHandle_t surfID ); bool Disp_PreClipFragment( moverlay_t *pOverlay, OverlayFragmentVector_t &aDispFragments, SurfaceHandle_t surfID ); void Disp_PostClipFragment( CDispInfo *pDisp, CMeshReader *pReader, moverlay_t *pOverlay, OverlayFragmentVector_t &aDispFragments, SurfaceHandle_t surfID ); void Disp_ClipFragment( CDispInfo *pDisp, OverlayFragmentVector_t &aDispFragments ); void Disp_DoClip( CDispInfo *pDisp, OverlayFragmentVector_t &aCurrentFragments, cplane_t &clipPlane, float clipDistStart, int nInterval, int nLoopStart, int nLoopEnd, int nLoopInc ); // Utility OverlayFragmentHandle_t AddFragmentToFragmentList( int nSize ); OverlayFragmentHandle_t AddFragmentToFragmentList( moverlayfragment_t *pSrc ); bool FadeOverlayFragmentGlobal( moverlayfragment_t *pFragment ); bool FadeOverlayFragment( moverlay_t *pOverlay, moverlayfragment_t *pFragment ); moverlayfragment_t *CreateTempFragment( int nSize ); moverlayfragment_t *CopyTempFragment( moverlayfragment_t *pSrc ); void DestroyTempFragment( moverlayfragment_t *pFragment ); void BuildClipPlanes( SurfaceHandle_t surfID, moverlayfragment_t &surfaceFrag, const Vector &vecBasisNormal, CUtlVector &m_ClipPlanes ); void DoClipFragment( moverlayfragment_t *pFragment, cplane_t *pClipPlane, moverlayfragment_t **ppFront, moverlayfragment_t **ppBack ); void InitTexCoords( moverlay_t *pOverlay, moverlayfragment_t &overlayFrag ); private: enum { RENDER_QUEUE_INVALID = 0xFFFF }; // Structures used to assign sort order handles struct RenderQueueInfo_t { OverlayFragmentHandle_t m_hFirstFragment; unsigned short m_nNextRenderQueue; // Index of next queue that has stuff to render unsigned short m_nVertexCount; unsigned short m_nIndexCount; }; struct RenderQueueHead_t { IMaterial *m_pMaterial; int m_nLightmapPage; RenderQueueInfo_t m_Queue[MAX_MAT_SORT_GROUPS]; unsigned short m_nRefCount; }; // First render queue to render unsigned short m_nFirstRenderQueue[MAX_MAT_SORT_GROUPS]; // Used to assign sort order handles CUtlLinkedList m_RenderQueue; // All overlays CUtlVector m_aOverlays; // List of all overlay fragments. prev/next links point to the next fragment on a *surface* CUtlLinkedList< moverlayfragment_t, unsigned short, true > m_aFragments; // Used to find all fragments associated with a particular overlay CUtlLinkedList< OverlayFragmentHandle_t, unsigned short, true > m_OverlayFragments; // Fade parameters. float m_flFadeMin2; float m_flFadeMax2; float m_flFadeDelta2; }; //----------------------------------------------------------------------------- // Singleton accessor //----------------------------------------------------------------------------- static COverlayMgr g_OverlayMgr; IOverlayMgr *OverlayMgr( void ) { return &g_OverlayMgr; } //----------------------------------------------------------------------------- // Constructor //----------------------------------------------------------------------------- COverlayMgr::COverlayMgr() { for ( int i = 0; i < MAX_MAT_SORT_GROUPS; ++i ) { m_nFirstRenderQueue[i] = RENDER_QUEUE_INVALID; } m_flFadeMin2 = 0.0f; m_flFadeMax2 = 0.0f; m_flFadeDelta2 = 0.0f; } //----------------------------------------------------------------------------- // Destructor //----------------------------------------------------------------------------- COverlayMgr::~COverlayMgr() { UnloadOverlays(); } //----------------------------------------------------------------------------- // Returns a particular overlay //----------------------------------------------------------------------------- inline moverlay_t *COverlayMgr::GetOverlay( int iOverlay ) { return &m_aOverlays[iOverlay]; } //----------------------------------------------------------------------------- // Returns a particular overlay fragment //----------------------------------------------------------------------------- inline moverlayfragment_t *COverlayMgr::GetOverlayFragment( OverlayFragmentHandle_t iFragment ) { return &m_aFragments[iFragment]; } //----------------------------------------------------------------------------- // Cleanup overlays //----------------------------------------------------------------------------- void COverlayMgr::UnloadOverlays( ) { FOR_EACH_LL( m_RenderQueue, i ) { m_RenderQueue[i].m_pMaterial->DecrementReferenceCount(); } int nOverlayCount = m_aOverlays.Count(); for ( int iOverlay = 0; iOverlay < nOverlayCount; ++iOverlay ) { moverlay_t *pOverlay = &m_aOverlays.Element( iOverlay ); int hFrag = pOverlay->m_hFirstFragment; while ( hFrag != OVERLAY_FRAGMENT_INVALID ) { int iFrag = m_OverlayFragments[hFrag]; m_aFragments.Free( iFrag ); hFrag = m_OverlayFragments.Next( hFrag ); } } m_aOverlays.Purge(); m_aFragments.Purge(); m_OverlayFragments.Purge(); m_RenderQueue.Purge(); for ( int i = 0; i < MAX_MAT_SORT_GROUPS; ++i ) { m_nFirstRenderQueue[i] = RENDER_QUEUE_INVALID; } } //----------------------------------------------------------------------------- // Create, destroy material sort order ids... //----------------------------------------------------------------------------- int COverlayMgr::GetMaterialSortID( IMaterial* pMaterial, int nLightmapPage ) { // Search the sort order handles for an enumeration id match (means materials + lightmaps match) unsigned short i; for ( i = m_RenderQueue.Head(); i != m_RenderQueue.InvalidIndex(); i = m_RenderQueue.Next(i) ) { // Found a match, lets increment the refcount of this sort order id if ((m_RenderQueue[i].m_pMaterial == pMaterial) && (m_RenderQueue[i].m_nLightmapPage == nLightmapPage)) { ++m_RenderQueue[i].m_nRefCount; return i; } } // Didn't find it, lets assign a new sort order ID, with a refcount of 1 i = m_RenderQueue.AddToTail(); RenderQueueHead_t &renderQueue = m_RenderQueue[i]; renderQueue.m_pMaterial = pMaterial; renderQueue.m_nLightmapPage = nLightmapPage; renderQueue.m_nRefCount = 1; for ( int j = 0; j < MAX_MAT_SORT_GROUPS; ++j ) { RenderQueueInfo_t &info = renderQueue.m_Queue[j]; info.m_hFirstFragment = OVERLAY_FRAGMENT_INVALID; info.m_nNextRenderQueue = RENDER_QUEUE_INVALID; info.m_nVertexCount = 0; info.m_nIndexCount = 0; } pMaterial->IncrementReferenceCount(); return i; } void COverlayMgr::CleanupMaterial( unsigned short nSortOrder ) { RenderQueueHead_t &renderQueue = m_RenderQueue[nSortOrder]; #ifdef _DEBUG for ( int i = 0; i < MAX_MAT_SORT_GROUPS; ++i ) { // Shouldn't be cleaning up while we've got a render list Assert( renderQueue.m_Queue[i].m_nVertexCount == 0 ); } #endif // Decrease the sort order reference count if (--renderQueue.m_nRefCount <= 0) { renderQueue.m_pMaterial->DecrementReferenceCount(); // No one referencing the sort order number? // Then lets clean up the sort order id m_RenderQueue.Remove(nSortOrder); } } //----------------------------------------------------------------------------- // Clears the render lists //----------------------------------------------------------------------------- void COverlayMgr::ClearRenderLists() { for ( int i = 0; i < MAX_MAT_SORT_GROUPS; ++i ) { ClearRenderLists( i ); } if ( r_overlayfadeenable.GetBool() ) { float flFadeMin = r_overlayfademin.GetFloat(); float flFadeMax = r_overlayfademax.GetFloat(); m_flFadeMin2 = flFadeMin * flFadeMin; m_flFadeMax2 = flFadeMax * flFadeMax; m_flFadeDelta2 = 1.0f / ( m_flFadeMax2 - m_flFadeMin2 ); } } //----------------------------------------------------------------------------- // Calculate the fade using the global convars. //----------------------------------------------------------------------------- bool COverlayMgr::FadeOverlayFragmentGlobal( moverlayfragment_t *pFragment ) { // Test the overlay distance and set alpha values. int iVert; bool bInRange = false; int nVertexCount = pFragment->m_aPrimVerts.Count(); for ( iVert = 0; iVert < nVertexCount; ++iVert ) { Vector vecSegment; VectorSubtract( MainViewOrigin(), pFragment->m_aPrimVerts.Element( iVert ).pos, vecSegment ); float flLength2 = vecSegment.LengthSqr(); // min dist of -1 means use max dist for fading if ( flLength2 < m_flFadeMin2 ) { pFragment->m_aPrimVerts.Element( iVert ).flAlpha = 1.0f; bInRange = true; } else if ( flLength2 > m_flFadeMax2 ) { // Set vertex alpha to off. pFragment->m_aPrimVerts.Element( iVert ).flAlpha = 0.0f; } else { // Set the alpha based on distance inside of fadeMin and fadeMax float flAlpha = flLength2 - m_flFadeMin2; flAlpha *= m_flFadeDelta2; pFragment->m_aPrimVerts.Element( iVert ).flAlpha = ( 1.0f - flAlpha ); bInRange = true; } } return bInRange; } //----------------------------------------------------------------------------- // Calculate the fade using per-overlay fade distances. //----------------------------------------------------------------------------- bool COverlayMgr::FadeOverlayFragment( moverlay_t *pOverlay, moverlayfragment_t *pFragment ) { // min dist of -1 means use max dist for fading float flFadeDistMinSq = pOverlay->m_flFadeDistMinSq; float flFadeDistMaxSq = pOverlay->m_flFadeDistMaxSq; Vector vecSegment; VectorSubtract( MainViewOrigin(), pOverlay->m_vecOrigin, vecSegment ); float flLength2 = vecSegment.LengthSqr(); float flAlpha = 0.0f; bool bInRange = false; if ( flLength2 < flFadeDistMaxSq ) { if ( ( flFadeDistMinSq >= 0 ) && ( flLength2 > flFadeDistMinSq ) ) { flAlpha = pOverlay->m_flInvFadeRangeSq * ( flFadeDistMaxSq - flLength2 ); flAlpha = clamp( flAlpha, 0.0f, 1.0f ); bInRange = true; } else { flAlpha = 1.0f; bInRange = true; } } int nVertexCount = pFragment->m_aPrimVerts.Count(); for ( int iVert = 0; iVert < nVertexCount; ++iVert ) { pFragment->m_aPrimVerts.Element( iVert ).flAlpha = flAlpha; } return bInRange; } //----------------------------------------------------------------------------- // Adds the fragment list to the list of fragments to render when RenderOverlays is called //----------------------------------------------------------------------------- void COverlayMgr::AddFragmentListToRenderList( int nSortGroup, OverlayFragmentHandle_t iFragment, bool bDisp ) { OverlayFragmentHandle_t i; for ( i = iFragment; i != OVERLAY_FRAGMENT_INVALID; i = m_aFragments.Next(i) ) { // Make sure we don't add the fragment twice... // FIXME: I currently have no way of ensuring a fragment doesn't end up in 2 sort groups // which would cause all manner of nastiness. moverlayfragment_t *pFragment = GetOverlayFragment(i); if ( !bDisp && pFragment->m_nRenderFrameID == g_OverlayRenderFrameID ) continue; // Triangle count too low? Skip it... int nVertexCount = pFragment->m_aPrimVerts.Count(); if ( nVertexCount < 3 ) continue; moverlay_t *pOverlay = &m_aOverlays[ pFragment->m_iOverlay ]; // See if we should fade the overlay. if ( r_overlayfadeenable.GetBool() ) { // Fade using the convars that control distance. if ( !FadeOverlayFragmentGlobal( pFragment ) ) continue; } else if ( pOverlay->m_flFadeDistMaxSq > 0 ) { // Fade using per-overlay fade distances, configured by the level designer. if ( !FadeOverlayFragment( pOverlay, pFragment ) ) continue; } // Update the frame count. pFragment->m_nRenderFrameID = g_OverlayRenderFrameID; // Determine the material associated with the fragment... int nMaterialSortID = pFragment->m_nMaterialSortID; // Insert the render queue into the list of render queues to render RenderQueueHead_t &renderQueue = m_RenderQueue[nMaterialSortID]; RenderQueueInfo_t &info = renderQueue.m_Queue[nSortGroup]; if ( info.m_hFirstFragment == OVERLAY_FRAGMENT_INVALID ) { info.m_nNextRenderQueue = m_nFirstRenderQueue[nSortGroup]; m_nFirstRenderQueue[nSortGroup] = nMaterialSortID; } // Add to list of fragments for this surface // NOTE: Render them in *reverse* order in which they appeared in the list // because they are stored in the list in *reverse* order in which they should be rendered. // Add the fragment to the bucket of fragments to render... pFragment->m_hNextRender = info.m_hFirstFragment; info.m_hFirstFragment = i; Assert( info.m_nVertexCount + nVertexCount < 65535 ); info.m_nVertexCount += nVertexCount; info.m_nIndexCount += 3 * (nVertexCount - 2); } } //----------------------------------------------------------------------------- // Renders all queued up overlays //----------------------------------------------------------------------------- void COverlayMgr::ClearRenderLists( int nSortGroup ) { g_OverlayRenderFrameID++; int nNextRenderQueue; for( int i = m_nFirstRenderQueue[nSortGroup]; i != RENDER_QUEUE_INVALID; i = nNextRenderQueue ) { RenderQueueInfo_t &renderQueue = m_RenderQueue[i].m_Queue[nSortGroup]; nNextRenderQueue = renderQueue.m_nNextRenderQueue; // Clean up the render queue for next time... renderQueue.m_nVertexCount = 0; renderQueue.m_nIndexCount = 0; renderQueue.m_hFirstFragment = OVERLAY_FRAGMENT_INVALID; renderQueue.m_nNextRenderQueue = RENDER_QUEUE_INVALID; } m_nFirstRenderQueue[nSortGroup] = RENDER_QUEUE_INVALID; } //----------------------------------------------------------------------------- // Renders all queued up overlays //----------------------------------------------------------------------------- void COverlayMgr::RenderOverlays( int nSortGroup ) { #ifndef SWDS VPROF_BUDGET( "COverlayMgr::RenderOverlays", VPROF_BUDGETGROUP_OVERLAYS ); if (r_renderoverlayfragment.GetInt() == 0) { ClearRenderLists( nSortGroup ); return; } CMatRenderContextPtr pRenderContext( materials ); bool bWireframeFragments = ( r_overlaywireframe.GetInt() != 0 ); if ( bWireframeFragments ) { pRenderContext->Bind( g_materialWorldWireframe ); } // Render sorted by material + lightmap... // Render them in order of their m_nRenderOrder parameter (set in the entity). int iCurrentRenderOrder = 0; int iHighestRenderOrder = 0; bool bLightmappedMaterial = false; int nMaxIndices = pRenderContext->GetMaxIndicesToRender(); while ( iCurrentRenderOrder <= iHighestRenderOrder ) { int nNextRenderQueue; for( int i = m_nFirstRenderQueue[nSortGroup]; i != RENDER_QUEUE_INVALID; i = nNextRenderQueue ) { RenderQueueHead_t &renderQueueHead = m_RenderQueue[i]; RenderQueueInfo_t &renderQueue = renderQueueHead.m_Queue[nSortGroup]; nNextRenderQueue = renderQueue.m_nNextRenderQueue; Assert( renderQueue.m_nVertexCount > 0 ); int nMaxVertices = pRenderContext->GetMaxVerticesToRender( !bWireframeFragments ? renderQueueHead.m_pMaterial : g_materialWorldWireframe ); if ( nMaxVertices == 0 ) continue; // Run this list for each bind proxy OverlayFragmentHandle_t hStartFragment = renderQueue.m_hFirstFragment; while ( hStartFragment != OVERLAY_FRAGMENT_INVALID ) { void *pCurrentBindProxy = m_aOverlays[ m_aFragments[ hStartFragment ].m_iOverlay ].m_pBindProxy; IMesh* pMesh = 0; // only init when we actually have something CMeshBuilder meshBuilder; CUtlVectorFixedGrowable polyList; int nCurrVertexCount = 0; int nCurrIndexCount = 0; bool bBoundMaterial = false; // We just need to make sure there's a unique sort ID for that. Then we bind once per queue OverlayFragmentHandle_t hFragment = hStartFragment; hStartFragment = OVERLAY_FRAGMENT_INVALID; for ( ; hFragment != OVERLAY_FRAGMENT_INVALID; hFragment = m_aFragments[hFragment].m_hNextRender ) { moverlayfragment_t *pFragment = &m_aFragments[hFragment]; moverlay_t *pOverlay = &m_aOverlays[pFragment->m_iOverlay]; if ( pOverlay->m_pBindProxy != pCurrentBindProxy ) { // This is from a different bind proxy if ( hStartFragment == OVERLAY_FRAGMENT_INVALID ) { // Start at the first different bind proxy when we rerun the fragment list hStartFragment = hFragment; } continue; } // Only render the current render order. int iThisOverlayRenderOrder = pOverlay->m_nRenderOrder; iHighestRenderOrder = max( iThisOverlayRenderOrder, iHighestRenderOrder ); if ( iThisOverlayRenderOrder != iCurrentRenderOrder ) continue; int nVertCount = pFragment->m_aPrimVerts.Count(); int nIndexCount = 3 * ( nVertCount - 2 ); if ( pMesh ) { // Would this cause an overflow? Flush! if ( ( ( nCurrVertexCount + nVertCount ) > nMaxVertices ) || ( ( nCurrIndexCount + nIndexCount ) > nMaxIndices ) ) { CIndexBuilder &indexBuilder = meshBuilder; indexBuilder.FastPolygonList( 0, polyList.Base(), polyList.Count() ); meshBuilder.End(); pMesh->Draw(); pMesh = NULL; polyList.RemoveAll(); nCurrIndexCount = nCurrVertexCount = 0; } } nCurrVertexCount += nVertCount; nCurrIndexCount += nIndexCount; const overlayvert_t *pVert = &(pFragment->m_aPrimVerts[0]); int iVert; if ( !pMesh ) // have we output any vertices yet? if first verts, init material and meshbuilder { if ( !bWireframeFragments && !bBoundMaterial ) { pRenderContext->Bind( renderQueueHead.m_pMaterial, pOverlay->m_pBindProxy /*proxy*/ ); pRenderContext->BindLightmapPage( renderQueueHead.m_nLightmapPage ); bLightmappedMaterial = renderQueueHead.m_pMaterial->GetPropertyFlag( MATERIAL_PROPERTY_NEEDS_LIGHTMAP ) || renderQueueHead.m_pMaterial->GetPropertyFlag( MATERIAL_PROPERTY_NEEDS_BUMPED_LIGHTMAPS ); bBoundMaterial = true; } // Create the mesh/mesh builder. pMesh = pRenderContext->GetDynamicMesh(); meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, MIN( renderQueue.m_nVertexCount, nMaxVertices ), MIN( renderQueue.m_nIndexCount, nMaxIndices ) ); } if ( bLightmappedMaterial ) { float flOffset = ComputeDecalLightmapOffset( pFragment->m_SurfId ); for ( iVert = 0; iVert < nVertCount; ++iVert, ++pVert ) { unsigned char nAlpha = FastFToC( pVert->flAlpha ); meshBuilder.Position3fv( pVert->pos.Base() ); meshBuilder.Normal3fv( pVert->normal.Base() ); meshBuilder.Color4ub( 255, 255, 255, nAlpha ); meshBuilder.TexCoord2fv( 0, pVert->texCoord[0].Base() ); meshBuilder.TexCoord2fv( 1, pVert->lightCoord ); meshBuilder.TexCoord1f( 2, flOffset ); meshBuilder.AdvanceVertex(); } } else { for ( iVert = 0; iVert < nVertCount; ++iVert, ++pVert ) { unsigned char nAlpha = FastFToC( pVert->flAlpha ); meshBuilder.Position3fv( pVert->pos.Base() ); meshBuilder.Normal3fv( pVert->normal.Base() ); meshBuilder.Color4ub( 255, 255, 255, nAlpha ); meshBuilder.TexCoord2fv( 0, pVert->texCoord[0].Base() ); meshBuilder.TexCoord2fv( 1, pVert->lightCoord ); meshBuilder.TexCoord2fv( 2, pVert->texCoord[1].Base() ); meshBuilder.AdvanceVertex(); } } polyList.AddToTail( nVertCount ); } if (pMesh) { CIndexBuilder &indexBuilder = meshBuilder; indexBuilder.FastPolygonList( 0, polyList.Base(), polyList.Count() ); meshBuilder.End(); pMesh->Draw(); } } } ++iCurrentRenderOrder; } #endif } void COverlayMgr::SetOverlayBindProxy( int iOverlayID, void *pBindProxy ) { moverlay_t *pOverlay = GetOverlay( iOverlayID ); if ( pOverlay ) pOverlay->m_pBindProxy = pBindProxy; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool COverlayMgr::Surf_PreClipFragment( moverlay_t *pOverlay, moverlayfragment_t &overlayFrag, SurfaceHandle_t surfID, moverlayfragment_t &surfaceFrag ) { MEM_ALLOC_CREDIT(); // Convert the overlay uv points to overlay plane points. overlayFrag.m_aPrimVerts.SetCount( 4 ); for( int iVert = 0; iVert < 4; ++iVert ) { Overlay_OverlayUVToOverlayPlane( pOverlay->m_vecOrigin, pOverlay->m_vecBasis[0], pOverlay->m_vecBasis[1], pOverlay->m_vecUVPoints[iVert], overlayFrag.m_aPrimVerts[iVert].pos ); } // Overlay texture coordinates. InitTexCoords( pOverlay, overlayFrag ); // Surface int nVertCount = surfaceFrag.m_aPrimVerts.Count(); for ( int iVert = 0; iVert < nVertCount; ++iVert ) { // Position. Overlay_WorldToOverlayPlane( pOverlay->m_vecOrigin, pOverlay->m_vecBasis[2], surfaceFrag.m_aPrimVerts[iVert].pos, surfaceFrag.m_aPrimVerts[iVert].pos ); } return true; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void COverlayMgr::Surf_PostClipFragment( moverlay_t *pOverlay, moverlayfragment_t &overlayFrag, SurfaceHandle_t surfID ) { #ifndef SWDS // Get fragment vertex count. int nVertCount = overlayFrag.m_aPrimVerts.Count(); if ( nVertCount == 0 ) return; // Create fragment. OverlayFragmentHandle_t hFragment = AddFragmentToFragmentList( nVertCount ); moverlayfragment_t *pFragment = GetOverlayFragment( hFragment ); // Get surface context. SurfaceCtx_t ctx; SurfSetupSurfaceContext( ctx, surfID ); pFragment->m_iOverlay = pOverlay->m_nId; pFragment->m_SurfId = surfID; const Vector &vNormal = MSurf_Plane( surfID ).normal; moverlayfragment_t origOverlay; origOverlay.m_aPrimVerts.SetSize( 4 ); for ( int iPoint = 0; iPoint < 4; ++iPoint ) { Overlay_OverlayUVToOverlayPlane( pOverlay->m_vecOrigin, pOverlay->m_vecBasis[0], pOverlay->m_vecBasis[1], pOverlay->m_vecUVPoints[iPoint], origOverlay.m_aPrimVerts[iPoint].pos ); } InitTexCoords( pOverlay, origOverlay ); for ( int iVert = 0; iVert < nVertCount; ++iVert ) { Vector2D vecUV; PointInQuadToBarycentric( origOverlay.m_aPrimVerts[0].pos, origOverlay.m_aPrimVerts[3].pos, origOverlay.m_aPrimVerts[2].pos, origOverlay.m_aPrimVerts[1].pos, overlayFrag.m_aPrimVerts[iVert].pos, vecUV ); Overlay_OverlayPlaneToWorld( pOverlay->m_vecBasis[2], surfID, overlayFrag.m_aPrimVerts[iVert].pos, pFragment->m_aPrimVerts[iVert].pos ); // Texture coordinates. Vector2D vecTexCoord; for ( int iTexCoord=0; iTexCoord < NUM_OVERLAY_TEXCOORDS; iTexCoord++ ) { TexCoordInQuadFromBarycentric( origOverlay.m_aPrimVerts[0].texCoord[iTexCoord], origOverlay.m_aPrimVerts[3].texCoord[iTexCoord], origOverlay.m_aPrimVerts[2].texCoord[iTexCoord], origOverlay.m_aPrimVerts[1].texCoord[iTexCoord], vecUV, vecTexCoord ); pFragment->m_aPrimVerts[iVert].texCoord[iTexCoord][0] = vecTexCoord.x; pFragment->m_aPrimVerts[iVert].texCoord[iTexCoord][1] = vecTexCoord.y; } // Normals : FIXME this isn't an interpolated normal. pFragment->m_aPrimVerts[iVert].normal = vNormal; // Lightmap coordinates. Vector2D uv; SurfComputeLightmapCoordinate( ctx, surfID, pFragment->m_aPrimVerts[iVert].pos, uv ); pFragment->m_aPrimVerts[iVert].lightCoord[0] = uv.x; pFragment->m_aPrimVerts[iVert].lightCoord[1] = uv.y; // Push -just- off the surface to avoid z-clipping errors. pFragment->m_aPrimVerts[iVert].pos += vNormal * OVERLAY_AVOID_FLICKER_NORMAL_OFFSET; } // Create the sort ID for this fragment const MaterialSystem_SortInfo_t &sortInfo = materialSortInfoArray[MSurf_MaterialSortID( surfID )]; mtexinfo_t *pTexInfo = &host_state.worldbrush->texinfo[pOverlay->m_nTexInfo]; pFragment->m_nMaterialSortID = GetMaterialSortID( pTexInfo->material, sortInfo.lightmapPageID ); // Add to list of fragments for this overlay MEM_ALLOC_CREDIT(); OverlayFragmentList_t i = m_OverlayFragments.Alloc( true ); m_OverlayFragments[i] = hFragment; m_OverlayFragments.LinkBefore( pOverlay->m_hFirstFragment, i ); pOverlay->m_hFirstFragment = i; // Add to list of fragments for this surface // NOTE: Store them in *reverse* order so that when we pull them off for // rendering, we can do *that* in reverse order too? Reduces the amount of iteration necessary // Therefore, we need to add to the head of the list m_aFragments.LinkBefore( MSurf_OverlayFragmentList( surfID ), hFragment ); MSurf_OverlayFragmentList( surfID ) = hFragment; #endif // !SWDS } //----------------------------------------------------------------------------- // Clips an overlay to a surface //----------------------------------------------------------------------------- void COverlayMgr::Surf_ClipFragment( moverlay_t *pOverlay, moverlayfragment_t &overlayFrag, SurfaceHandle_t surfID, moverlayfragment_t &surfaceFrag ) { MEM_ALLOC_CREDIT(); // Create the clip planes. CUtlVector m_ClipPlanes; BuildClipPlanes( surfID, surfaceFrag, pOverlay->m_vecBasis[2], m_ClipPlanes ); // Copy the overlay fragment (initial clipped fragment). moverlayfragment_t *pClippedFrag = CopyTempFragment( &overlayFrag ); for( int iPlane = 0; iPlane < m_ClipPlanes.Count(); ++iPlane ) { moverlayfragment_t *pFront = NULL, *pBack = NULL; DoClipFragment( pClippedFrag, &m_ClipPlanes[iPlane], &pFront, &pBack ); DestroyTempFragment( pClippedFrag ); pClippedFrag = NULL; // Keep the backside and continue clipping. if ( pBack ) { pClippedFrag = pBack; } if ( pFront ) { DestroyTempFragment( pFront ); } } m_ClipPlanes.Purge(); // Copy the clipped polygon back to the overlay frag. overlayFrag.m_aPrimVerts.RemoveAll(); if ( pClippedFrag ) { overlayFrag.m_aPrimVerts.SetCount( pClippedFrag->m_aPrimVerts.Count() ); for ( int iVert = 0; iVert < pClippedFrag->m_aPrimVerts.Count(); ++iVert ) { overlayFrag.m_aPrimVerts[iVert].pos = pClippedFrag->m_aPrimVerts[iVert].pos; memcpy( overlayFrag.m_aPrimVerts[iVert].texCoord, pClippedFrag->m_aPrimVerts[iVert].texCoord, sizeof( overlayFrag.m_aPrimVerts[iVert].texCoord ) ); } } DestroyTempFragment( pClippedFrag ); } inline float TriangleArea( const Vector &v0, const Vector &v1, const Vector &v2 ) { Vector vecEdge0, vecEdge1, vecCross; VectorSubtract( v1, v0, vecEdge0 ); VectorSubtract( v2, v0, vecEdge1 ); CrossProduct( vecEdge0, vecEdge1, vecCross ); return ( VectorLength( vecCross ) * 0.5f ); } //----------------------------------------------------------------------------- // Creates overlay fragments for a particular surface //----------------------------------------------------------------------------- void COverlayMgr::Surf_CreateFragments( moverlay_t *pOverlay, SurfaceHandle_t surfID ) { moverlayfragment_t overlayFrag, surfaceFrag; // The faces get fan tesselated into triangles when rendered - do the same to // create the fragments! int iFirstVert = MSurf_FirstVertIndex( surfID ); int nSurfTriangleCount = MSurf_VertCount( surfID ) - 2; for( int iTri = 0; iTri < nSurfTriangleCount; ++iTri ) { // 3 Points in a triangle. surfaceFrag.m_aPrimVerts.SetCount( 3 ); int iVert = host_state.worldbrush->vertindices[(iFirstVert)]; mvertex_t *pVert = &host_state.worldbrush->vertexes[iVert]; surfaceFrag.m_aPrimVerts[0].pos = pVert->position; iVert = host_state.worldbrush->vertindices[(iFirstVert+iTri+1)]; pVert = &host_state.worldbrush->vertexes[iVert]; surfaceFrag.m_aPrimVerts[1].pos = pVert->position; iVert = host_state.worldbrush->vertindices[(iFirstVert+iTri+2)]; pVert = &host_state.worldbrush->vertexes[iVert]; surfaceFrag.m_aPrimVerts[2].pos = pVert->position; if ( TriangleArea( surfaceFrag.m_aPrimVerts[0].pos, surfaceFrag.m_aPrimVerts[1].pos, surfaceFrag.m_aPrimVerts[2].pos ) > 1.0f ) { if ( Surf_PreClipFragment( pOverlay, overlayFrag, surfID, surfaceFrag ) ) { Surf_ClipFragment( pOverlay, overlayFrag, surfID, surfaceFrag ); Surf_PostClipFragment( pOverlay, overlayFrag, surfID ); } } // Clean up! surfaceFrag.m_aPrimVerts.RemoveAll(); overlayFrag.m_aPrimVerts.RemoveAll(); } } //----------------------------------------------------------------------------- // Creates fragments from the overlays loaded in from file //----------------------------------------------------------------------------- void COverlayMgr::CreateFragments( void ) { int nOverlayCount = m_aOverlays.Count(); for ( int iOverlay = 0; iOverlay < nOverlayCount; ++iOverlay ) { moverlay_t *pOverlay = &m_aOverlays.Element( iOverlay ); int nFaceCount = pOverlay->m_aFaces.Count(); if ( nFaceCount == 0 ) continue; // Build the overlay basis. bool bFlip = ( pOverlay->m_vecUVPoints[3].z == 1.0f ); pOverlay->m_vecUVPoints[3].z = 0.0f; Overlay_BuildBasis( pOverlay->m_vecBasis[2], pOverlay->m_vecBasis[0], pOverlay->m_vecBasis[1], bFlip ); // Clip against each face in the face list. for( int iFace = 0; iFace < nFaceCount; ++iFace ) { SurfaceHandle_t surfID = pOverlay->m_aFaces[iFace]; if ( SurfaceHasDispInfo( surfID ) ) { Disp_CreateFragments( pOverlay, surfID ); } else { Surf_CreateFragments( pOverlay, surfID ); } } } // Overlay checking! for ( int iOverlay = 0; iOverlay < nOverlayCount; ++iOverlay ) { moverlay_t *pOverlay = &m_aOverlays.Element( iOverlay ); int hFrag = pOverlay->m_hFirstFragment; while ( hFrag != OVERLAY_FRAGMENT_INVALID ) { int iFrag = m_OverlayFragments[hFrag]; moverlayfragment_t *pFrag = &m_aFragments[iFrag]; int nVertCount = pFrag->m_aPrimVerts.Count(); for ( int iVert = 0; iVert < nVertCount; ++iVert ) { overlayvert_t *pVert = &pFrag->m_aPrimVerts[iVert]; if ( !pVert->pos.IsValid() ) { Assert( 0 ); mtexinfo_t *pTexInfo = &host_state.worldbrush->texinfo[pOverlay->m_nTexInfo]; DevMsg( 1, "Bad overlay vert - %d at (%f, %f, %f) with material '%s'\n", iOverlay, pOverlay->m_vecOrigin.x, pOverlay->m_vecOrigin.y, pOverlay->m_vecOrigin.z, ( pTexInfo && pTexInfo->material ) ? pTexInfo->material->GetName() : "" ); } if ( !pVert->normal.IsValid() ) { Assert( 0 ); mtexinfo_t *pTexInfo = &host_state.worldbrush->texinfo[pOverlay->m_nTexInfo]; DevMsg( 1, "Bad overlay normal - %d at (%f, %f, %f) with material '%s'\n", iOverlay, pOverlay->m_vecOrigin.x, pOverlay->m_vecOrigin.y, pOverlay->m_vecOrigin.z, ( pTexInfo && pTexInfo->material ) ? pTexInfo->material->GetName() : "" ); } if ( !pVert->texCoord[0].IsValid() || !pVert->texCoord[1].IsValid() ) { Assert( 0 ); mtexinfo_t *pTexInfo = &host_state.worldbrush->texinfo[pOverlay->m_nTexInfo]; DevMsg( 1, "Bad overlay texture coords - %d at (%f, %f, %f) with material '%s'\n", iOverlay, pOverlay->m_vecOrigin.x, pOverlay->m_vecOrigin.y, pOverlay->m_vecOrigin.z, ( pTexInfo && pTexInfo->material ) ? pTexInfo->material->GetName() : "" ); } } hFrag = m_OverlayFragments.Next( hFrag ); } } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void COverlayMgr::ReSortMaterials( void ) { #ifndef SWDS // Clear the old render queue. m_RenderQueue.Purge(); for ( int iSort = 0; iSort < MAX_MAT_SORT_GROUPS; ++iSort ) { m_nFirstRenderQueue[iSort] = RENDER_QUEUE_INVALID; } // Update all fragments. int nOverlayCount = m_aOverlays.Count(); for ( int iOverlay = 0; iOverlay < nOverlayCount; ++iOverlay ) { moverlay_t *pOverlay = &m_aOverlays.Element( iOverlay ); if ( !pOverlay ) continue; mtexinfo_t *pTexInfo = &host_state.worldbrush->texinfo[pOverlay->m_nTexInfo]; if ( !pTexInfo ) continue; int hFrag = pOverlay->m_hFirstFragment; while ( hFrag != OVERLAY_FRAGMENT_INVALID ) { int iFrag = m_OverlayFragments[hFrag]; moverlayfragment_t *pFrag = &m_aFragments[iFrag]; if ( pFrag ) { const MaterialSystem_SortInfo_t &sortInfo = materialSortInfoArray[MSurf_MaterialSortID( pFrag->m_SurfId )]; pFrag->m_nMaterialSortID = GetMaterialSortID( pTexInfo->material, sortInfo.lightmapPageID ); // Get surface context. SurfaceCtx_t ctx; SurfSetupSurfaceContext( ctx, pFrag->m_SurfId ); int nVertCount = pFrag->m_aPrimVerts.Count(); for ( int iVert = 0; iVert < nVertCount; ++iVert ) { // Lightmap coordinates. Vector2D uv; SurfComputeLightmapCoordinate( ctx, pFrag->m_SurfId, pFrag->m_aPrimVerts[iVert].pos, uv ); pFrag->m_aPrimVerts[iVert].lightCoord[0] = uv.x; pFrag->m_aPrimVerts[iVert].lightCoord[1] = uv.y; } } hFrag = m_OverlayFragments.Next( hFrag ); } } #endif // !SWDS } //----------------------------------------------------------------------------- // Loads overlays from the lump //----------------------------------------------------------------------------- bool COverlayMgr::LoadOverlays( ) { CMapLoadHelper lh( LUMP_OVERLAYS ); CMapLoadHelper lh2( LUMP_WATEROVERLAYS ); CMapLoadHelper lhOverlayFades( LUMP_OVERLAY_FADES ); doverlay_t *pOverlayIn; dwateroverlay_t *pWaterOverlayIn; pOverlayIn = ( doverlay_t* )lh.LumpBase(); if ( lh.LumpSize() % sizeof( doverlay_t ) ) return false; pWaterOverlayIn = ( dwateroverlay_t* )lh2.LumpBase(); if ( lh2.LumpSize() % sizeof( dwateroverlay_t ) ) return false; // Fade distances are in a parallel lump doverlayfade_t *pOverlayFadesIn = (doverlayfade_t *)lhOverlayFades.LumpBase(); if ( lhOverlayFades.LumpSize() % sizeof( doverlayfade_t ) ) return false; int nOverlayCount = lh.LumpSize() / sizeof( doverlay_t ); int nWaterOverlayCount = lh2.LumpSize() / sizeof( dwateroverlay_t ); // Memory allocation! m_aOverlays.SetSize( nOverlayCount + nWaterOverlayCount ); for( int iOverlay = 0; iOverlay < nOverlayCount; ++iOverlay, ++pOverlayIn ) { moverlay_t *pOverlayOut = &m_aOverlays.Element( iOverlay ); pOverlayOut->m_nId = iOverlay; pOverlayOut->m_nTexInfo = pOverlayIn->nTexInfo; pOverlayOut->m_nRenderOrder = pOverlayIn->GetRenderOrder(); if ( pOverlayOut->m_nRenderOrder >= OVERLAY_NUM_RENDER_ORDERS ) Error( "COverlayMgr::LoadOverlays: invalid render order (%d) for an overlay.", pOverlayOut->m_nRenderOrder ); pOverlayOut->m_flU[0] = pOverlayIn->flU[0]; pOverlayOut->m_flU[1] = pOverlayIn->flU[1]; pOverlayOut->m_flV[0] = pOverlayIn->flV[0]; pOverlayOut->m_flV[1] = pOverlayIn->flV[1]; if ( pOverlayFadesIn ) { pOverlayOut->m_flFadeDistMinSq = pOverlayFadesIn->flFadeDistMinSq; pOverlayOut->m_flFadeDistMaxSq = pOverlayFadesIn->flFadeDistMaxSq; pOverlayOut->m_flInvFadeRangeSq = 1.0f / ( pOverlayFadesIn->flFadeDistMaxSq - pOverlayFadesIn->flFadeDistMinSq ); pOverlayFadesIn++; } else { pOverlayOut->m_flFadeDistMinSq = -1.0f; pOverlayOut->m_flFadeDistMaxSq = 0; pOverlayOut->m_flInvFadeRangeSq = 1.0f; } VectorCopy( pOverlayIn->vecOrigin, pOverlayOut->m_vecOrigin ); VectorCopy( pOverlayIn->vecUVPoints[0], pOverlayOut->m_vecUVPoints[0] ); VectorCopy( pOverlayIn->vecUVPoints[1], pOverlayOut->m_vecUVPoints[1] ); VectorCopy( pOverlayIn->vecUVPoints[2], pOverlayOut->m_vecUVPoints[2] ); VectorCopy( pOverlayIn->vecUVPoints[3], pOverlayOut->m_vecUVPoints[3] ); VectorCopy( pOverlayIn->vecBasisNormal, pOverlayOut->m_vecBasis[2] ); // Basis U is encoded in the z components of the UVPoints 0, 1, 2 pOverlayOut->m_vecBasis[0].x = pOverlayOut->m_vecUVPoints[0].z; pOverlayOut->m_vecBasis[0].y = pOverlayOut->m_vecUVPoints[1].z; pOverlayOut->m_vecBasis[0].z = pOverlayOut->m_vecUVPoints[2].z; if ( pOverlayOut->m_vecBasis[0].x == 0.0f && pOverlayOut->m_vecBasis[0].y == 0.0f && pOverlayOut->m_vecBasis[0].z == 0.0f ) { Warning( "Bad overlay basis at (%f %f %f)!\n", pOverlayOut->m_vecOrigin.x, pOverlayOut->m_vecOrigin.y, pOverlayOut->m_vecOrigin.z ); } CrossProduct( pOverlayOut->m_vecBasis[2], pOverlayOut->m_vecBasis[0], pOverlayOut->m_vecBasis[1] ); VectorNormalize( pOverlayOut->m_vecBasis[1] ); pOverlayOut->m_vecUVPoints[0].z = 0.0f; pOverlayOut->m_vecUVPoints[1].z = 0.0f; pOverlayOut->m_vecUVPoints[2].z = 0.0f; pOverlayOut->m_aFaces.SetSize( pOverlayIn->GetFaceCount() ); for( int iFace = 0; iFace < pOverlayIn->GetFaceCount(); ++iFace ) { pOverlayOut->m_aFaces[iFace] = SurfaceHandleFromIndex( pOverlayIn->aFaces[iFace], lh.GetMap() ); } pOverlayOut->m_hFirstFragment = OVERLAY_FRAGMENT_LIST_INVALID; pOverlayOut->m_pBindProxy = NULL; } for( int iWaterOverlay = 0; iWaterOverlay < nWaterOverlayCount; ++iWaterOverlay, ++pWaterOverlayIn ) { moverlay_t *pOverlayOut = &m_aOverlays.Element( nOverlayCount + iWaterOverlay ); pOverlayOut->m_nId = nOverlayCount + iWaterOverlay; pOverlayOut->m_nTexInfo = pWaterOverlayIn->nTexInfo; pOverlayOut->m_nRenderOrder = pWaterOverlayIn->GetRenderOrder(); if ( pOverlayOut->m_nRenderOrder >= OVERLAY_NUM_RENDER_ORDERS ) Error( "COverlayMgr::LoadOverlays: invalid render order (%d) for an overlay.", pOverlayOut->m_nRenderOrder ); pOverlayOut->m_flU[0] = pWaterOverlayIn->flU[0]; pOverlayOut->m_flU[1] = pWaterOverlayIn->flU[1]; pOverlayOut->m_flV[0] = pWaterOverlayIn->flV[0]; pOverlayOut->m_flV[1] = pWaterOverlayIn->flV[1]; VectorCopy( pWaterOverlayIn->vecOrigin, pOverlayOut->m_vecOrigin ); VectorCopy( pWaterOverlayIn->vecUVPoints[0], pOverlayOut->m_vecUVPoints[0] ); VectorCopy( pWaterOverlayIn->vecUVPoints[1], pOverlayOut->m_vecUVPoints[1] ); VectorCopy( pWaterOverlayIn->vecUVPoints[2], pOverlayOut->m_vecUVPoints[2] ); VectorCopy( pWaterOverlayIn->vecUVPoints[3], pOverlayOut->m_vecUVPoints[3] ); VectorCopy( pWaterOverlayIn->vecBasisNormal, pOverlayOut->m_vecBasis[2] ); // Basis U is encoded in the z components of the UVPoints 0, 1, 2 pOverlayOut->m_vecBasis[0].x = pOverlayOut->m_vecUVPoints[0].z; pOverlayOut->m_vecBasis[0].y = pOverlayOut->m_vecUVPoints[1].z; pOverlayOut->m_vecBasis[0].z = pOverlayOut->m_vecUVPoints[2].z; if ( pOverlayOut->m_vecBasis[0].x == 0.0f && pOverlayOut->m_vecBasis[0].y == 0.0f && pOverlayOut->m_vecBasis[0].z == 0.0f ) { Warning( "Bad overlay basis at (%f %f %f)!\n", pOverlayOut->m_vecOrigin.x, pOverlayOut->m_vecOrigin.y, pOverlayOut->m_vecOrigin.z ); } CrossProduct( pOverlayOut->m_vecBasis[2], pOverlayOut->m_vecBasis[0], pOverlayOut->m_vecBasis[1] ); VectorNormalize( pOverlayOut->m_vecBasis[1] ); pOverlayOut->m_vecUVPoints[0].z = 0.0f; pOverlayOut->m_vecUVPoints[1].z = 0.0f; pOverlayOut->m_vecUVPoints[2].z = 0.0f; pOverlayOut->m_aFaces.SetSize( pWaterOverlayIn->GetFaceCount() ); for( int iFace = 0; iFace < pWaterOverlayIn->GetFaceCount(); ++iFace ) { pOverlayOut->m_aFaces[iFace] = SurfaceHandleFromIndex( pWaterOverlayIn->aFaces[iFace], lh2.GetMap() ); } pOverlayOut->m_hFirstFragment = OVERLAY_FRAGMENT_LIST_INVALID; pOverlayOut->m_pBindProxy = NULL; } return true; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void COverlayMgr::Disp_CreateFragments( moverlay_t *pOverlay, SurfaceHandle_t surfID ) { OverlayFragmentVector_t aDispFragments; if ( Disp_PreClipFragment( pOverlay, aDispFragments, surfID ) ) { IDispInfo *pIDisp = MSurf_DispInfo( surfID ); CDispInfo *pDisp = static_cast( pIDisp ); if ( pDisp ) { Disp_ClipFragment( pDisp, aDispFragments ); Disp_PostClipFragment( pDisp, &pDisp->m_MeshReader, pOverlay, aDispFragments, surfID ); } } for ( int i = aDispFragments.Count(); --i >= 0; ) { DestroyTempFragment( aDispFragments[i] ); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool COverlayMgr::Disp_PreClipFragment( moverlay_t *pOverlay, OverlayFragmentVector_t &aDispFragments, SurfaceHandle_t surfID ) { MEM_ALLOC_CREDIT(); // The faces are not tesselated when they are displaced faces. int iFirstVert = MSurf_FirstVertIndex( surfID ); // Displaced faces are quads. moverlayfragment_t surfaceFrag; surfaceFrag.m_aPrimVerts.SetCount( 4 ); for( int iVert = 0; iVert < 4; ++iVert ) { int iVertex = host_state.worldbrush->vertindices[(iFirstVert+iVert)]; mvertex_t *pVert = &host_state.worldbrush->vertexes[iVertex]; surfaceFrag.m_aPrimVerts[iVert].pos = pVert->position; } // Setup the base fragment to be clipped by the base surface previous to the // displaced surface. moverlayfragment_t overlayFrag; if ( !Surf_PreClipFragment( pOverlay, overlayFrag, surfID, surfaceFrag ) ) return false; Surf_ClipFragment( pOverlay, overlayFrag, surfID, surfaceFrag ); // Get fragment vertex count. int nVertCount = overlayFrag.m_aPrimVerts.Count(); if ( nVertCount == 0 ) return false; // Setup moverlayfragment_t *pFragment = CopyTempFragment( &overlayFrag ); aDispFragments.AddToTail( pFragment ); IDispInfo *pIDispInfo = MSurf_DispInfo( surfID ); CDispInfo *pDispInfo = static_cast( pIDispInfo ); int iPointStart = pDispInfo->m_iPointStart; Vector2D vecTmpUV; for ( int iVert = 0; iVert < nVertCount; ++iVert ) { PointInQuadToBarycentric( surfaceFrag.m_aPrimVerts[iPointStart].pos, surfaceFrag.m_aPrimVerts[(iPointStart+3)%4].pos, surfaceFrag.m_aPrimVerts[(iPointStart+2)%4].pos, surfaceFrag.m_aPrimVerts[(iPointStart+1)%4].pos, overlayFrag.m_aPrimVerts[iVert].pos, vecTmpUV ); if ( !vecTmpUV.IsValid() ) { mtexinfo_t *pTexInfo = &host_state.worldbrush->texinfo[pOverlay->m_nTexInfo]; DevWarning( 1, "Bad overlay geometry at %s with material '%s'\n", VecToString(pOverlay->m_vecOrigin), ( pTexInfo && pTexInfo->material ) ? pTexInfo->material->GetName() : "" ); return false; } pFragment->m_aPrimVerts[iVert].pos.x = vecTmpUV.x; pFragment->m_aPrimVerts[iVert].pos.y = vecTmpUV.y; pFragment->m_aPrimVerts[iVert].pos.z = 0.0f; } return true; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void COverlayMgr::Disp_PostClipFragment( CDispInfo *pDisp, CMeshReader *pReader, moverlay_t *pOverlay, OverlayFragmentVector_t &aDispFragments, SurfaceHandle_t surfID ) { #ifndef SWDS if ( aDispFragments.Count() == 0 ) return; // Get surface context. SurfaceCtx_t ctx; SurfSetupSurfaceContext( ctx, surfID ); // The faces are not tesselated when they are displaced faces. int iFirstVert = MSurf_FirstVertIndex( surfID ); // Displaced faces are quads. moverlayfragment_t surfaceFrag; surfaceFrag.m_aPrimVerts.SetCount( 4 ); for( int iVert = 0; iVert < 4; ++iVert ) { int iVertex = host_state.worldbrush->vertindices[(iFirstVert+iVert)]; mvertex_t *pVert = &host_state.worldbrush->vertexes[iVertex]; surfaceFrag.m_aPrimVerts[iVert].pos = pVert->position; } Vector2D lightCoords[4]; int nInterval = pDisp->GetSideLength(); pReader->TexCoord2f( 0, DISP_LMCOORDS_STAGE, lightCoords[0].x, lightCoords[0].y ); pReader->TexCoord2f( nInterval - 1, DISP_LMCOORDS_STAGE, lightCoords[1].x, lightCoords[1].y ); pReader->TexCoord2f( ( nInterval * nInterval ) - 1, DISP_LMCOORDS_STAGE, lightCoords[2].x, lightCoords[2].y ); pReader->TexCoord2f( nInterval * ( nInterval - 1 ), DISP_LMCOORDS_STAGE, lightCoords[3].x, lightCoords[3].y ); // Get the number of displacement fragments. int nFragCount = aDispFragments.Count(); for ( int iFrag = 0; iFrag < nFragCount; ++iFrag ) { moverlayfragment_t *pDispFragment = aDispFragments[iFrag]; if ( !pDispFragment ) continue; int nVertCount = pDispFragment->m_aPrimVerts.Count(); if ( nVertCount < 3 ) continue; // Create fragment. OverlayFragmentHandle_t hFragment = AddFragmentToFragmentList( nVertCount ); moverlayfragment_t *pFragment = GetOverlayFragment( hFragment ); pFragment->m_iOverlay = pOverlay->m_nId; pFragment->m_SurfId = surfID; Vector2D vecTmpUV; Vector vecTmp; for ( int iVert = 0; iVert < nVertCount; ++iVert ) { vecTmpUV.x = pDispFragment->m_aPrimVerts[iVert].pos.x; vecTmpUV.y = pDispFragment->m_aPrimVerts[iVert].pos.y; vecTmpUV.x = clamp( vecTmpUV.x, 0.0f, 1.0f ); vecTmpUV.y = clamp( vecTmpUV.y, 0.0f, 1.0f ); Overlay_DispUVToWorld( pDisp, pReader, vecTmpUV, pFragment->m_aPrimVerts[iVert].pos, surfaceFrag ); // Texture coordinates. pFragment->m_aPrimVerts[iVert].texCoord[0] = pDispFragment->m_aPrimVerts[iVert].texCoord[0]; pFragment->m_aPrimVerts[iVert].texCoord[1] = pDispFragment->m_aPrimVerts[iVert].texCoord[1]; // Lightmap coordinates. Vector2D uv; TexCoordInQuadFromBarycentric( lightCoords[0], lightCoords[1], lightCoords[2], lightCoords[3], vecTmpUV, uv ); pFragment->m_aPrimVerts[iVert].lightCoord[0] = uv.x; pFragment->m_aPrimVerts[iVert].lightCoord[1] = uv.y; } // Calculate the normal for this fragment. Vector vecFragmentNormal; Vector vecEdges[2]; VectorSubtract( pFragment->m_aPrimVerts[1].pos, pFragment->m_aPrimVerts[0].pos, vecEdges[0] ); VectorSubtract( pFragment->m_aPrimVerts[2].pos, pFragment->m_aPrimVerts[0].pos, vecEdges[1] ); vecFragmentNormal = CrossProduct( vecEdges[1], vecEdges[0] ); if ( VectorNormalize( vecFragmentNormal ) < 1e-3 ) { vecFragmentNormal.Init( -vecEdges[1].y, vecEdges[1].x, 0.0f ); if ( VectorNormalize( vecFragmentNormal ) < 1e-3 ) { vecFragmentNormal.Init( 0.0f, 0.0f, 1.0f ); } } for ( int iVert = 0; iVert < nVertCount; ++iVert ) { pFragment->m_aPrimVerts[iVert].normal = vecFragmentNormal; } // Create the sort ID for this fragment const MaterialSystem_SortInfo_t &sortInfo = materialSortInfoArray[MSurf_MaterialSortID( surfID )]; mtexinfo_t *pTexInfo = &host_state.worldbrush->texinfo[pOverlay->m_nTexInfo]; pFragment->m_nMaterialSortID = GetMaterialSortID( pTexInfo->material, sortInfo.lightmapPageID ); // Add to list of fragments for this overlay MEM_ALLOC_CREDIT(); OverlayFragmentList_t i = m_OverlayFragments.Alloc( true ); m_OverlayFragments[i] = hFragment; m_OverlayFragments.LinkBefore( pOverlay->m_hFirstFragment, i ); pOverlay->m_hFirstFragment = i; // Add to list of fragments for this surface // NOTE: Store them in *reverse* order so that when we pull them off for // rendering, we can do *that* in reverse order too? Reduces the amount of iteration necessary // Therefore, we need to add to the head of the list m_aFragments.LinkBefore( MSurf_OverlayFragmentList( surfID ), hFragment ); MSurf_OverlayFragmentList( surfID ) = hFragment; } #endif // !SWDS } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void COverlayMgr::Disp_ClipFragment( CDispInfo *pDisp, OverlayFragmentVector_t &aDispFragments ) { cplane_t clipPlane; // Cache the displacement interval. const CPowerInfo *pPowerInfo = pDisp->GetPowerInfo(); int nInterval = ( 1 << pPowerInfo->GetPower() ); // Displacement-space clipping in V. clipPlane.normal.Init( 1.0f, 0.0f, 0.0f ); Disp_DoClip( pDisp, aDispFragments, clipPlane, 1.0f, nInterval, 1, nInterval, 1 ); // Displacement-space clipping in U. clipPlane.normal.Init( 0.0f, 1.0f, 0.0f ); Disp_DoClip( pDisp, aDispFragments, clipPlane, 1.0f, nInterval, 1, nInterval, 1 ); // Displacement-space clipping UV from top-left to bottom-right. clipPlane.normal.Init( 0.707f, 0.707f, 0.0f ); // 45 degrees Disp_DoClip( pDisp, aDispFragments, clipPlane, 0.707f, nInterval, 2, ( nInterval * 2 - 1 ), 2 ); // Displacement-space clipping UV from bottom-left to top-right. clipPlane.normal.Init( -0.707f, 0.707f, 0.0f ); // 135 degrees Disp_DoClip( pDisp, aDispFragments, clipPlane, 0.707f, nInterval, -( nInterval - 2 ), ( nInterval - 1 ), 2 ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void COverlayMgr::Disp_DoClip( CDispInfo *pDisp, OverlayFragmentVector_t &aDispFragments, cplane_t &clipPlane, float clipDistStart, int nInterval, int nLoopStart, int nLoopEnd, int nLoopInc ) { // Setup interval information. float flInterval = static_cast( nInterval ); float flOOInterval = 1.0f / flInterval; // Holds the current set of clipped faces. OverlayFragmentVector_t aClippedFragments; for ( int iInterval = nLoopStart; iInterval < nLoopEnd; iInterval += nLoopInc ) { // Copy the current list to clipped face list. aClippedFragments.CopyArray( aDispFragments.Base(), aDispFragments.Count() ); aDispFragments.Purge(); // Clip in V. int nFragCount = aClippedFragments.Count(); for ( int iFrag = 0; iFrag < nFragCount; iFrag++ ) { moverlayfragment_t *pClipFrag = aClippedFragments[iFrag]; if ( pClipFrag ) { moverlayfragment_t *pFront = NULL, *pBack = NULL; clipPlane.dist = clipDistStart * ( ( float )iInterval * flOOInterval ); DoClipFragment( pClipFrag, &clipPlane, &pFront, &pBack ); DestroyTempFragment( pClipFrag ); pClipFrag = NULL; if ( pFront ) { aDispFragments.AddToTail( pFront ); } if ( pBack ) { aDispFragments.AddToTail( pBack ); } } } } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void COverlayMgr::InitTexCoords( moverlay_t *pOverlay, moverlayfragment_t &overlayFrag ) { // Overlay texture coordinates. overlayFrag.m_aPrimVerts[0].texCoord[0].Init( pOverlay->m_flU[0], pOverlay->m_flV[0] ); overlayFrag.m_aPrimVerts[1].texCoord[0].Init( pOverlay->m_flU[0], pOverlay->m_flV[1] ); overlayFrag.m_aPrimVerts[2].texCoord[0].Init( pOverlay->m_flU[1], pOverlay->m_flV[1] ); overlayFrag.m_aPrimVerts[3].texCoord[0].Init( pOverlay->m_flU[1], pOverlay->m_flV[0] ); overlayFrag.m_aPrimVerts[0].texCoord[1].Init( 0, 0 ); overlayFrag.m_aPrimVerts[1].texCoord[1].Init( 0, 1 ); overlayFrag.m_aPrimVerts[2].texCoord[1].Init( 1, 1 ); overlayFrag.m_aPrimVerts[3].texCoord[1].Init( 1, 0 ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void COverlayMgr::DoClipFragment( moverlayfragment_t *pFragment, cplane_t *pClipPlane, moverlayfragment_t **ppFront, moverlayfragment_t **ppBack ) { const float OVERLAY_EPSILON = 0.0001f; // Verify. if ( !pFragment ) return; float flDists[128] = {}; int nSides[128] = {}; int nSideCounts[3] = {}; // // Determine "sidedness" of all the polygon points. // nSideCounts[0] = nSideCounts[1] = nSideCounts[2] = 0; int iVert = 0; for ( ; iVert < pFragment->m_aPrimVerts.Count(); ++iVert ) { flDists[iVert] = pClipPlane->normal.Dot( pFragment->m_aPrimVerts[iVert].pos ) - pClipPlane->dist; if ( flDists[iVert] > OVERLAY_EPSILON ) { nSides[iVert] = SIDE_FRONT; } else if ( flDists[iVert] < -OVERLAY_EPSILON ) { nSides[iVert] = SIDE_BACK; } else { nSides[iVert] = SIDE_ON; } nSideCounts[nSides[iVert]]++; } // Wrap around (close the polygon). nSides[iVert] = nSides[0]; flDists[iVert] = flDists[0]; // All points in back - no split (copy face to back). if( !nSideCounts[SIDE_FRONT] ) { *ppBack = CopyTempFragment( pFragment ); return; } // All points in front - no split (copy face to front). if( !nSideCounts[SIDE_BACK] ) { *ppFront = CopyTempFragment( pFragment ); return; } // Build new front and back faces. // NOTE: Gotta create them first moverlayfragment_t *pFront = CreateTempFragment( 0 ); moverlayfragment_t *pBack = CreateTempFragment( 0 ); if ( !pFront || !pBack ) { DestroyTempFragment( pFront ); DestroyTempFragment( pBack ); return; } MEM_ALLOC_CREDIT(); int nVertCount = pFragment->m_aPrimVerts.Count(); for ( iVert = 0; iVert < nVertCount; ++iVert ) { // "On" clip plane. if ( nSides[iVert] == SIDE_ON ) { pFront->m_aPrimVerts.AddToTail( pFragment->m_aPrimVerts[iVert] ); pBack->m_aPrimVerts.AddToTail( pFragment->m_aPrimVerts[iVert] ); continue; } // "In back" of clip plane. if ( nSides[iVert] == SIDE_BACK ) { pBack->m_aPrimVerts.AddToTail( pFragment->m_aPrimVerts[iVert] ); } // "In front" of clip plane. if ( nSides[iVert] == SIDE_FRONT ) { pFront->m_aPrimVerts.AddToTail( pFragment->m_aPrimVerts[iVert] ); } if ( nSides[iVert+1] == SIDE_ON || nSides[iVert+1] == nSides[iVert] ) continue; // Split! float fraction = flDists[iVert] / ( flDists[iVert] - flDists[iVert+1] ); overlayvert_t vert; vert.pos = pFragment->m_aPrimVerts[iVert].pos + fraction * ( pFragment->m_aPrimVerts[(iVert+1)%nVertCount].pos - pFragment->m_aPrimVerts[iVert].pos ); for ( int iTexCoord=0; iTexCoord < NUM_OVERLAY_TEXCOORDS; iTexCoord++ ) { vert.texCoord[iTexCoord][0] = pFragment->m_aPrimVerts[iVert].texCoord[iTexCoord][0] + fraction * ( pFragment->m_aPrimVerts[(iVert+1)%nVertCount].texCoord[iTexCoord][0] - pFragment->m_aPrimVerts[iVert].texCoord[iTexCoord][0] ); vert.texCoord[iTexCoord][1] = pFragment->m_aPrimVerts[iVert].texCoord[iTexCoord][1] + fraction * ( pFragment->m_aPrimVerts[(iVert+1)%nVertCount].texCoord[iTexCoord][1] - pFragment->m_aPrimVerts[iVert].texCoord[iTexCoord][1] ); } pFront->m_aPrimVerts.AddToTail( vert ); pBack->m_aPrimVerts.AddToTail( vert ); } *ppFront = pFront; *ppBack = pBack; } //----------------------------------------------------------------------------- // Copies a fragment into the main fragment list //----------------------------------------------------------------------------- OverlayFragmentHandle_t COverlayMgr::AddFragmentToFragmentList( int nSize ) { MEM_ALLOC_CREDIT(); // Add to list of fragments. int iFragment = m_aFragments.Alloc( true ); moverlayfragment_t &frag = m_aFragments[iFragment]; frag.m_SurfId = SURFACE_HANDLE_INVALID; frag.m_iOverlay = -1; frag.m_nRenderFrameID = -1; frag.m_nMaterialSortID = 0xFFFF; frag.m_hNextRender = OVERLAY_FRAGMENT_INVALID; if ( nSize > 0 ) { frag.m_aPrimVerts.SetSize( nSize ); } return iFragment; } //----------------------------------------------------------------------------- // Copies a fragment into the main fragment list //----------------------------------------------------------------------------- OverlayFragmentHandle_t COverlayMgr::AddFragmentToFragmentList( moverlayfragment_t *pSrc ) { MEM_ALLOC_CREDIT(); // Add to list of fragments. int iFragment = m_aFragments.Alloc( true ); moverlayfragment_t &frag = m_aFragments[iFragment]; frag.m_SurfId = pSrc->m_SurfId; frag.m_iOverlay = pSrc->m_iOverlay; frag.m_aPrimVerts.CopyArray( pSrc->m_aPrimVerts.Base(), pSrc->m_aPrimVerts.Count() ); return iFragment; } //----------------------------------------------------------------------------- // Temp fragments for clipping algorithms //----------------------------------------------------------------------------- moverlayfragment_t *COverlayMgr::CreateTempFragment( int nSize ) { MEM_ALLOC_CREDIT(); moverlayfragment_t *pDst = new moverlayfragment_t; if ( pDst ) { pDst->m_SurfId = SURFACE_HANDLE_INVALID; pDst->m_iOverlay = -1; if ( nSize > 0 ) { pDst->m_aPrimVerts.SetSize( nSize ); } } return pDst; } //----------------------------------------------------------------------------- // Temp fragments for clipping algorithms //----------------------------------------------------------------------------- moverlayfragment_t *COverlayMgr::CopyTempFragment( moverlayfragment_t *pSrc ) { MEM_ALLOC_CREDIT(); moverlayfragment_t *pDst = new moverlayfragment_t; if ( pDst ) { pDst->m_SurfId = pSrc->m_SurfId; pDst->m_iOverlay = pSrc->m_iOverlay; pDst->m_aPrimVerts.CopyArray( pSrc->m_aPrimVerts.Base(), pSrc->m_aPrimVerts.Count() ); } return pDst; } //----------------------------------------------------------------------------- // Temp fragments for clipping algorithms //----------------------------------------------------------------------------- void COverlayMgr::DestroyTempFragment( moverlayfragment_t *pFragment ) { if ( pFragment ) { delete pFragment; } } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void COverlayMgr::BuildClipPlanes( SurfaceHandle_t surfID, moverlayfragment_t &surfaceFrag, const Vector &vecBasisNormal, CUtlVector &m_ClipPlanes ) { int nVertCount = surfaceFrag.m_aPrimVerts.Count(); for ( int iVert = 0; iVert < nVertCount; ++iVert ) { Vector vecEdge; vecEdge = surfaceFrag.m_aPrimVerts[(iVert+1)%nVertCount].pos - surfaceFrag.m_aPrimVerts[iVert].pos; VectorNormalize( vecEdge ); int iPlane = m_ClipPlanes.AddToTail(); cplane_t *pPlane = &m_ClipPlanes[iPlane]; pPlane->normal = vecBasisNormal.Cross( vecEdge ); pPlane->dist = pPlane->normal.Dot( surfaceFrag.m_aPrimVerts[iVert].pos ); pPlane->type = 3; // Check normal facing. float flDistance = pPlane->normal.Dot( surfaceFrag.m_aPrimVerts[(iVert+2)%nVertCount].pos ) - pPlane->dist; if ( flDistance > 0.0 ) { // Flip pPlane->normal.Negate(); pPlane->dist = -pPlane->dist; } } } //============================================================================= // // Code below this line will get moved out into common code!!!!!!!!!!!!! // //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void Overlay_BuildBasisOrigin( Vector &vecBasisOrigin, SurfaceHandle_t surfID ) { cplane_t surfacePlane = MSurf_Plane( surfID ); VectorNormalize( surfacePlane.normal ); // Get the distance from entity origin to face plane. float flDist = surfacePlane.normal.Dot( vecBasisOrigin ) - surfacePlane.dist; // Move the basis origin to the position of the entity projected into the face plane. vecBasisOrigin = vecBasisOrigin - ( flDist * surfacePlane.normal ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool Overlay_IsBasisFlipped( int *pFlip, int iAxis, int iComponent ) { if ( iAxis < 0 || iAxis > 2 || iComponent < 0 || iComponent > 2 ) return false; int nValue = ( 1 << iComponent ); return ( ( pFlip[iAxis] & nValue ) != 0 ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void Overlay_BuildBasis( const Vector &vecBasisNormal, Vector &vecBasisU, Vector &vecBasisV, bool bFlip ) { // Verify incoming data. Assert( vecBasisNormal.IsValid() ); if ( !vecBasisNormal.IsValid() ) return; vecBasisV = vecBasisNormal.Cross( vecBasisU ); if ( bFlip ) { vecBasisV.Negate(); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void Overlay_TriTLToBR( CDispInfo *pDisp, CMeshReader *pReader, Vector &vecWorld, float flU, float flV, int nWidth, const Vector &vecIntersectPoint ) { const float TRIEDGE_EPSILON = 0.000001f; int nHeight = nWidth; int nSnapU = static_cast( flU ); int nSnapV = static_cast( flV ); int nNextU = nSnapU + 1; int nNextV = nSnapV + 1; if ( nNextU == nWidth) { --nNextU; } if ( nNextV == nHeight ) { --nNextV; } float flFracU = flU - static_cast( nSnapU ); float flFracV = flV - static_cast( nSnapV ); Vector vecVerts[3], vecFlatVerts[3]; if( ( flFracU + flFracV ) >= ( 1.0f + TRIEDGE_EPSILON ) ) { int nIndices[3]; nIndices[0] = nNextV * nWidth + nSnapU; nIndices[1] = nNextV * nWidth + nNextU; nIndices[2] = nSnapV * nWidth + nNextU; for( int iVert = 0; iVert < 3; ++iVert ) { vecVerts[iVert] = GetOverlayPos( pReader, nIndices[iVert] ); vecFlatVerts[iVert] = pDisp->GetFlatVert( nIndices[iVert] ); } if ( nSnapU == nNextU ) { if ( nSnapV == nNextV ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else if ( nSnapV == nNextV ) { if ( nSnapU == nNextU ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else { float flCfs[3]; if ( CalcBarycentricCooefs( vecFlatVerts[0], vecFlatVerts[1], vecFlatVerts[2], vecIntersectPoint, flCfs[0], flCfs[1], flCfs[2] ) ) { vecWorld = ( vecVerts[0] * flCfs[0] ) + ( vecVerts[1] * flCfs[1] ) + ( vecVerts[2] * flCfs[2] ); } else { nIndices[0] = nSnapV * nWidth + nSnapU; nIndices[1] = nNextV * nWidth + nSnapU; nIndices[2] = nSnapV * nWidth + nNextU; for( int iVert = 0; iVert < 3; ++iVert ) { vecVerts[iVert] = GetOverlayPos( pReader, nIndices[iVert] ); vecFlatVerts[iVert] = pDisp->GetFlatVert( nIndices[iVert] ); } if ( nSnapU == nNextU ) { if ( nSnapV == nNextV ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[1] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[1] - vecVerts[0] ) ); } } else if ( nSnapV == nNextV ) { if ( nSnapU == nNextU ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else { CalcBarycentricCooefs( vecFlatVerts[0], vecFlatVerts[1], vecFlatVerts[2], vecIntersectPoint, flCfs[0], flCfs[1], flCfs[2] ); vecWorld = ( vecVerts[0] * flCfs[0] ) + ( vecVerts[1] * flCfs[1] ) + ( vecVerts[2] * flCfs[2] ); } } } } else { int nIndices[3]; nIndices[0] = nSnapV * nWidth + nSnapU; nIndices[1] = nNextV * nWidth + nSnapU; nIndices[2] = nSnapV * nWidth + nNextU; for( int iVert = 0; iVert < 3; ++iVert ) { vecVerts[iVert] = GetOverlayPos( pReader, nIndices[iVert] ); vecFlatVerts[iVert] = pDisp->GetFlatVert( nIndices[iVert] ); } if ( nSnapU == nNextU ) { if ( nSnapV == nNextV ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[1] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[1] - vecVerts[0] ) ); } } else if ( nSnapV == nNextV ) { if ( nSnapU == nNextU ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else { float flCfs[3]; if ( CalcBarycentricCooefs( vecFlatVerts[0], vecFlatVerts[1], vecFlatVerts[2], vecIntersectPoint, flCfs[0], flCfs[1], flCfs[2] ) ) { vecWorld = ( vecVerts[0] * flCfs[0] ) + ( vecVerts[1] * flCfs[1] ) + ( vecVerts[2] * flCfs[2] ); } else { nIndices[0] = nNextV * nWidth + nSnapU; nIndices[1] = nNextV * nWidth + nNextU; nIndices[2] = nSnapV * nWidth + nNextU; for( int iVert = 0; iVert < 3; ++iVert ) { vecVerts[iVert] = GetOverlayPos( pReader, nIndices[iVert] ); vecFlatVerts[iVert] = pDisp->GetFlatVert( nIndices[iVert] ); } if ( nSnapU == nNextU ) { if ( nSnapV == nNextV ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else if ( nSnapV == nNextV ) { if ( nSnapU == nNextU ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else { CalcBarycentricCooefs( vecFlatVerts[0], vecFlatVerts[1], vecFlatVerts[2], vecIntersectPoint, flCfs[0], flCfs[1], flCfs[2] ); vecWorld = ( vecVerts[0] * flCfs[0] ) + ( vecVerts[1] * flCfs[1] ) + ( vecVerts[2] * flCfs[2] ); } } } } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void Overlay_TriBLToTR( CDispInfo *pDisp, CMeshReader *pReader, Vector &vecWorld, float flU, float flV, int nWidth, const Vector &vecIntersectPoint ) { int nHeight = nWidth; int nSnapU = static_cast( flU ); int nSnapV = static_cast( flV ); int nNextU = nSnapU + 1; int nNextV = nSnapV + 1; if ( nNextU == nWidth) { --nNextU; } if ( nNextV == nHeight ) { --nNextV; } float flFracU = flU - static_cast( nSnapU ); float flFracV = flV - static_cast( nSnapV ); // The fractions are not correct all the time - but they are a good first guess! Vector vecVerts[3], vecFlatVerts[3]; if( flFracU < flFracV ) { int nIndices[3]; nIndices[0] = nSnapV * nWidth + nSnapU; nIndices[1] = nNextV * nWidth + nSnapU; nIndices[2] = nNextV * nWidth + nNextU; for( int iVert = 0; iVert < 3; ++iVert ) { vecVerts[iVert] = GetOverlayPos( pReader, nIndices[iVert] ); vecFlatVerts[iVert] = pDisp->GetFlatVert( nIndices[iVert] ); } if ( nSnapU == nNextU ) { if ( nSnapV == nNextV ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else if ( nSnapV == nNextV ) { if ( nSnapU == nNextU ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else { float flCfs[3]; if ( CalcBarycentricCooefs( vecFlatVerts[0], vecFlatVerts[1], vecFlatVerts[2], vecIntersectPoint, flCfs[0], flCfs[1], flCfs[2] ) ) { vecWorld = ( vecVerts[0] * flCfs[0] ) + ( vecVerts[1] * flCfs[1] ) + ( vecVerts[2] * flCfs[2] ); } else { nIndices[0] = nSnapV * nWidth + nSnapU; nIndices[1] = nNextV * nWidth + nNextU; nIndices[2] = nSnapV * nWidth + nNextU; for( int iVert = 0; iVert < 3; ++iVert ) { vecVerts[iVert] = GetOverlayPos( pReader, nIndices[iVert] ); vecFlatVerts[iVert] = pDisp->GetFlatVert( nIndices[iVert] ); } if ( nSnapU == nNextU ) { if ( nSnapV == nNextV ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[1] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[1] - vecVerts[0] ) ); } } else if ( nSnapV == nNextV ) { if ( nSnapU == nNextU ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else { CalcBarycentricCooefs( vecFlatVerts[0], vecFlatVerts[1], vecFlatVerts[2], vecIntersectPoint, flCfs[0], flCfs[1], flCfs[2] ); vecWorld = ( vecVerts[0] * flCfs[0] ) + ( vecVerts[1] * flCfs[1] ) + ( vecVerts[2] * flCfs[2] ); } } } } else { int nIndices[3]; nIndices[0] = nSnapV * nWidth + nSnapU; nIndices[1] = nNextV * nWidth + nNextU; nIndices[2] = nSnapV * nWidth + nNextU; for( int iVert = 0; iVert < 3; ++iVert ) { vecVerts[iVert] = GetOverlayPos( pReader, nIndices[iVert] ); vecFlatVerts[iVert] = pDisp->GetFlatVert( nIndices[iVert] ); } if ( nSnapU == nNextU ) { if ( nSnapV == nNextV ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[1] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[1] - vecVerts[0] ) ); } } else if ( nSnapV == nNextV ) { if ( nSnapU == nNextU ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else { float flCfs[3]; if ( CalcBarycentricCooefs( vecFlatVerts[0], vecFlatVerts[1], vecFlatVerts[2], vecIntersectPoint, flCfs[0], flCfs[1], flCfs[2] ) ) { vecWorld = ( vecVerts[0] * flCfs[0] ) + ( vecVerts[1] * flCfs[1] ) + ( vecVerts[2] * flCfs[2] ); } else { nIndices[0] = nSnapV * nWidth + nSnapU; nIndices[1] = nNextV * nWidth + nSnapU; nIndices[2] = nNextV * nWidth + nNextU; for( int iVert = 0; iVert < 3; ++iVert ) { vecVerts[iVert] = GetOverlayPos( pReader, nIndices[iVert] ); vecFlatVerts[iVert] = pDisp->GetFlatVert( nIndices[iVert] ); } if ( nSnapU == nNextU ) { if ( nSnapV == nNextV ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else if ( nSnapV == nNextV ) { if ( nSnapU == nNextU ) { vecWorld = vecVerts[0]; } else { float flFrac = ( vecIntersectPoint - vecFlatVerts[0] ).Length() / ( vecFlatVerts[2] - vecFlatVerts[0] ).Length(); vecWorld = vecVerts[0] + ( flFrac * ( vecVerts[2] - vecVerts[0] ) ); } } else { CalcBarycentricCooefs( vecFlatVerts[0], vecFlatVerts[1], vecFlatVerts[2], vecIntersectPoint, flCfs[0], flCfs[1], flCfs[2] ); vecWorld = ( vecVerts[0] * flCfs[0] ) + ( vecVerts[1] * flCfs[1] ) + ( vecVerts[2] * flCfs[2] ); } } } } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void Overlay_DispUVToWorld( CDispInfo *pDisp, CMeshReader *pReader, const Vector2D &vecUV, Vector &vecWorld, moverlayfragment_t &surfaceFrag ) { // Get the displacement power. const CPowerInfo *pPowerInfo = pDisp->GetPowerInfo(); int nWidth = ( ( 1 << pPowerInfo->GetPower() ) + 1 ); int nHeight = nWidth; Vector vecIntersectPoint; PointInQuadFromBarycentric( surfaceFrag.m_aPrimVerts[(0+pDisp->m_iPointStart)%4].pos, surfaceFrag.m_aPrimVerts[(3+pDisp->m_iPointStart)%4].pos, surfaceFrag.m_aPrimVerts[(2+pDisp->m_iPointStart)%4].pos, surfaceFrag.m_aPrimVerts[(1+pDisp->m_iPointStart)%4].pos, vecUV, vecIntersectPoint ); // Scale the U, V coordinates to the displacement grid size. float flU = vecUV.x * static_cast( nWidth - 1.000001f ); float flV = vecUV.y * static_cast( nHeight - 1.000001f ); // Find the base U, V. int nSnapU = static_cast( flU ); int nSnapV = static_cast( flV ); // Use this to get the triangle orientation. bool bOdd = ( ( ( nSnapV * nWidth ) + nSnapU ) % 2 == 1 ); // Top Left to Bottom Right if( bOdd ) { Overlay_TriTLToBR( pDisp, pReader, vecWorld, flU, flV, nWidth, vecIntersectPoint ); } // Bottom Left to Top Right else { Overlay_TriBLToTR( pDisp, pReader, vecWorld, flU, flV, nWidth, vecIntersectPoint ); } } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void Overlay_OverlayUVToOverlayPlane( const Vector &vecBasisOrigin, const Vector &vecBasisU, const Vector &vecBasisV, const Vector &vecUVPoint, Vector &vecPlanePoint ) { vecPlanePoint = ( vecUVPoint.x * vecBasisU ) + ( vecUVPoint.y * vecBasisV ); vecPlanePoint += vecBasisOrigin; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void Overlay_WorldToOverlayPlane( const Vector &vecBasisOrigin, const Vector &vecBasisNormal, const Vector &vecWorldPoint, Vector &vecPlanePoint ) { Vector vecDelta = vecWorldPoint - vecBasisOrigin; float flDistance = vecBasisNormal.Dot( vecDelta ); vecPlanePoint = vecWorldPoint - ( flDistance * vecBasisNormal ); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void Overlay_OverlayPlaneToWorld( const Vector &vecBasisNormal, SurfaceHandle_t surfID, const Vector &vecPlanePoint, Vector &vecWorldPoint ) { cplane_t surfacePlane = MSurf_Plane( surfID ); VectorNormalize( surfacePlane.normal ); float flDistanceToSurface = surfacePlane.normal.Dot( vecPlanePoint ) - surfacePlane.dist; float flDenom = surfacePlane.normal.Dot( vecBasisNormal ); float flDistance; if( flDenom != 0.0f ) { flDistance = ( 1.0f / flDenom ) * flDistanceToSurface; } else { flDistance = flDistanceToSurface; } vecWorldPoint = vecPlanePoint - ( vecBasisNormal * flDistance ); }