1HEADmaster

1 files changed, 2358 insertions, 0 deletions

diff --git a/engine/Overlay.cpp b/engine/Overlay.cpp
new file mode 100644
index 0000000..8842bc8
--- /dev/null
+++ b/engine/Overlay.cpp
@@ -0,0 +1,2358 @@
+//========= 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<overlayvert_t>	m_aPrimVerts;
+};
+
+struct moverlay_t
+{
+	int				m_nId;
+	short			m_nTexInfo;
+	short			m_nRenderOrder;	// 0 - MAX_OVERLAY_RENDER_ORDERS
+	OverlayFragmentList_t m_hFirstFragment;
+	CUtlVector<SurfaceHandle_t>	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<moverlayfragment_t*> 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<cplane_t> &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<RenderQueueHead_t, unsigned short> m_RenderQueue;
+
+	// All overlays
+	CUtlVector<moverlay_t> 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<int,256> 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<cplane_t> 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<CDispInfo*>( 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<CDispInfo*>( 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<float>( 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<cplane_t> &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<int>( flU );
+	int nSnapV = static_cast<int>( flV );
+	int nNextU = nSnapU + 1;
+	int nNextV = nSnapV + 1;
+	if ( nNextU == nWidth)	 { --nNextU; }
+	if ( nNextV == nHeight ) { --nNextV; }
+
+	float flFracU = flU - static_cast<float>( nSnapU );
+	float flFracV = flV - static_cast<float>( 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<int>( flU );
+	int nSnapV = static_cast<int>( flV );
+	int nNextU = nSnapU + 1;
+	int nNextV = nSnapV + 1;
+	if ( nNextU == nWidth)	 { --nNextU; }
+	if ( nNextV == nHeight ) { --nNextV; }
+
+	float flFracU = flU - static_cast<float>( nSnapU );
+	float flFracV = flV - static_cast<float>( 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<float>( nWidth - 1.000001f );
+	float flV = vecUV.y * static_cast<float>( nHeight - 1.000001f );
+
+	// Find the base U, V.
+	int nSnapU = static_cast<int>( flU );
+	int nSnapV = static_cast<int>( 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 );
+}