tf2/tf2_src/engine/disp_interface.cpp

//========= 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
}