1HEADmaster

1 files changed, 1469 insertions, 0 deletions

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