tf2/tf2_src/engine/gl_rsurf.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//===========================================================================//


#include "render_pch.h"
#include "client.h"
#include "gl_model_private.h"
#include "gl_water.h"
#include "gl_cvars.h"
#include "zone.h"
#include "decal.h"
#include "decal_private.h"
#include "gl_lightmap.h"
#include "r_local.h"
#include "gl_matsysiface.h"
#include "gl_rsurf.h"
#include "materialsystem/imesh.h"
#include "materialsystem/ivballoctracker.h"
#include "tier2/tier2.h"
#include "collisionutils.h"
#include "cdll_int.h"
#include "utllinkedlist.h"
#include "r_areaportal.h"
#include "bsptreedata.h"
#include "cmodel_private.h"
#include "tier0/dbg.h"
#include "crtmemdebug.h"
#include "iclientrenderable.h"
#include "icliententitylist.h"
#include "icliententity.h"
#include "gl_rmain.h"
#include "tier0/vprof.h"
#include "bitvec.h"
#include "debugoverlay.h"
#include "host.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "cl_main.h"
#include "cmodel_engine.h"
#include "r_decal.h"
#include "materialsystem/materialsystem_config.h"
#include "materialsystem/imaterialproxy.h"
#include "materialsystem/imaterialvar.h"
#include "coordsize.h"
#include "mempool.h"
#ifndef SWDS
#include "Overlay.h"
#endif

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#define BACKFACE_EPSILON	-0.01f

#define BRUSHMODEL_DECAL_SORT_GROUP		MAX_MAT_SORT_GROUPS
const int MAX_VERTEX_FORMAT_CHANGES = 128;
int g_MaxLeavesVisible = 512;

//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------

class IClientEntity;

// interface to shader drawing
void Shader_BrushBegin( model_t *model, IClientEntity *baseentity = NULL );
void Shader_BrushSurface( SurfaceHandle_t surfID, model_t *model, IClientEntity *baseentity = NULL );
void Shader_BrushEnd( IMatRenderContext *pRenderContext, VMatrix const* brushToWorld, model_t *model, bool bShadowDepth, IClientEntity *baseentity = NULL );
#ifdef NEWMESH
void BuildMSurfaceVertexArrays( worldbrushdata_t *pBrushData, SurfaceHandle_t surfID, float overbright, CVertexBufferBuilder &builder );
#else
void BuildMSurfaceVertexArrays( worldbrushdata_t *pBrushData, SurfaceHandle_t surfID, float overbright, CMeshBuilder &builder );
#endif

//-----------------------------------------------------------------------------
// Information about the fog volumes for this pass of rendering
//-----------------------------------------------------------------------------

struct FogState_t
{
	MaterialFogMode_t m_FogMode;
	float m_FogStart;
	float m_FogEnd;
	float m_FogColor[3];
	bool m_FogEnabled;
};

struct FogVolumeInfo_t : public FogState_t
{
	bool	m_InFogVolume;
	float	m_FogSurfaceZ;
	float	m_FogMinZ;
	int		m_FogVolumeID;
};

//-----------------------------------------------------------------------------
// Cached convars...
//-----------------------------------------------------------------------------
struct CachedConvars_t
{
	bool	m_bDrawWorld;
	int		m_nDrawLeaf;
	bool	m_bDrawFuncDetail;
};


static CachedConvars_t s_ShaderConvars;

// AR - moved so SWDS can access these vars
Frustum_t g_Frustum;


//-----------------------------------------------------------------------------
// Convars
//-----------------------------------------------------------------------------
static ConVar r_drawtranslucentworld( "r_drawtranslucentworld", "1", FCVAR_CHEAT );
static ConVar mat_forcedynamic( "mat_forcedynamic", "0", FCVAR_CHEAT );
static ConVar r_drawleaf( "r_drawleaf", "-1", FCVAR_CHEAT, "Draw the specified leaf." );
static ConVar r_drawworld( "r_drawworld", "1", FCVAR_CHEAT, "Render the world." );
static ConVar r_drawfuncdetail( "r_drawfuncdetail", "1", FCVAR_CHEAT, "Render func_detail" );
static ConVar fog_enable_water_fog( "fog_enable_water_fog", "1", FCVAR_CHEAT );
static ConVar r_fastzreject( "r_fastzreject", "0", FCVAR_ALLOWED_IN_COMPETITIVE, "Activate/deactivates a fast z-setting algorithm to take advantage of hardware with fast z reject. Use -1 to default to hardware settings" );
static ConVar r_fastzrejectdisp( "r_fastzrejectdisp", "0", 0, "Activates/deactivates fast z rejection on displacements (360 only). Only active when r_fastzreject is on." );


//-----------------------------------------------------------------------------
// Installs a client-side renderer for brush models
//-----------------------------------------------------------------------------
static IBrushRenderer* s_pBrushRenderOverride = 0;

//-----------------------------------------------------------------------------
// Make sure we don't render the same surfaces twice
//-----------------------------------------------------------------------------
int	r_surfacevisframe = 0;
#define r_surfacevisframe dont_use_r_surfacevisframe_here


//-----------------------------------------------------------------------------
// Fast z reject displacements?
//-----------------------------------------------------------------------------
static bool s_bFastZRejectDisplacements = false;

//-----------------------------------------------------------------------------
// Top view bounds
//-----------------------------------------------------------------------------
static bool r_drawtopview = false;
static Vector2D s_OrthographicCenter;
static Vector2D s_OrthographicHalfDiagonal;

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
typedef CVarBitVec CVisitedSurfs;


//-----------------------------------------------------------------------------
// Returns planes in brush models
//-----------------------------------------------------------------------------
int R_GetBrushModelPlaneCount( const model_t *model )
{
	return model->brush.nummodelsurfaces;
}

const cplane_t &R_GetBrushModelPlane( const model_t *model, int nIndex, Vector *pOrigin )
{
	SurfaceHandle_t surfID = SurfaceHandleFromIndex( model->brush.firstmodelsurface, model->brush.pShared );
	surfID += nIndex;
	Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );

	if ( pOrigin )
	{
		int vertCount = MSurf_VertCount( surfID );
		if ( vertCount > 0 )
		{
			int nFirstVertex = model->brush.pShared->vertindices[MSurf_FirstVertIndex( surfID )];
			*pOrigin = model->brush.pShared->vertexes[nFirstVertex].position;
		}
		else
		{
			const cplane_t &plane = MSurf_Plane( surfID );
			VectorMultiply( plane.normal, plane.dist, *pOrigin );
		}
	}

	return MSurf_Plane( surfID );
}

//-----------------------------------------------------------------------------
// Computes the centroid of a surface
//-----------------------------------------------------------------------------
void Surf_ComputeCentroid( SurfaceHandle_t surfID, Vector *pVecCentroid )
{
	int nCount = MSurf_VertCount( surfID );
	int nFirstVertIndex = MSurf_FirstVertIndex( surfID );

	float flTotalArea = 0.0f;
	Vector vecNormal;
	pVecCentroid->Init(0,0,0);
	int vertIndex = host_state.worldbrush->vertindices[nFirstVertIndex];
	Vector vecApex = host_state.worldbrush->vertexes[vertIndex].position;
	for (int v = 1; v < nCount - 1; ++v )
	{
		vertIndex = host_state.worldbrush->vertindices[nFirstVertIndex+v];
		Vector v1 = host_state.worldbrush->vertexes[vertIndex].position;
		vertIndex = host_state.worldbrush->vertindices[nFirstVertIndex+v+1];
		Vector v2 = host_state.worldbrush->vertexes[vertIndex].position;
		CrossProduct( v2 - v1, v1 - vecApex, vecNormal );
		float flArea = vecNormal.Length();
		flTotalArea += flArea;
		*pVecCentroid += (vecApex + v1 + v2) * flArea / 3.0f;
	}

	if (flTotalArea)
	{
		*pVecCentroid /= flTotalArea;
	}
}

//-----------------------------------------------------------------------------
// Converts sort infos to lightmap pages
//-----------------------------------------------------------------------------
int SortInfoToLightmapPage( int sortID )
{
        return materialSortInfoArray[sortID].lightmapPageID;
}



#ifndef SWDS

class CWorldRenderList : public CRefCounted1<IWorldRenderList>
{
public:
	CWorldRenderList()
	{
	}

	~CWorldRenderList()
	{
		Purge();
	}

	static CWorldRenderList *FindOrCreateList( int nSurfaces )
	{
		CWorldRenderList *p = g_Pool.GetObject();
		if ( p->m_VisitedSurfs.GetNumBits() == 0 )
		{
			p->Init( nSurfaces );
		}
		else
		{
			p->AddRef();
		}

		AssertMsg( p->m_VisitedSurfs.GetNumBits() == nSurfaces, "World render list pool not cleared between maps" );

		return p;
	}

	static void PurgeAll()
	{
		CWorldRenderList *p;
		while ( ( p = g_Pool.GetObject( false ) ) != NULL )
		{
			p->Purge();
			delete p;
		}
	}

	virtual bool OnFinalRelease()
	{
		Reset();
		g_Pool.PutObject( this );
		return false;
	}

	void Init( int nSurfaces )
	{
		m_SortList.Init(materials->GetNumSortIDs(), 512);
		m_AlphaSortList.Init( g_MaxLeavesVisible, 64 );
		m_DispSortList.Init(materials->GetNumSortIDs(), 32);
		m_DispAlphaSortList.Init( g_MaxLeavesVisible, 32 );
		m_VisitedSurfs.Resize( nSurfaces );
		m_bSkyVisible = false;
	}

	void Purge()
	{
		g_MaxLeavesVisible = max(g_MaxLeavesVisible,m_VisibleLeaves.Count());

		m_VisibleLeaves.Purge();
		m_VisibleLeafFogVolumes.Purge();
		for ( int i = 0; i < MAX_MAT_SORT_GROUPS; i++ )
		{
			m_ShadowHandles[i].Purge();
			m_DlightSurfaces[i].Purge();
		}
		m_SortList.Shutdown();
		m_AlphaSortList.Shutdown();
		m_DispSortList.Shutdown();
		m_DispAlphaSortList.Shutdown();
	}

	void Reset()
	{
		g_MaxLeavesVisible = max(g_MaxLeavesVisible,m_VisibleLeaves.Count());
		m_SortList.Reset();
		m_AlphaSortList.Reset();
		m_DispSortList.Reset();
		m_DispAlphaSortList.Reset();

		m_bSkyVisible = false;
		for (int j = 0; j < MAX_MAT_SORT_GROUPS; ++j)
		{
			//Assert(pRenderList->m_ShadowHandles[j].Count() == 0 );
			m_ShadowHandles[j].RemoveAll();
			m_DlightSurfaces[j].RemoveAll();
		}

		// We haven't found any visible leafs this frame
		m_VisibleLeaves.RemoveAll();
		m_VisibleLeafFogVolumes.RemoveAll();

		m_VisitedSurfs.ClearAll();
	}

	CMSurfaceSortList m_SortList;
	CMSurfaceSortList m_DispSortList;
	CMSurfaceSortList m_AlphaSortList;
	CMSurfaceSortList m_DispAlphaSortList;

	//-------------------------------------------------------------------------
	// List of decals to render this frame (need an extra one for brush models)
	//-------------------------------------------------------------------------
	CUtlVector<ShadowDecalHandle_t> m_ShadowHandles[MAX_MAT_SORT_GROUPS];
	
	// list of surfaces with dynamic lightmaps
	CUtlVector<SurfaceHandle_t>	m_DlightSurfaces[MAX_MAT_SORT_GROUPS];

	//-------------------------------------------------------------------------
	// Used to generate a list of the leaves visited, and in back-to-front order
	// for this frame of rendering
	//-------------------------------------------------------------------------
	CUtlVector<LeafIndex_t>		m_VisibleLeaves;
	CUtlVector<LeafFogVolume_t>	m_VisibleLeafFogVolumes;

	CVisitedSurfs m_VisitedSurfs;
	bool						m_bSkyVisible;

	static CObjectPool<CWorldRenderList> g_Pool;
};

CObjectPool<CWorldRenderList> CWorldRenderList::g_Pool;

IWorldRenderList *AllocWorldRenderList()
{
	return CWorldRenderList::FindOrCreateList( host_state.worldbrush->numsurfaces );
}


FORCEINLINE bool VisitSurface( CVisitedSurfs &visitedSurfs, SurfaceHandle_t surfID )
{
	return !visitedSurfs.TestAndSet( MSurf_Index( surfID ) );
}

FORCEINLINE void MarkSurfaceVisited( CVisitedSurfs &visitedSurfs, SurfaceHandle_t surfID )
{
	visitedSurfs.Set( MSurf_Index( surfID ) );
}

FORCEINLINE bool VisitedSurface( CVisitedSurfs &visitedSurfs, SurfaceHandle_t surfID )
{
	return visitedSurfs.IsBitSet( MSurf_Index( surfID ) );
}

FORCEINLINE bool VisitedSurface( CVisitedSurfs &visitedSurfs, int index )
{
	return visitedSurfs.IsBitSet( index );
}

//-----------------------------------------------------------------------------
// Activates top view
//-----------------------------------------------------------------------------

void R_DrawTopView( bool enable )
{
	r_drawtopview = enable;
}

void R_TopViewBounds( Vector2D const& mins, Vector2D const& maxs )
{
	Vector2DAdd( maxs, mins, s_OrthographicCenter );
	s_OrthographicCenter *= 0.5f;
	Vector2DSubtract( maxs, s_OrthographicCenter, s_OrthographicHalfDiagonal );
}

#define MOVE_DLIGHTS_TO_NEW_TEXTURE 0

#if MOVE_DLIGHTS_TO_NEW_TEXTURE
bool DlightSurfaceSetQueuingFlag(SurfaceHandle_t surfID)
{
	if ( MSurf_Flags( surfID ) & SURFDRAW_HASLIGHTSYTLES )
	{
		msurfacelighting_t *pLighting = SurfaceLighting(surfID);
		for( int maps = 1; maps < MAXLIGHTMAPS && pLighting->m_nStyles[maps] != 255; maps++ )
		{
			if( d_lightstylenumframes[pLighting->m_nStyles[maps]] != 1 )
			{
				MSurf_Flags( surfID ) |= SURFDRAW_DLIGHTPASS;
				return true;
			}
		}

		return false;
	}

	MSurf_Flags( surfID ) |= SURFDRAW_DLIGHTPASS;
	return true;
}
#else
bool DlightSurfaceSetQueuingFlag(SurfaceHandle_t surfID) { return false; }
#endif




//-----------------------------------------------------------------------------
// Adds surfaces to list of things to render
//-----------------------------------------------------------------------------
void Shader_TranslucentWorldSurface( CWorldRenderList *pRenderList, SurfaceHandle_t surfID )
{
	Assert( !SurfaceHasDispInfo( surfID ) && (pRenderList->m_VisibleLeaves.Count() > 0) );

	// Hook into the chain of translucent objects for this leaf
	int sortGroup = MSurf_SortGroup( surfID );
	pRenderList->m_AlphaSortList.AddSurfaceToTail( surfID, sortGroup, pRenderList->m_VisibleLeaves.Count()-1 );
	if ( MSurf_Flags( surfID ) & (SURFDRAW_HASLIGHTSYTLES|SURFDRAW_HASDLIGHT) )
	{
		pRenderList->m_DlightSurfaces[sortGroup].AddToTail( surfID );
		
		DlightSurfaceSetQueuingFlag(surfID);
	}
}

inline void Shader_WorldSurface( CWorldRenderList *pRenderList, SurfaceHandle_t surfID )
{
	// Hook it into the list of surfaces to render with this material
	// Do it in a way that generates a front-to-back ordering for fast z reject
	Assert( !SurfaceHasDispInfo( surfID ) );

	// Each surface is in exactly one group
	int nSortGroup = MSurf_SortGroup( surfID );

	// Add decals on non-displacement surfaces
	if( SurfaceHasDecals( surfID ) )
	{
		DecalSurfaceAdd( surfID, nSortGroup );
	}

	int nMaterialSortID = MSurf_MaterialSortID( surfID );

	if ( MSurf_Flags( surfID ) & (SURFDRAW_HASLIGHTSYTLES|SURFDRAW_HASDLIGHT) )
	{
		pRenderList->m_DlightSurfaces[nSortGroup].AddToTail( surfID );
		if ( !DlightSurfaceSetQueuingFlag(surfID) )
		{
			pRenderList->m_SortList.AddSurfaceToTail( surfID, nSortGroup, nMaterialSortID );
		}
	}
	else
	{
		pRenderList->m_SortList.AddSurfaceToTail( surfID, nSortGroup, nMaterialSortID );
	}
}

// The NoCull flavor of this function optimizes for shadow depth map rendering
// No decal work, dlights or material sorting, for example
inline void Shader_WorldSurfaceNoCull( CWorldRenderList *pRenderList, SurfaceHandle_t surfID )
{
	// Hook it into the list of surfaces to render with this material
	// Do it in a way that generates a front-to-back ordering for fast z reject
	Assert( !SurfaceHasDispInfo( surfID ) );

	// Each surface is in exactly one group
	int nSortGroup = MSurf_SortGroup( surfID );

	int nMaterialSortID = MSurf_MaterialSortID( surfID );
	pRenderList->m_SortList.AddSurfaceToTail( surfID, nSortGroup, nMaterialSortID );
}


//-----------------------------------------------------------------------------
// Adds displacement surfaces to list of things to render
//-----------------------------------------------------------------------------
void Shader_TranslucentDisplacementSurface( CWorldRenderList *pRenderList, SurfaceHandle_t surfID )
{
	Assert( SurfaceHasDispInfo( surfID ) && (pRenderList->m_VisibleLeaves.Count() > 0));

	// For translucent displacement surfaces, they can exist in many
	// leaves. We want to choose the leaf that's closest to the camera
	// to render it in. Thankfully, we're iterating the tree in front-to-back
	// order, so this is very simple.

	// NOTE: You might expect some problems here when displacements cross fog volume 
	// planes. However, these problems go away (I hope!) because the first planes
	// that split a scene are the fog volume planes. That means that if we're
	// in a fog volume, the closest leaf that the displacement will be in will
	// also be in the fog volume. If we're not in a fog volume, the closest
	// leaf that the displacement will be in will not be a fog volume. That should
	// hopefully hide any discontinuities between fog state that occur when 
	// rendering displacements that straddle fog volume boundaries.

	// Each surface is in exactly one group
	int sortGroup = MSurf_SortGroup( surfID );
	if ( MSurf_Flags( surfID ) & (SURFDRAW_HASLIGHTSYTLES|SURFDRAW_HASDLIGHT) )
	{
		pRenderList->m_DlightSurfaces[sortGroup].AddToTail( surfID );
		if ( !DlightSurfaceSetQueuingFlag(surfID) )
		{
			pRenderList->m_DispAlphaSortList.AddSurfaceToTail(surfID, sortGroup, pRenderList->m_VisibleLeaves.Count()-1);
		}
	}
	else
	{
		pRenderList->m_DispAlphaSortList.AddSurfaceToTail(surfID, sortGroup, pRenderList->m_VisibleLeaves.Count()-1);
	}
}

void Shader_DisplacementSurface( CWorldRenderList *pRenderList, SurfaceHandle_t surfID )
{
	Assert( SurfaceHasDispInfo( surfID ) );

	// For opaque displacement surfaces, we're going to build a temporary list of 
	// displacement surfaces in each material bucket, and then add those to
	// the actual displacement lists in a separate pass.
	// We do this to sort the displacement surfaces by material

	// Each surface is in exactly one group
	int nSortGroup = MSurf_SortGroup( surfID );
	int nMaterialSortID = MSurf_MaterialSortID( surfID );
	if ( MSurf_Flags( surfID ) & (SURFDRAW_HASLIGHTSYTLES|SURFDRAW_HASDLIGHT) )
	{
		pRenderList->m_DlightSurfaces[nSortGroup].AddToTail( surfID );
		if ( !DlightSurfaceSetQueuingFlag(surfID) )
		{
			pRenderList->m_DispSortList.AddSurfaceToTail( surfID, nSortGroup, nMaterialSortID );
		}
	}
	else
	{
		pRenderList->m_DispSortList.AddSurfaceToTail( surfID, nSortGroup, nMaterialSortID );
	}
}
 
//-----------------------------------------------------------------------------
// Purpose: This draws a single surface using the dynamic mesh
//-----------------------------------------------------------------------------
void Shader_DrawSurfaceDynamic( IMatRenderContext *pRenderContext, SurfaceHandle_t surfID, bool bShadowDepth )
{
	tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s %d", __FUNCTION__, surfID );

	if( !SurfaceHasPrims( surfID ) )
	{
		IMesh *pMesh = pRenderContext->GetDynamicMesh( );
		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_POLYGON, MSurf_VertCount( surfID ) );
		BuildMSurfaceVertexArrays( host_state.worldbrush, surfID, OVERBRIGHT, meshBuilder );
		meshBuilder.End();
		pMesh->Draw();
		return;
	}

	mprimitive_t *pPrim = &host_state.worldbrush->primitives[MSurf_FirstPrimID( surfID )];

	if ( pPrim->vertCount )
	{
#ifdef DBGFLAG_ASSERT
		int primType = pPrim->type;
#endif
		IMesh *pMesh = pRenderContext->GetDynamicMesh( false );
		CMeshBuilder meshBuilder;
		for( int i = 0; i < MSurf_NumPrims( surfID ); i++, pPrim++ )
		{
			// Can't have heterogeneous primitive lists
			Assert( primType == pPrim->type );
			switch( pPrim->type )
			{
			case PRIM_TRILIST:
				meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, pPrim->vertCount, pPrim->indexCount );
				break;
			case PRIM_TRISTRIP:
				meshBuilder.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, pPrim->vertCount, pPrim->indexCount );
				break;
			default:
				Assert( 0 );
				return;
			}
			Assert( pPrim->indexCount );
			BuildMSurfacePrimVerts( host_state.worldbrush, pPrim, meshBuilder, surfID );
			BuildMSurfacePrimIndices( host_state.worldbrush, pPrim, meshBuilder );
			meshBuilder.End();
			pMesh->Draw();
		}
	}
	else
	{
		// prims are just a tessellation
		IMesh *pMesh = pRenderContext->GetDynamicMesh( );
		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, MSurf_VertCount( surfID ), pPrim->indexCount );
		BuildMSurfaceVertexArrays( host_state.worldbrush, surfID, OVERBRIGHT, meshBuilder );
		for ( int primIndex = 0; primIndex < pPrim->indexCount; primIndex++ )
		{
			meshBuilder.FastIndex( host_state.worldbrush->primindices[pPrim->firstIndex + primIndex] );
		}

		meshBuilder.End();
		pMesh->Draw();
	}
}


//-----------------------------------------------------------------------------
// Purpose: This draws a single surface using its static mesh
//-----------------------------------------------------------------------------

/*
// NOTE: Since a static vb/dynamic ib IMesh doesn't buffer, we shouldn't use this
// since it causes a lock and drawindexedprimitive per surface! (gary)
void Shader_DrawSurfaceStatic( SurfaceHandle_t surfID )
{
	VPROF( "Shader_DrawSurfaceStatic" );
	if ( 
#ifdef USE_CONVARS
		mat_forcedynamic.GetInt() || 
#endif
		(MSurf_Flags( surfID ) & SURFDRAW_WATERSURFACE) )
	{
		Shader_DrawSurfaceDynamic( pRenderContext, surfID );
		return;
	}

	IMesh *pMesh = pRenderContext->GetDynamicMesh( true, 
		g_pWorldStatic[MSurf_MaterialSortID( surfID )].m_pMesh );
	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, 0, (MSurf_VertCount( surfID )-2)*3 );

	unsigned short startVert = MSurf_VertBufferIndex( surfID );
	Assert(startVert!=0xFFFF);
	for ( int v = 0; v < MSurf_VertCount( surfID )-2; v++ )
	{
		meshBuilder.Index( startVert );
		meshBuilder.AdvanceIndex();
		meshBuilder.Index( startVert + v + 1 );
		meshBuilder.AdvanceIndex();
		meshBuilder.Index( startVert + v + 2 );
		meshBuilder.AdvanceIndex();
	}
	meshBuilder.End();
	pMesh->Draw();
}
*/

//-----------------------------------------------------------------------------
// Sets the lightmapping state
//-----------------------------------------------------------------------------
static inline void Shader_SetChainLightmapState( IMatRenderContext *pRenderContext, SurfaceHandle_t surfID )
{
	if ( g_pMaterialSystemConfig->nFullbright == 1 )
	{
		if( MSurf_Flags( surfID ) & SURFDRAW_BUMPLIGHT )
		{
			pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP );
		}
		else
		{
			pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE );
		}
	}
	else
	{
		Assert( MSurf_MaterialSortID( surfID ) >= 0 && MSurf_MaterialSortID( surfID ) < g_WorldStaticMeshes.Count() );
		pRenderContext->BindLightmapPage( materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID );
	}
}


//-----------------------------------------------------------------------------
// Sets the lightmap + texture to render with
//-----------------------------------------------------------------------------
void Shader_SetChainTextureState( IMatRenderContext *pRenderContext, SurfaceHandle_t surfID, IClientEntity* pBaseEntity, bool bShadowDepth )
{
	tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );

	if ( bShadowDepth )
	{
		IMaterial *pDrawMaterial = MSurf_TexInfo( surfID )->material;
		// Select proper override material
		int nAlphaTest = (int) pDrawMaterial->IsAlphaTested();
		int nNoCull = (int) pDrawMaterial->IsTwoSided();
		IMaterial *pDepthWriteMaterial = g_pMaterialDepthWrite[nAlphaTest][nNoCull];

		if ( nAlphaTest == 1 )
		{
			static unsigned int originalTextureVarCache = 0;
			IMaterialVar *pOriginalTextureVar = pDrawMaterial->FindVarFast( "$basetexture", &originalTextureVarCache );
			static unsigned int originalTextureFrameVarCache = 0;
			IMaterialVar *pOriginalTextureFrameVar = pDrawMaterial->FindVarFast( "$frame", &originalTextureFrameVarCache );
			static unsigned int originalAlphaRefCache = 0;
			IMaterialVar *pOriginalAlphaRefVar = pDrawMaterial->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( MSurf_TexInfo( surfID )->material, pBaseEntity ? pBaseEntity->GetClientRenderable() : NULL );
		Shader_SetChainLightmapState( pRenderContext, surfID );
	}
}

void Shader_DrawDynamicChain( const CMSurfaceSortList &sortList, const surfacesortgroup_t &group, bool bShadowDepth )
{
	tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );

	CMatRenderContextPtr pRenderContext( materials );

	SurfaceHandle_t hSurfID = sortList.GetSurfaceAtHead(group);
	if ( !IS_SURF_VALID( hSurfID ))
		return;
	Shader_SetChainTextureState( pRenderContext, hSurfID, 0, bShadowDepth );

	MSL_FOREACH_SURFACE_IN_GROUP_BEGIN(sortList, group, surfID)
	{
		Shader_DrawSurfaceDynamic( pRenderContext, surfID, bShadowDepth );
	}
	MSL_FOREACH_SURFACE_IN_GROUP_END()
}

void Shader_DrawChainsDynamic( const CMSurfaceSortList &sortList, int nSortGroup, bool bShadowDepth )
{
	tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );

	MSL_FOREACH_GROUP_BEGIN(sortList, nSortGroup, group )
	{
		Shader_DrawDynamicChain( sortList, group, bShadowDepth );
	}
	MSL_FOREACH_GROUP_END()
}

struct vertexformatlist_t
{
	unsigned short numbatches;
	unsigned short firstbatch;
#ifdef NEWMESH
	IVertexBuffer *pVertexBuffer;
#else
	IMesh	*pMesh;
#endif
};

struct batchlist_t
{
	SurfaceHandle_t	surfID;		// material and lightmap info
	unsigned short firstIndex;
	unsigned short numIndex;
};

void Shader_DrawChainsStatic( const CMSurfaceSortList &sortList, int nSortGroup, bool bShadowDepth )
{
	tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );

	//VPROF("DrawChainsStatic");
	CUtlVectorFixed<vertexformatlist_t, MAX_VERTEX_FORMAT_CHANGES> meshList;
	int meshMap[MAX_VERTEX_FORMAT_CHANGES];
	CUtlVectorFixedGrowable<batchlist_t, 512> batchList;
	CUtlVectorFixedGrowable<const surfacesortgroup_t *, 8> dynamicGroups;
	bool bWarn = true;
#ifdef NEWMESH
	CIndexBufferBuilder indexBufferBuilder;
#else
	CMeshBuilder meshBuilder;
#endif

	bool skipBind = false;
	if ( g_pMaterialSystemConfig->nFullbright == 1  )
	{
		skipBind = true;
	}

	const CUtlVector<surfacesortgroup_t *> &groupList = sortList.GetSortList(nSortGroup);
	int count = groupList.Count();
	
	int i, listIndex = 0;

	CMatRenderContextPtr pRenderContext( materials );

	//PIXEVENT( pRenderContext, "Shader_DrawChainsStatic" );

	int nMaxIndices = pRenderContext->GetMaxIndicesToRender();
	while ( listIndex < count )
	{
		const surfacesortgroup_t &groupBase = *groupList[listIndex];
		SurfaceHandle_t surfIDBase = sortList.GetSurfaceAtHead( groupBase );
		int sortIDBase = MSurf_MaterialSortID( surfIDBase );
#ifdef NEWMESH
		IIndexBuffer *pBuildIndexBuffer = pRenderContext->GetDynamicIndexBuffer( MATERIAL_INDEX_FORMAT_16BIT, false );
		indexBufferBuilder.Begin( pBuildIndexBuffer, nMaxIndices );
		IVertexBuffer *pLastVertexBuffer = NULL;
#else
		IMesh *pBuildMesh = pRenderContext->GetDynamicMesh( false, g_WorldStaticMeshes[sortIDBase] );
		meshBuilder.Begin( pBuildMesh, MATERIAL_TRIANGLES, 0, nMaxIndices );
		IMesh *pLastMesh = NULL;
#endif
		int indexCount = 0;
		int meshIndex = -1;

		for ( ; listIndex < count; listIndex++ )
		{
			const surfacesortgroup_t &group = *groupList[listIndex];
			SurfaceHandle_t surfID = sortList.GetSurfaceAtHead(group);
			Assert( IS_SURF_VALID( surfID ) );
			if ( MSurf_Flags(surfID) & SURFDRAW_DYNAMIC )
			{
				dynamicGroups.AddToTail( &group );
				continue;
			}

			Assert( group.triangleCount > 0 );
			int numIndex = group.triangleCount * 3;
			if ( indexCount + numIndex > nMaxIndices )
			{
				if ( numIndex > nMaxIndices )
				{
					DevMsg("Too many faces with the same material in scene!\n");
					break;
				}

#ifdef NEWMESH
				pLastVertexBuffer = NULL;
#else
				pLastMesh = NULL;
#endif
				break;
			}
			
			int sortID = MSurf_MaterialSortID( surfID );

#ifdef NEWMESH
			if ( g_WorldStaticMeshes[sortID] != pLastVertexBuffer )
#else
			if ( g_WorldStaticMeshes[sortID] != pLastMesh )
#endif
			{
				if( meshList.Count() < MAX_VERTEX_FORMAT_CHANGES - 1 )
				{
					meshIndex = meshList.AddToTail();
					meshList[meshIndex].numbatches = 0;
					meshList[meshIndex].firstbatch = batchList.Count();
#ifdef NEWMESH
					pLastVertexBuffer = g_WorldStaticMeshes[sortID];
					Assert( pLastVertexBuffer );
					meshList[meshIndex].pVertexBuffer = pLastVertexBuffer;
#else
					pLastMesh = g_WorldStaticMeshes[sortID];
					Assert( pLastMesh );
					meshList[meshIndex].pMesh = pLastMesh;
#endif
				}
				else
				{
					if ( bWarn )
					{
						Warning( "Too many vertex format changes in frame, whole world not rendered\n" );
						bWarn = false;
					}
					continue;
				}
			}

			int batchIndex = batchList.AddToTail();
			batchlist_t &batch = batchList[batchIndex];
			batch.firstIndex = indexCount;
			batch.surfID = surfID;
			batch.numIndex = numIndex;
			Assert( indexCount + batch.numIndex < nMaxIndices );
			indexCount += batch.numIndex;

			meshList[meshIndex].numbatches++;

			MSL_FOREACH_SURFACE_IN_GROUP_BEGIN(sortList, group, surfIDList)
			{
				tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "BuildIndicesForWorldSurface" );
#ifdef NEWMESH
				BuildIndicesForWorldSurface( indexBufferBuilder, surfIDList, host_state.worldbrush );
#else
				Assert( meshBuilder.m_nFirstVertex == 0 );
				BuildIndicesForWorldSurface( meshBuilder, surfIDList, host_state.worldbrush );
#endif
			}
			MSL_FOREACH_SURFACE_IN_GROUP_END()
		}

		// close out the index buffer
#ifdef NEWMESH
		indexBufferBuilder.End( false ); // this one matches (world rendering)
#else
		meshBuilder.End( false, false );
#endif

		int meshTotal = meshList.Count();
		VPROF_INCREMENT_COUNTER( "vertex format changes", meshTotal );

		// HACKHACK: Crappy little bubble sort
		// UNDONE: Make the traversal happen so that they are already sorted when you get here.
		// NOTE: Profiled in a fairly complex map.  This is not even costing 0.01ms / frame!
		for ( i = 0; i < meshTotal; i++ )
		{
			meshMap[i] = i;
		}

		bool swapped = true;
		while ( swapped )
		{
			swapped = false;
			for ( i = 1; i < meshTotal; i++ )
			{
#ifdef NEWMESH
				if ( meshList[meshMap[i]].pVertexBuffer < meshList[meshMap[i-1]].pVertexBuffer )
#else
				if ( meshList[meshMap[i]].pMesh < meshList[meshMap[i-1]].pMesh )
#endif
				{
					int tmp = meshMap[i-1];
					meshMap[i-1] = meshMap[i];
					meshMap[i] = tmp;
					swapped = true;
				}
			}
		}

#ifndef NEWMESH
		pRenderContext->BeginBatch( pBuildMesh );
#endif
		for ( int m = 0; m < meshTotal; m++ )
		{
			vertexformatlist_t &mesh = meshList[meshMap[m]];
			IMaterial *pBindMaterial = materialSortInfoArray[MSurf_MaterialSortID( batchList[mesh.firstbatch].surfID )].material;
#ifdef NEWMESH
			Assert( mesh.pVertexBuffer && pBuildIndexBuffer );
#else
			Assert( mesh.pMesh && pBuildMesh );
#endif
#ifdef NEWMESH
			IIndexBuffer *pIndexBuffer = pRenderContext->GetDynamicIndexBuffer( MATERIAL_INDEX_FORMAT_16BIT, false );
#else
//			IMesh *pMesh = pRenderContext->GetDynamicMesh( false, mesh.pMesh, pBuildMesh, pBindMaterial );
			pRenderContext->BindBatch( mesh.pMesh, pBindMaterial );
#endif

			for ( int b = 0; b < mesh.numbatches; b++ )
			{
				batchlist_t &batch = batchList[b+mesh.firstbatch];
				IMaterial *pDrawMaterial = materialSortInfoArray[MSurf_MaterialSortID( batch.surfID )].material;

				if ( bShadowDepth )
				{
					// Select proper override material
					int nAlphaTest = (int) pDrawMaterial->IsAlphaTested();
					int nNoCull = (int) pDrawMaterial->IsTwoSided();
					IMaterial *pDepthWriteMaterial = g_pMaterialDepthWrite[nAlphaTest][nNoCull];

					if ( nAlphaTest == 1 )
					{
						static unsigned int originalTextureVarCache = 0;
						IMaterialVar *pOriginalTextureVar = pDrawMaterial->FindVarFast( "$basetexture", &originalTextureVarCache );
						static unsigned int originalTextureFrameVarCache = 0;
						IMaterialVar *pOriginalTextureFrameVar = pDrawMaterial->FindVarFast( "$frame", &originalTextureFrameVarCache );
						static unsigned int originalAlphaRefCache = 0;
						IMaterialVar *pOriginalAlphaRefVar = pDrawMaterial->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( pDrawMaterial, NULL );
						
					if ( skipBind )
					{
						if( MSurf_Flags( batch.surfID ) & SURFDRAW_BUMPLIGHT )
						{
							pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP );
						}
						else
						{
							pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE );
						}
					}
					else
					{
						pRenderContext->BindLightmapPage( materialSortInfoArray[MSurf_MaterialSortID( batch.surfID )].lightmapPageID );
					}
				}
#ifdef NEWMESH
				// FIXME: IMaterial::GetVertexFormat() should do this stripping (add a separate 'SupportsCompression' accessor)
				VertexFormat_t vertexFormat = pBindMaterial->GetVertexFormat() & ~VERTEX_FORMAT_COMPRESSED;
				pRenderContext->BindVertexBuffer( 0, mesh.pVertexBuffer, 0, vertexFormat );
				pRenderContext->BindIndexBuffer( pIndexBuffer, 0 );
				Warning( "pRenderContext->Draw( MATERIAL_TRIANGLES, batch.firstIndex = %d, batch.numIndex = %d )\n", 
					( int )batch.firstIndex, ( int )batch.numIndex );
				pRenderContext->Draw( MATERIAL_TRIANGLES, batch.firstIndex, batch.numIndex );
#else
//				pMesh->Draw( batch.firstIndex, batch.numIndex );
				pRenderContext->DrawBatch( batch.firstIndex, batch.numIndex );
#endif
			}
		}
#ifndef NEWMESH
		pRenderContext->EndBatch();
#endif


		// if we get here and pLast mesh is NULL and we rendered somthing, we need to loop
#ifdef NEWMESH
		if ( pLastVertexBuffer || !meshTotal )
#else
		if ( pLastMesh || !meshTotal )
#endif
			break;

		meshList.RemoveAll();
		batchList.RemoveAll();
	}
	for ( i = 0; i < dynamicGroups.Count(); i++ )
	{
		Shader_DrawDynamicChain( sortList, *dynamicGroups[i], bShadowDepth );
	}
}

//-----------------------------------------------------------------------------
// The following methods will display debugging info in the middle of each surface
//-----------------------------------------------------------------------------
typedef void (*SurfaceDebugFunc_t)( SurfaceHandle_t surfID, const Vector &vecCentroid );

void DrawSurfaceID( SurfaceHandle_t surfID, const Vector &vecCentroid )
{
	char buf[32];
	Q_snprintf(buf, sizeof( buf ), "0x%p", surfID );
	CDebugOverlay::AddTextOverlay( vecCentroid, 0, buf );
}

void DrawSurfaceIDAsInt( SurfaceHandle_t surfID, const Vector &vecCentroid )
{
	int nInt = (msurface2_t*)surfID - host_state.worldbrush->surfaces2;
	char buf[32];
	Q_snprintf( buf, sizeof( buf ), "%d", nInt );
	CDebugOverlay::AddTextOverlay( vecCentroid, 0, buf );
}

void DrawSurfaceMaterial( SurfaceHandle_t surfID, const Vector &vecCentroid )
{
	mtexinfo_t * pTexInfo = MSurf_TexInfo(surfID);

	const char *pFullMaterialName = pTexInfo->material ? pTexInfo->material->GetName() : "no material";
	const char *pSlash = strrchr( pFullMaterialName, '/' );
	const char *pMaterialName = strrchr( pFullMaterialName, '\\' );
	if (pSlash > pMaterialName)
		pMaterialName = pSlash;
	if (pMaterialName)
		++pMaterialName;
	else
		pMaterialName = pFullMaterialName;

	CDebugOverlay::AddTextOverlay( vecCentroid, 0, pMaterialName );
}


//-----------------------------------------------------------------------------
// Displays the surface id # in the center of the surface.
//-----------------------------------------------------------------------------
void Shader_DrawSurfaceDebuggingInfo( const CUtlVector<msurface2_t *> &surfaceList, SurfaceDebugFunc_t func )
{
	for ( int i = 0; i < surfaceList.Count(); i++ )
	{
		SurfaceHandle_t surfID = surfaceList[i];
		Assert( !SurfaceHasDispInfo( surfID ) );

		// Compute the centroid of the surface
		int nCount = MSurf_VertCount( surfID );
		if (nCount >= 3)
		{
			Vector vecCentroid;
			Surf_ComputeCentroid( surfID, &vecCentroid );
			func( surfID, vecCentroid );
		}
	}
}



//-----------------------------------------------------------------------------
// Doesn't draw internal triangles
//-----------------------------------------------------------------------------
void Shader_DrawWireframePolygons( const CUtlVector<msurface2_t *> &surfaceList )
{
	int nLineCount = 0;
	for ( int i = 0; i < surfaceList.Count(); i++ )
	{
		int nCount = MSurf_VertCount( surfaceList[i] );
		if (nCount >= 3)
		{
			nLineCount += nCount;
		}
	}

	if (nLineCount == 0)
		return;

	CMatRenderContextPtr pRenderContext( materials );

	pRenderContext->Bind( g_materialWorldWireframe );
	IMesh *pMesh = pRenderContext->GetDynamicMesh( false );
	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_LINES, nLineCount );

	for ( int i = 0; i < surfaceList.Count(); i++ )
	{
		SurfaceHandle_t surfID = surfaceList[i];
		Assert( !SurfaceHasDispInfo( surfID ) );

		// Compute the centroid of the surface
		int nCount = MSurf_VertCount( surfID );
		if (nCount >= 3)
		{
			int nFirstVertIndex = MSurf_FirstVertIndex( surfID );
			int nVertIndex = host_state.worldbrush->vertindices[nFirstVertIndex + nCount - 1];
			Vector vecPrevPos = host_state.worldbrush->vertexes[nVertIndex].position;
			for (int v = 0; v < nCount; ++v )
			{
				// world-space vertex
				nVertIndex = host_state.worldbrush->vertindices[nFirstVertIndex + v];
				Vector& vec = host_state.worldbrush->vertexes[nVertIndex].position;

				// output to mesh
				meshBuilder.Position3fv( vecPrevPos.Base() );
				meshBuilder.AdvanceVertex();
				meshBuilder.Position3fv( vec.Base() );
				meshBuilder.AdvanceVertex();

				vecPrevPos = vec;
			}
		}
	}

	meshBuilder.End();
	pMesh->Draw();
}


//-----------------------------------------------------------------------------
// Debugging mode, renders the wireframe.
//-----------------------------------------------------------------------------
static void Shader_DrawChainsWireframe(	const CUtlVector<msurface2_t *> &surfaceList )
{
	int nWireFrameMode = WireFrameMode();

	switch( nWireFrameMode )
	{
	case 3:
		// Doesn't draw internal triangles
		Shader_DrawWireframePolygons(surfaceList);
		break;

	default:
		{
			CMatRenderContextPtr pRenderContext( materials );
			if( nWireFrameMode == 2 )
			{
				pRenderContext->Bind( g_materialWorldWireframeZBuffer );
			}
			else
			{
				pRenderContext->Bind( g_materialWorldWireframe );
			}
			for ( int i = 0; i < surfaceList.Count(); i++ )
			{
				SurfaceHandle_t surfID = surfaceList[i];
				Assert( !SurfaceHasDispInfo( surfID ) );
				Shader_DrawSurfaceDynamic( pRenderContext, surfID, false );
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Debugging mode, renders the normals
//-----------------------------------------------------------------------------
static void Shader_DrawChainNormals( const CUtlVector<msurface2_t *> &surfaceList )
{
	Vector p, tVect, tangentS, tangentT;

	CMatRenderContextPtr pRenderContext( materials );

	worldbrushdata_t *pBrushData = host_state.worldbrush;
	pRenderContext->Bind( g_pMaterialWireframeVertexColor );

	for ( int i = 0; i < surfaceList.Count(); i++ )
	{
		SurfaceHandle_t surfID = surfaceList[i];
		IMesh *pMesh = pRenderContext->GetDynamicMesh( );
		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_LINES, MSurf_VertCount( surfID ) * 3 );
	
		bool negate = TangentSpaceSurfaceSetup( surfID, tVect );

		int vertID;
		for( vertID = 0; vertID < MSurf_VertCount( surfID ); ++vertID )
		{
			int vertIndex = pBrushData->vertindices[MSurf_FirstVertIndex( surfID )+vertID];
			Vector& pos = pBrushData->vertexes[vertIndex].position;
			Vector& norm = pBrushData->vertnormals[ pBrushData->vertnormalindices[MSurf_FirstVertNormal( surfID )+vertID] ];

			TangentSpaceComputeBasis( tangentS, tangentT, norm, tVect, negate );

			meshBuilder.Position3fv( pos.Base() );
			meshBuilder.Color3ub( 0, 0, 255 );
			meshBuilder.AdvanceVertex();

			VectorMA( pos, 5.0f, norm, p );
			meshBuilder.Position3fv( p.Base() );
			meshBuilder.Color3ub( 0, 0, 255 );
			meshBuilder.AdvanceVertex();

			meshBuilder.Position3fv( pos.Base() );
			meshBuilder.Color3ub( 0, 255, 0 );
			meshBuilder.AdvanceVertex();

			VectorMA( pos, 5.0f, tangentT, p );
			meshBuilder.Position3fv( p.Base() );
			meshBuilder.Color3ub( 0, 255, 0 );
			meshBuilder.AdvanceVertex();

			meshBuilder.Position3fv( pos.Base() );
			meshBuilder.Color3ub( 255, 0, 0 );
			meshBuilder.AdvanceVertex();

			VectorMA( pos, 5.0f, tangentS, p );
			meshBuilder.Position3fv( p.Base() );
			meshBuilder.Color3ub( 255, 0, 0 );
			meshBuilder.AdvanceVertex();
		}
		
		meshBuilder.End();
		pMesh->Draw();
	}
}

static void Shader_DrawChainBumpBasis( const CUtlVector<msurface2_t *> &surfaceList )
{
	Vector p, tVect, tangentS, tangentT;

	CMatRenderContextPtr pRenderContext( materials );

	worldbrushdata_t *pBrushData = host_state.worldbrush;
	pRenderContext->Bind( g_pMaterialWireframeVertexColor );

	for ( int i = 0; i < surfaceList.Count(); i++ )
	{
		SurfaceHandle_t surfID = surfaceList[i];
		IMesh *pMesh = pRenderContext->GetDynamicMesh( );
		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_LINES, MSurf_VertCount( surfID ) * 3 );
	
		bool negate = TangentSpaceSurfaceSetup( surfID, tVect );

		int vertID;
		for( vertID = 0; vertID < MSurf_VertCount( surfID ); ++vertID )
		{
			int vertIndex = pBrushData->vertindices[MSurf_FirstVertIndex( surfID )+vertID];
			Vector& pos = pBrushData->vertexes[vertIndex].position;
			Vector& norm = pBrushData->vertnormals[ pBrushData->vertnormalindices[MSurf_FirstVertNormal( surfID )+vertID] ];

			TangentSpaceComputeBasis( tangentS, tangentT, norm, tVect, negate );

			Vector worldSpaceBumpBasis[3];

			for( int j = 0; j < 3; j++ )
			{
				worldSpaceBumpBasis[j][0] = 
					g_localBumpBasis[j][0] * tangentS[0] +
					g_localBumpBasis[j][1] * tangentS[1] + 
					g_localBumpBasis[j][2] * tangentS[2];
				worldSpaceBumpBasis[j][1] = 
					g_localBumpBasis[j][0] * tangentT[0] +
					g_localBumpBasis[j][1] * tangentT[1] + 
					g_localBumpBasis[j][2] * tangentT[2];
				worldSpaceBumpBasis[j][2] = 
					g_localBumpBasis[j][0] * norm[0] +
					g_localBumpBasis[j][1] * norm[1] + 
					g_localBumpBasis[j][2] * norm[2];
			}

			meshBuilder.Position3fv( pos.Base() );
			meshBuilder.Color3ub( 255, 0, 0 );
			meshBuilder.AdvanceVertex();

			VectorMA( pos, 5.0f, worldSpaceBumpBasis[0], p );
			meshBuilder.Position3fv( p.Base() );
			meshBuilder.Color3ub( 255, 0, 0 );
			meshBuilder.AdvanceVertex();

			meshBuilder.Position3fv( pos.Base() );
			meshBuilder.Color3ub( 0, 255, 0 );
			meshBuilder.AdvanceVertex();

			VectorMA( pos, 5.0f, worldSpaceBumpBasis[1], p );
			meshBuilder.Position3fv( p.Base() );
			meshBuilder.Color3ub( 0, 255, 0 );
			meshBuilder.AdvanceVertex();

			meshBuilder.Position3fv( pos.Base() );
			meshBuilder.Color3ub( 0, 0, 255 );
			meshBuilder.AdvanceVertex();

			VectorMA( pos, 5.0f, worldSpaceBumpBasis[2], p );
			meshBuilder.Position3fv( p.Base() );
			meshBuilder.Color3ub( 0, 0, 255 );
			meshBuilder.AdvanceVertex();
		}
		
		meshBuilder.End();
		pMesh->Draw();
	}
}


//-----------------------------------------------------------------------------
// Debugging mode, renders the luxel grid.
//-----------------------------------------------------------------------------
static void Shader_DrawLuxels( const CUtlVector<msurface2_t *> &surfaceList )
{
	CMatRenderContextPtr pRenderContext( materials );

	pRenderContext->Bind( g_materialDebugLuxels );

	for ( int i = 0; i < surfaceList.Count(); i++ )
	{
		SurfaceHandle_t surfID = surfaceList[i];
		Assert( !SurfaceHasDispInfo( surfID ) );

		// Gotta bind the lightmap page so the rendering knows the lightmap scale
		pRenderContext->BindLightmapPage( materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID );
		Shader_DrawSurfaceDynamic( pRenderContext, surfID, false );
	}
}

static struct CShaderDebug
{
	bool		wireframe;
	bool		normals;
	bool		luxels;
	bool		bumpBasis;
	bool		surfacematerials;
	bool		anydebug;
	int			surfaceid;

	void TestAnyDebug()
	{
		anydebug = wireframe || normals || luxels || bumpBasis || ( surfaceid != 0 ) || surfacematerials;
	}

} g_ShaderDebug;


ConVar mat_surfaceid("mat_surfaceid", "0", FCVAR_CHEAT);
ConVar mat_surfacemat("mat_surfacemat", "0", FCVAR_CHEAT);


//-----------------------------------------------------------------------------
// Purpose: 
// Output : static void
//-----------------------------------------------------------------------------
static void ComputeDebugSettings( void )
{
	g_ShaderDebug.wireframe = ShouldDrawInWireFrameMode() || (r_drawworld.GetInt() == 2);
	g_ShaderDebug.normals = mat_normals.GetBool();
	g_ShaderDebug.luxels = mat_luxels.GetBool();
	g_ShaderDebug.bumpBasis = mat_bumpbasis.GetBool();
	g_ShaderDebug.surfaceid = mat_surfaceid.GetInt();
	g_ShaderDebug.surfacematerials = mat_surfacemat.GetBool();
	g_ShaderDebug.TestAnyDebug();
}

//-----------------------------------------------------------------------------
// Draw debugging information
//-----------------------------------------------------------------------------
static void DrawDebugInformation( const CUtlVector<msurface2_t *> &surfaceList )
{
	// Overlay with wireframe if we're in that mode
	if( g_ShaderDebug.wireframe )
	{
		Shader_DrawChainsWireframe(surfaceList);
	}

	// Overlay with normals if we're in that mode
	if( g_ShaderDebug.normals )
	{
		Shader_DrawChainNormals(surfaceList);
	}

	if( g_ShaderDebug.bumpBasis )
	{
		Shader_DrawChainBumpBasis(surfaceList);
	}
	
	// Overlay with luxel grid if we're in that mode
	if( g_ShaderDebug.luxels )
	{
		Shader_DrawLuxels(surfaceList);
	}

	if ( g_ShaderDebug.surfaceid )
	{
		// Draw the surface id in the middle of the surfaces
		Shader_DrawSurfaceDebuggingInfo( surfaceList, (g_ShaderDebug.surfaceid != 2 ) ? DrawSurfaceID : DrawSurfaceIDAsInt );
	}
	else if ( g_ShaderDebug.surfacematerials )
	{
		// Draw the material name in the middle of the surfaces
		Shader_DrawSurfaceDebuggingInfo( surfaceList, DrawSurfaceMaterial );
	}
}


void AddProjectedTextureDecalsToList( CWorldRenderList *pRenderList, int nSortGroup )
{
	const CMSurfaceSortList &sortList = pRenderList->m_SortList;
	MSL_FOREACH_GROUP_BEGIN( sortList, nSortGroup, group )
	{
		MSL_FOREACH_SURFACE_IN_GROUP_BEGIN(sortList, group, surfID)
		{
			Assert( !SurfaceHasDispInfo( surfID ) );
			if ( SHADOW_DECAL_HANDLE_INVALID != MSurf_ShadowDecals( surfID ) )
			{
				// No shadows on water surfaces
				if ((MSurf_Flags( surfID ) & SURFDRAW_NOSHADOWS) == 0)
				{
					MEM_ALLOC_CREDIT();
					pRenderList->m_ShadowHandles[nSortGroup].AddToTail( MSurf_ShadowDecals( surfID ) );
				}
			}
			// Add overlay fragments to list.
			if ( OVERLAY_FRAGMENT_INVALID != MSurf_OverlayFragmentList( surfID ) )
			{
				OverlayMgr()->AddFragmentListToRenderList( nSortGroup, MSurf_OverlayFragmentList( surfID ), false );
			}
		}
		MSL_FOREACH_SURFACE_IN_GROUP_END();
	}
	MSL_FOREACH_GROUP_END()
}

//-----------------------------------------------------------------------------
// Draws all of the opaque non-displacement surfaces queued up previously
//-----------------------------------------------------------------------------
void Shader_DrawChains( const CWorldRenderList *pRenderList, int nSortGroup, bool bShadowDepth )
{
	tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );

	CMatRenderContextPtr pRenderContext(materials);
	Assert( !g_EngineRenderer->InLightmapUpdate() );
	VPROF("Shader_DrawChains");
	// Draw chains...
#ifdef USE_CONVARS
	if ( !mat_forcedynamic.GetInt() && !g_pMaterialSystemConfig->bDrawFlat )
#else
	if( 1 )
#endif
	{
		if ( g_VBAllocTracker )
			g_VBAllocTracker->TrackMeshAllocations( "Shader_DrawChainsStatic" );
		Shader_DrawChainsStatic( pRenderList->m_SortList, nSortGroup, bShadowDepth );
	}
	else
	{
		if ( g_VBAllocTracker )
			g_VBAllocTracker->TrackMeshAllocations( "Shader_DrawChainsDynamic" );
		Shader_DrawChainsDynamic( pRenderList->m_SortList, nSortGroup, bShadowDepth );
	}
	if ( g_VBAllocTracker )
		g_VBAllocTracker->TrackMeshAllocations( NULL );

#if MOVE_DLIGHTS_TO_NEW_TEXTURE
	for ( int i = 0; i < pRenderList->m_DlightSurfaces[nSortGroup].Count(); i++ )
	{
		SurfaceHandle_t surfID = pRenderList->m_DlightSurfaces[nSortGroup][i];
		if ( !SurfaceHasDispInfo( surfID ) && (MSurf_Flags(surfID) & SURFDRAW_DLIGHTPASS) )
		{
			pRenderContext->Bind( MSurf_TexInfo( surfID )->material, NULL );
			Shader_SetChainLightmapState( pRenderContext, surfID );
			Shader_DrawSurfaceDynamic( pRenderContext, surfID, bShadowDepth );
		}
	}
#endif

	if ( bShadowDepth )	// Skip debug stuff in shadow depth map
		return;

#ifdef USE_CONVARS
	if ( g_ShaderDebug.anydebug )
	{
		const CMSurfaceSortList &sortList = pRenderList->m_SortList;
		// Debugging information
		MSL_FOREACH_GROUP_BEGIN(sortList, nSortGroup, group )
		{
			CUtlVector<msurface2_t *> surfList;
			sortList.GetSurfaceListForGroup( surfList, group );
			DrawDebugInformation( surfList );
		}
		MSL_FOREACH_GROUP_END()
	}
#endif
}


//-----------------------------------------------------------------------------
// Draws all of the opaque displacement surfaces queued up previously
//-----------------------------------------------------------------------------
void Shader_DrawDispChain( int nSortGroup, const CMSurfaceSortList &list, unsigned long flags, ERenderDepthMode DepthMode )
{
	VPROF_BUDGET( "Shader_DrawDispChain", VPROF_BUDGETGROUP_DISPLACEMENT_RENDERING );
	tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );

	int count = 0;
	msurface2_t **pList;
	MSL_FOREACH_GROUP_BEGIN( list, nSortGroup, group )
	{
		count += group.surfaceCount;
	}
	MSL_FOREACH_GROUP_END()

	if (count)
	{
		pList = (msurface2_t **)stackalloc( count * sizeof(msurface2_t *));
		int i = 0;
		MSL_FOREACH_GROUP_BEGIN( list, nSortGroup, group )
		{
			MSL_FOREACH_SURFACE_IN_GROUP_BEGIN(list,group,surfID)
			{
				pList[i] = surfID;
				++i;
			}
			MSL_FOREACH_SURFACE_IN_GROUP_END()
		}
		MSL_FOREACH_GROUP_END()
		Assert(i==count);

		// draw displacments, batch decals
		DispInfo_RenderList( nSortGroup, pList, count, g_EngineRenderer->ViewGetCurrent().m_bOrtho, flags, DepthMode );
		stackfree(pList);
	}
}

static void Shader_BuildDynamicLightmaps( CWorldRenderList *pRenderList )
{
	VPROF( "Shader_BuildDynamicLightmaps" );

	R_DLightStartView();

	// Build all lightmaps for opaque surfaces
	for ( int nSortGroup = 0; nSortGroup < MAX_MAT_SORT_GROUPS; ++nSortGroup)
	{
#if 0
		int updateStart = g_LightmapUpdateList.Count();
#endif
		for ( int i = pRenderList->m_DlightSurfaces[nSortGroup].Count()-1; i >= 0; --i )
		{
			LightmapUpdateInfo_t tmp;
			tmp.m_SurfHandle = pRenderList->m_DlightSurfaces[nSortGroup].Element(i);
			tmp.transformIndex = 0;
			g_LightmapUpdateList.AddToTail( tmp );
		}

		// UNDONE: Redo this list?  Make a new list with the texture coord info for the new lightmaps?
#if 0
		pRenderList->m_DlightSurfaces[nSortGroup].RemoveAll();
		for ( int i = updateStart; i < g_LightmapUpdateList.Count(); i++ )
		{
			if ( MSurf_Flags(g_LightmapUpdateList[i].m_SurfHandle) & SURFDRAW_DLIGHTPASS )
			{
				pRenderList->m_DlightSurfaces[nSortGroup].AddToTail(g_LightmapUpdateList[i].m_SurfHandle);
			}
		}
#endif
	}

	R_DLightEndView();
}


//-----------------------------------------------------------------------------
// Compute if we're in or out of a fog volume
//-----------------------------------------------------------------------------
static void ComputeFogVolumeInfo( FogVolumeInfo_t *pFogVolume )
{
	pFogVolume->m_InFogVolume = false;
	int leafID = CM_PointLeafnum( CurrentViewOrigin() );
	if( leafID < 0 || leafID >= host_state.worldbrush->numleafs )
		return;

	mleaf_t* pLeaf = &host_state.worldbrush->leafs[leafID];
	pFogVolume->m_FogVolumeID = pLeaf->leafWaterDataID;
	if( pFogVolume->m_FogVolumeID == -1 )
		return;

	pFogVolume->m_InFogVolume = true;

	mleafwaterdata_t* pLeafWaterData = &host_state.worldbrush->leafwaterdata[pLeaf->leafWaterDataID];
	if( pLeafWaterData->surfaceTexInfoID == -1 )
	{
		// Should this ever happen?????
		pFogVolume->m_FogEnabled = false;
		return;
	}
	mtexinfo_t* pTexInfo = &host_state.worldbrush->texinfo[pLeafWaterData->surfaceTexInfoID];

	IMaterial* pMaterial = pTexInfo->material;
	if( pMaterial )
	{
		IMaterialVar* pFogColorVar	= pMaterial->FindVar( "$fogcolor", NULL );
		IMaterialVar* pFogEnableVar = pMaterial->FindVar( "$fogenable", NULL );
		IMaterialVar* pFogStartVar	= pMaterial->FindVar( "$fogstart", NULL );
		IMaterialVar* pFogEndVar	= pMaterial->FindVar( "$fogend", NULL );

		pFogVolume->m_FogEnabled = pFogEnableVar->GetIntValue() ? true : false;
		pFogColorVar->GetVecValue( pFogVolume->m_FogColor, 3 );
		pFogVolume->m_FogStart		= -pFogStartVar->GetFloatValue();
		pFogVolume->m_FogEnd		= -pFogEndVar->GetFloatValue();
		pFogVolume->m_FogSurfaceZ	= pLeafWaterData->surfaceZ;
		pFogVolume->m_FogMinZ		= pLeafWaterData->minZ;
		pFogVolume->m_FogMode		= MATERIAL_FOG_LINEAR;
	}
	else
	{
		static bool bComplained = false;
		if( !bComplained )
		{
			Warning( "***Water vmt missing . . check console for missing materials!***\n" );
			bComplained = true;
		}
		pFogVolume->m_FogEnabled = false;
	}
}


//-----------------------------------------------------------------------------
// Resets a world render list
//-----------------------------------------------------------------------------
void ResetWorldRenderList( CWorldRenderList *pRenderList )
{
	if ( pRenderList )
	{
		pRenderList->Reset();
	}
}


//-----------------------------------------------------------------------------
// Call this before rendering; it clears out the lists of stuff to render
//-----------------------------------------------------------------------------
void Shader_WorldBegin( CWorldRenderList *pRenderList )
{
	// Cache the convars so we don't keep accessing them...
	s_ShaderConvars.m_bDrawWorld = r_drawworld.GetBool();
	s_ShaderConvars.m_nDrawLeaf = r_drawleaf.GetInt();
	s_ShaderConvars.m_bDrawFuncDetail = r_drawfuncdetail.GetBool();

	ResetWorldRenderList( pRenderList );

	// Clear out the decal list
	DecalSurfacesInit( false );

	// Clear out the render lists of overlays
	OverlayMgr()->ClearRenderLists();

	// Clear out the render lists of shadows
	g_pShadowMgr->ClearShadowRenderList( );
}



//-----------------------------------------------------------------------------
// Performs the z-fill
//-----------------------------------------------------------------------------
static void Shader_WorldZFillSurfChain( const CMSurfaceSortList &sortList, const surfacesortgroup_t &group, CMeshBuilder &meshBuilder, int &nStartVertIn, unsigned int includeFlags )
{
	int nStartVert = nStartVertIn;
	mvertex_t *pWorldVerts = host_state.worldbrush->vertexes;

	MSL_FOREACH_SURFACE_IN_GROUP_BEGIN(sortList, group, nSurfID)
	{
		if ( (MSurf_Flags( nSurfID ) & includeFlags) == 0 )
			continue;

		// Skip water surfaces since it may move up or down to fixup water transitions.
		if ( MSurf_Flags( nSurfID ) & SURFDRAW_WATERSURFACE )
			continue;

		int nSurfTriangleCount = MSurf_VertCount( nSurfID ) - 2;

		unsigned short *pVertIndex = &(host_state.worldbrush->vertindices[MSurf_FirstVertIndex( nSurfID )]);

		// add surface to this batch
		if ( SurfaceHasPrims(nSurfID) )
		{
			mprimitive_t *pPrim = &host_state.worldbrush->primitives[MSurf_FirstPrimID( nSurfID )];
			if ( pPrim->vertCount == 0 )
			{
				int firstVert = MSurf_FirstVertIndex( nSurfID );
				for ( int i = 0; i < MSurf_VertCount(nSurfID); i++ )
				{
					int vertIndex = host_state.worldbrush->vertindices[firstVert + i];
					meshBuilder.Position3fv( pWorldVerts[vertIndex].position.Base() );
					meshBuilder.AdvanceVertex();
				}
				for ( int primIndex = 0; primIndex < pPrim->indexCount; primIndex++ )
				{
					meshBuilder.FastIndex( host_state.worldbrush->primindices[pPrim->firstIndex + primIndex] + nStartVert );
				}
			}
		}
		else
		{
			switch (nSurfTriangleCount)
			{
			case 1:
				meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
				meshBuilder.AdvanceVertex();
				meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
				meshBuilder.AdvanceVertex();
				meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
				meshBuilder.AdvanceVertex();

				meshBuilder.FastIndex( nStartVert );
				meshBuilder.FastIndex( nStartVert + 1 );
				meshBuilder.FastIndex( nStartVert + 2 );

				break;

			case 2:
				meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
				meshBuilder.AdvanceVertex();
				meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
				meshBuilder.AdvanceVertex();
				meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
				meshBuilder.AdvanceVertex();
				meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
				meshBuilder.AdvanceVertex();
				meshBuilder.FastIndex( nStartVert );
				meshBuilder.FastIndex( nStartVert + 1 );
				meshBuilder.FastIndex( nStartVert + 2 );
				meshBuilder.FastIndex( nStartVert );
				meshBuilder.FastIndex( nStartVert + 2 );
				meshBuilder.FastIndex( nStartVert + 3 );
				break;

			default:
				{
					for ( unsigned short v = 0; v < nSurfTriangleCount; ++v )
					{
						meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
						meshBuilder.AdvanceVertex();

						meshBuilder.FastIndex( nStartVert );
						meshBuilder.FastIndex( nStartVert + v + 1 );
						meshBuilder.FastIndex( nStartVert + v + 2 );
					}

					meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
					meshBuilder.AdvanceVertex();
					meshBuilder.Position3fv( pWorldVerts[*pVertIndex++].position.Base() );
					meshBuilder.AdvanceVertex();
				}
				break;
			}
		}
		nStartVert += nSurfTriangleCount + 2;
	}
	MSL_FOREACH_SURFACE_IN_GROUP_END()

	nStartVertIn = nStartVert;
}

static const int s_DrawWorldListsToSortGroup[MAX_MAT_SORT_GROUPS] = 
{
	MAT_SORT_GROUP_STRICTLY_ABOVEWATER,
	MAT_SORT_GROUP_STRICTLY_UNDERWATER,
	MAT_SORT_GROUP_INTERSECTS_WATER_SURFACE,
	MAT_SORT_GROUP_WATERSURFACE,
};

static ConVar r_flashlightrendermodels(  "r_flashlightrendermodels", "1" );

//-----------------------------------------------------------------------------
// Performs the shadow depth texture fill
//-----------------------------------------------------------------------------
static void Shader_WorldShadowDepthFill( CWorldRenderList *pRenderList, unsigned long flags )
{
	tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );

	// First, count the number of vertices + indices
	int nVertexCount = 0;
	int nIndexCount = 0;
	ERenderDepthMode DepthMode = DEPTH_MODE_SHADOW;
	if ( flags & DRAWWORLDLISTS_DRAW_SSAO )
	{
		DepthMode = DEPTH_MODE_SSA0;
	}

	int g;
	CUtlVector<const surfacesortgroup_t *> alphatestedGroups;

	const CMSurfaceSortList &sortList = pRenderList->m_SortList;
	for ( g = 0; g < MAX_MAT_SORT_GROUPS; ++g )
	{
		if ( ( flags & ( 1 << g ) ) == 0 )
			continue;

		int nSortGroup = s_DrawWorldListsToSortGroup[g];
		MSL_FOREACH_GROUP_BEGIN(sortList, nSortGroup, group )
		{
			SurfaceHandle_t surfID = sortList.GetSurfaceAtHead(group);
			if ( MSurf_Flags( surfID ) & SURFDRAW_WATERSURFACE )
				continue;
			IMaterial *pMaterial = MSurf_TexInfo( surfID )->material;

			if( pMaterial->IsTranslucent() )
				continue;

			if ( pMaterial->IsAlphaTested() )
			{
				alphatestedGroups.AddToTail( &group );
				continue;
			}

			nVertexCount += group.vertexCount;
			nIndexCount += group.triangleCount*3;
		}
		MSL_FOREACH_GROUP_END()

		// Draws opaque displacement surfaces along with shadows, overlays, flashlights, etc.
		Shader_DrawDispChain( nSortGroup, pRenderList->m_DispSortList, flags, DepthMode );
	}
	if ( nVertexCount == 0 )
		return;
 
	CMatRenderContextPtr pRenderContext( materials );

	if ( DepthMode == DEPTH_MODE_SHADOW )
	{
		pRenderContext->Bind( g_pMaterialDepthWrite[0][1] );
	}
	else
	{
		pRenderContext->Bind( g_pMaterialSSAODepthWrite[0][1] );
	}

	IMesh *pMesh = pRenderContext->GetDynamicMesh( false );

	int nMaxIndices  = pRenderContext->GetMaxIndicesToRender();
	int nMaxVertices = pRenderContext->GetMaxVerticesToRender( g_pMaterialDepthWrite[0][1] );	// opaque, nocull

	// nBatchIndexCount and nBatchVertexCount are the number of indices and vertices we can fit in this batch
	// Each batch must have fewer than nMaxIndices and nMaxVertices or the material system will fail
	int nBatchIndexCount  = min( nIndexCount,  nMaxIndices  );
	int nBatchVertexCount = min( nVertexCount, nMaxVertices );


	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nBatchVertexCount, nBatchIndexCount );

	int nStartVert = 0;
	for ( g = 0; g < MAX_MAT_SORT_GROUPS; ++g )
	{
		if ( ( flags & ( 1 << g ) ) == 0 )
			continue;

		int nSortGroup = s_DrawWorldListsToSortGroup[g];
		MSL_FOREACH_GROUP_BEGIN(sortList, nSortGroup, group )
		{
			SurfaceHandle_t surfID = sortList.GetSurfaceAtHead(group);
			// Check to see if we can add this list to the current batch...
			int nCurrIndexCount = group.triangleCount*3;
			int nCurrVertexCount = group.vertexCount;
			if ( ( nCurrIndexCount == 0 ) || ( nCurrVertexCount == 0 ) )
				continue;

			// this group is too big to draw so push it into the alphatested groups
			// this will run much slower but at least it won't crash
			// alphatested groups will draw each surface one at a time.
			if ( nCurrIndexCount > nMaxIndices || nCurrVertexCount > nMaxVertices )
			{
				alphatestedGroups.AddToTail( &group );
				continue;
			}
			IMaterial *pMaterial = MSurf_TexInfo( surfID )->material;

			// Opaque only on this loop
			if( pMaterial->IsTranslucent() ||  pMaterial->IsAlphaTested() )
				continue;

			Assert( nCurrIndexCount  <= nMaxIndices  );
			Assert( nCurrVertexCount <= nMaxVertices );

			if ( ( nBatchIndexCount < nCurrIndexCount ) || ( nBatchVertexCount < nCurrVertexCount ) )
			{
				// Nope, fire off the current batch...
				meshBuilder.End();
				pMesh->Draw();
				nBatchIndexCount  = min( nIndexCount,  nMaxIndices  );
				nBatchVertexCount = min( nVertexCount, nMaxVertices );
				pMesh = pRenderContext->GetDynamicMesh( false );
				meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nBatchVertexCount, nBatchIndexCount );
				nStartVert = 0;
			}

			nBatchIndexCount  -= nCurrIndexCount;
			nIndexCount       -= nCurrIndexCount;
			nBatchVertexCount -= nCurrVertexCount;
			nVertexCount      -= nCurrVertexCount;
			// 0xFFFFFFFF means include all surfaces
			Shader_WorldZFillSurfChain( sortList, group, meshBuilder, nStartVert, 0xFFFFFFFF );
		}
		MSL_FOREACH_GROUP_END()
	}

	meshBuilder.End();
	pMesh->Draw();

	// Now draw the alpha-tested groups we stored away earlier
	for ( int i = 0; i < alphatestedGroups.Count(); i++ )
	{
		Shader_DrawDynamicChain( sortList, *alphatestedGroups[i], true );
	}
}



//-----------------------------------------------------------------------------
// Performs the z-fill
//-----------------------------------------------------------------------------
static void Shader_WorldZFill( CWorldRenderList *pRenderList, unsigned long flags )
{
	tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );

	// First, count the number of vertices + indices
	int nVertexCount = 0;
	int nIndexCount = 0;

	int g;
	const CMSurfaceSortList &sortList = pRenderList->m_SortList;

#ifdef _X360
	bool bFastZRejectDisplacements = s_bFastZRejectDisplacements || ( r_fastzrejectdisp.GetInt() != 0 );
#endif

	for ( g = 0; g < MAX_MAT_SORT_GROUPS; ++g )
	{
		if ( ( flags & ( 1 << g ) ) == 0 )
			continue;

		int nSortGroup = s_DrawWorldListsToSortGroup[g];
		MSL_FOREACH_GROUP_BEGIN(sortList, nSortGroup, group )
		{
			SurfaceHandle_t surfID = sortList.GetSurfaceAtHead(group);
			IMaterial *pMaterial = MSurf_TexInfo( surfID )->material;
			if( pMaterial->IsAlphaTested() || pMaterial->IsTranslucent() )
			{
				continue;
			}
			nVertexCount += group.vertexCountNoDetail;
			nIndexCount += group.indexCountNoDetail;
		}
		MSL_FOREACH_GROUP_END()

#ifdef _X360
		// Draws opaque displacement surfaces along with shadows, overlays, flashlights, etc.
		// NOTE: This only makes sense on the 360, since the extra batches aren't
		// worth it on the PC (I think!)
		if ( bFastZRejectDisplacements )
		{
			Shader_DrawDispChain( nSortGroup, pRenderList->m_DispSortList, flags, true );
		}
#endif
	}

	if ( nVertexCount == 0 )
		return;

	CMatRenderContextPtr pRenderContext( materials );

	pRenderContext->Bind( g_pMaterialWriteZ );
	IMesh *pMesh = pRenderContext->GetDynamicMesh( false );

	int nMaxIndices  = pRenderContext->GetMaxIndicesToRender();
	int nMaxVertices = pRenderContext->GetMaxVerticesToRender( g_pMaterialWriteZ );

	// nBatchIndexCount and nBatchVertexCount are the number of indices and vertices we can fit in this batch
	// Each batch must have fewe than nMaxIndices and nMaxVertices or the material system will fail
	int nBatchIndexCount  = min( nIndexCount,  nMaxIndices  );
	int nBatchVertexCount = min( nVertexCount, nMaxVertices );

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nBatchVertexCount, nBatchIndexCount );

	int nStartVert = 0;
	for ( g = 0; g < MAX_MAT_SORT_GROUPS; ++g )
	{
		if ( ( flags & ( 1 << g ) ) == 0 )
			continue;

		int nSortGroup = s_DrawWorldListsToSortGroup[g];
		MSL_FOREACH_GROUP_BEGIN(sortList, nSortGroup, group )
		{
			SurfaceHandle_t surfID = sortList.GetSurfaceAtHead(group);

			// Check to see if we can add this list to the current batch...
			int nCurrIndexCount = group.indexCountNoDetail;
			int nCurrVertexCount = group.vertexCountNoDetail;
			if ( ( nCurrIndexCount == 0 ) || ( nCurrVertexCount == 0 ) )
				continue;

			IMaterial *pMaterial = MSurf_TexInfo( surfID )->material;

			if( pMaterial->IsAlphaTested() || pMaterial->IsTranslucent() )
				continue;

			Assert( nCurrIndexCount  <= nMaxIndices  );
			Assert( nCurrVertexCount <= nMaxVertices );

			if ( ( nBatchIndexCount < nCurrIndexCount ) || ( nBatchVertexCount < nCurrVertexCount ) )
			{
				// Nope, fire off the current batch...
				meshBuilder.End();
				pMesh->Draw();
				nBatchIndexCount  = min( nIndexCount,  nMaxIndices  );
				nBatchVertexCount = min( nVertexCount, nMaxVertices );
				pMesh = pRenderContext->GetDynamicMesh( false );
				meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nBatchVertexCount, nBatchIndexCount );
				nStartVert = 0;
			}

			nBatchIndexCount  -= nCurrIndexCount;
			nIndexCount       -= nCurrIndexCount;
			nBatchVertexCount -= nCurrVertexCount;
			nVertexCount      -= nCurrVertexCount;

			// only draw surfaces on nodes (i.e. no detail surfaces)
			Shader_WorldZFillSurfChain( sortList, group, meshBuilder, nStartVert, SURFDRAW_NODE );
		}
		MSL_FOREACH_GROUP_END()
	}

	meshBuilder.End();
	pMesh->Draw();

	// FIXME: Do fast z reject on displacements!
}

//-----------------------------------------------------------------------------
// Call this after lists of stuff to render are made; it renders opaque surfaces
//-----------------------------------------------------------------------------
static void Shader_WorldEnd( CWorldRenderList *pRenderList, unsigned long flags, float waterZAdjust )
{
	VPROF("Shader_WorldEnd");

	CMatRenderContextPtr pRenderContext( materials );

	if ( flags & ( DRAWWORLDLISTS_DRAW_SHADOWDEPTH | DRAWWORLDLISTS_DRAW_SSAO ) )
	{
		Shader_WorldShadowDepthFill( pRenderList, flags );
		return;
	}

	// Draw the skybox
	if ( flags & DRAWWORLDLISTS_DRAW_SKYBOX )
	{
		if ( pRenderList->m_bSkyVisible || Map_VisForceFullSky() )
		{
			if( flags & DRAWWORLDLISTS_DRAW_CLIPSKYBOX )
			{
				R_DrawSkyBox( g_EngineRenderer->GetZFar() );
			}
			else
			{
				// Don't clip the skybox with height clip in this path.
				MaterialHeightClipMode_t nClipMode = pRenderContext->GetHeightClipMode();
				pRenderContext->SetHeightClipMode( MATERIAL_HEIGHTCLIPMODE_DISABLE );
				R_DrawSkyBox( g_EngineRenderer->GetZFar() );
				pRenderContext->SetHeightClipMode( nClipMode );
			}
		}
	}

	// Perform the fast z-fill pass
	bool bFastZReject = (r_fastzreject.GetInt() != 0);
	if ( bFastZReject )
	{
		Shader_WorldZFill( pRenderList, flags );
	}
	
	// Gotta draw each sort group
	// Draw the fog volume first, if there is one, because it turns out
	// that we only draw fog volumes if we're in the fog volume, which
	// means it's closer. We want to render closer things first to get
	// fast z-reject.
	int i;
	for ( i = MAX_MAT_SORT_GROUPS; --i >= 0; )
	{
		if ( !( flags & ( 1 << i ) ) )
			continue;

		int nSortGroup = s_DrawWorldListsToSortGroup[i];
		if ( nSortGroup == MAT_SORT_GROUP_WATERSURFACE  )
		{
			if ( waterZAdjust != 0.0f )
			{
				pRenderContext->MatrixMode( MATERIAL_MODEL );
				pRenderContext->PushMatrix();
				pRenderContext->LoadIdentity();
				pRenderContext->Translate( 0.0f, 0.0f, waterZAdjust );
			}
		}

		// Draws opaque displacement surfaces along with shadows, overlays, flashlights, etc.
		Shader_DrawDispChain( nSortGroup, pRenderList->m_DispSortList, flags, DEPTH_MODE_NORMAL );

		// Draws opaque non-displacement surfaces
		// This also add shadows to pRenderList->m_ShadowHandles.
		Shader_DrawChains( pRenderList, nSortGroup, false );
		AddProjectedTextureDecalsToList( pRenderList, nSortGroup );

		// Adds shadows to render lists
		for ( int j = pRenderList->m_ShadowHandles[nSortGroup].Count()-1; j >= 0; --j )
		{
			g_pShadowMgr->AddShadowsOnSurfaceToRenderList( pRenderList->m_ShadowHandles[nSortGroup].Element(j) );
		}
		pRenderList->m_ShadowHandles[nSortGroup].RemoveAll();

		// Don't stencil or scissor the flashlight if we're rendering to an offscreen view
		bool bFlashlightMask = !( (flags & DRAWWORLDLISTS_DRAW_REFRACTION ) || (flags & DRAWWORLDLISTS_DRAW_REFLECTION ));

		// Set masking stencil bits for flashlights
		g_pShadowMgr->SetFlashlightStencilMasks( bFlashlightMask );

		// Draw shadows and flashlights on world surfaces
		g_pShadowMgr->RenderFlashlights( bFlashlightMask );

		// Render the fragments from the surfaces + displacements.
		// FIXME: Actually, this call is irrelevant (for displacements) because it's done from
		// within DrawDispChain currently, but that should change.
		// We need to split out the disp decal rendering from DrawDispChain
		// and do it after overlays are rendered....
		OverlayMgr()->RenderOverlays( nSortGroup );
		g_pShadowMgr->DrawFlashlightOverlays( nSortGroup, bFlashlightMask );
		OverlayMgr()->ClearRenderLists( nSortGroup );

		// Draws decals lying on opaque non-displacement surfaces
		DecalSurfaceDraw( pRenderContext, nSortGroup );

		// Draw the flashlight lighting for the decals.
		g_pShadowMgr->DrawFlashlightDecals( nSortGroup, bFlashlightMask );

		// Draw RTT shadows
		g_pShadowMgr->RenderShadows( );
		g_pShadowMgr->ClearShadowRenderList();

		if ( nSortGroup == MAT_SORT_GROUP_WATERSURFACE && waterZAdjust != 0.0f )
		{
			pRenderContext->MatrixMode( MATERIAL_MODEL );
			pRenderContext->PopMatrix();
		}
	}
}


//-----------------------------------------------------------------------------
// Renders translucent surfaces
//-----------------------------------------------------------------------------
bool Shader_LeafContainsTranslucentSurfaces( IWorldRenderList *pRenderListIn, int sortIndex, unsigned long flags )
{
	CWorldRenderList *pRenderList = assert_cast<CWorldRenderList *>(pRenderListIn);
	int i;
	for ( i = 0; i < MAX_MAT_SORT_GROUPS; ++i )
	{
		if( !( flags & ( 1 << i ) ) )
			continue;

		int sortGroup = s_DrawWorldListsToSortGroup[i];
	
		// Set the fog state here since it will be the same for all things
		// in this list of translucent objects (except for displacements)
		const surfacesortgroup_t &group = pRenderList->m_AlphaSortList.GetGroupForSortID( sortGroup, sortIndex );
		if ( group.surfaceCount )
			return true;
		const surfacesortgroup_t &dispGroup = pRenderList->m_DispAlphaSortList.GetGroupForSortID( sortGroup, sortIndex );
		if ( dispGroup.surfaceCount )
			return true;
	}

	return false;
}

void Shader_DrawTranslucentSurfaces( IWorldRenderList *pRenderListIn, int sortIndex, unsigned long flags, bool bShadowDepth )
{
	if ( !r_drawtranslucentworld.GetBool() )
		return;

	CWorldRenderList *pRenderList = assert_cast<CWorldRenderList *>(pRenderListIn);

	CMatRenderContextPtr pRenderContext( materials );

	bool skipLight = false;
	if ( g_pMaterialSystemConfig->nFullbright == 1 )
	{
		pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP );
		skipLight = true;
	}



	// Gotta draw each sort group
	// Draw the fog volume first, if there is one, because it turns out
	// that we only draw fog volumes if we're in the fog volume, which
	// means it's closer. We want to render closer things first to get
	// fast z-reject.
	int i;
	CUtlVector<msurface2_t *> surfaceList;
	for ( i = 0; i < MAX_MAT_SORT_GROUPS; ++i )
	{
		if( !( flags & ( 1 << i ) ) )
		{
			continue;
		}
		int sortGroup = s_DrawWorldListsToSortGroup[i];
	
		// Set the fog state here since it will be the same for all things
		// in this list of translucent objects (except for displacements)

		surfaceList.RemoveAll();
		const surfacesortgroup_t &group = pRenderList->m_AlphaSortList.GetGroupForSortID( sortGroup, sortIndex );
		const surfacesortgroup_t &dispGroup = pRenderList->m_DispAlphaSortList.GetGroupForSortID( sortGroup, sortIndex );
		// Empty? skip...
		if (!group.surfaceCount && !dispGroup.surfaceCount )
			continue;

		pRenderList->m_AlphaSortList.GetSurfaceListForGroup( surfaceList, group );

		// Interate in back-to-front order
		for ( int listIndex = surfaceList.Count(); --listIndex >= 0; )
		{
			SurfaceHandle_t surfID = surfaceList[listIndex];
			pRenderContext->Bind( MSurf_TexInfo( surfID )->material );

			Assert( MSurf_MaterialSortID( surfID ) >= 0 && 
				    MSurf_MaterialSortID( surfID ) < g_WorldStaticMeshes.Count() );

			if ( !skipLight )
			{
				pRenderContext->BindLightmapPage( materialSortInfoArray[MSurf_MaterialSortID( surfID )].lightmapPageID );
			}
			
//			NOTE: Since a static vb/dynamic ib IMesh doesn't buffer, we shouldn't use this
//			since it causes a lock and drawindexedprimitive per surface! (gary)
//			Shader_DrawSurfaceStatic( surfID );
			Shader_DrawSurfaceDynamic( pRenderContext, surfID, false );

//			g_pShadowMgr->ClearShadowRenderList();

			// Add shadows/flashlights to list.
			ShadowDecalHandle_t decalHandle = MSurf_ShadowDecals( surfID );
			if (decalHandle != SHADOW_DECAL_HANDLE_INVALID)
			{
				g_pShadowMgr->AddShadowsOnSurfaceToRenderList( decalHandle );
			}

			bool bFlashlightMask = !( (flags & DRAWWORLDLISTS_DRAW_REFRACTION ) || (flags & DRAWWORLDLISTS_DRAW_REFLECTION ));

			// Draw flashlights
			g_pShadowMgr->RenderFlashlights( bFlashlightMask );

			// Draw overlays on the surface.
			OverlayMgr()->AddFragmentListToRenderList( i, MSurf_OverlayFragmentList( surfID ), false );
			OverlayMgr()->RenderOverlays( i );

			// Draw flashlight overlays
			g_pShadowMgr->DrawFlashlightOverlays( i, bFlashlightMask );
			OverlayMgr()->ClearRenderLists( i );

		    // Draw decals on the surface
			DrawDecalsOnSingleSurface( pRenderContext, surfID );

			// Draw flashlight decals
			g_pShadowMgr->DrawFlashlightDecalsOnSingleSurface( surfID, bFlashlightMask );

			// draw shadows
			g_pShadowMgr->RenderShadows();
			g_pShadowMgr->ClearShadowRenderList();
		}
		// Draw wireframe, etc information
		DrawDebugInformation( surfaceList );

		// Now draw the translucent displacements; we need to do these *after* the
		// non-displacement surfaces because most likely the displacement will always
		// be in front (or at least not behind) the non-displacement translucent surfaces
		// that exist in the same leaf.
		
		// Draws translucent displacement surfaces

		surfaceList.RemoveAll();
		surfaceList.EnsureCapacity(dispGroup.surfaceCount);
		MSL_FOREACH_SURFACE_IN_GROUP_BEGIN(pRenderList->m_DispAlphaSortList, dispGroup, surfID)
		{
			surfaceList.AddToTail(surfID);
		}
		MSL_FOREACH_SURFACE_IN_GROUP_END()

		DispInfo_RenderList( i, surfaceList.Base(), surfaceList.Count(), g_EngineRenderer->ViewGetCurrent().m_bOrtho, flags, DEPTH_MODE_NORMAL );
	}
}



//=============================================================
//
//	WORLD MODEL
//
//=============================================================

void FASTCALL R_DrawSurface( CWorldRenderList *pRenderList, SurfaceHandle_t surfID )
{
	ASSERT_SURF_VALID( surfID );
	Assert( !SurfaceHasDispInfo( surfID ) );
	if ( MSurf_Flags( surfID ) & SURFDRAW_SKY )
	{
		pRenderList->m_bSkyVisible = true;
	}
//	else if ( surf->texinfo->material->IsTranslucent() )
	else if( MSurf_Flags( surfID ) & SURFDRAW_TRANS )
	{
		Shader_TranslucentWorldSurface( pRenderList, surfID );
	}
	else
	{
		Shader_WorldSurface( pRenderList, surfID );
	}
}

// The NoCull flavor of this function calls functions which optimize for shadow depth map rendering
void FASTCALL R_DrawSurfaceNoCull( CWorldRenderList *pRenderList, SurfaceHandle_t surfID )
{
	ASSERT_SURF_VALID( surfID );
	if( !(MSurf_Flags( surfID ) & SURFDRAW_TRANS) && !(MSurf_Flags( surfID ) & SURFDRAW_SKY) )
	{
		Shader_WorldSurfaceNoCull( pRenderList, surfID );
	}
}

//-----------------------------------------------------------------------------
// Draws displacements in a leaf
//-----------------------------------------------------------------------------
static inline void DrawDisplacementsInLeaf( CWorldRenderList *pRenderList, mleaf_t* pLeaf )
{
	// add displacement surfaces
	if (!pLeaf->dispCount)
		return;

	CVisitedSurfs &visitedSurfs = pRenderList->m_VisitedSurfs;
	for ( int i = 0; i < pLeaf->dispCount; i++ )
	{
		IDispInfo *pDispInfo = MLeaf_Disaplcement( pLeaf, i );

		// NOTE: We're not using the displacement's touched method here 
		// because we're just using the parent surface's visframe in the
		// surface add methods below...
		SurfaceHandle_t parentSurfID = pDispInfo->GetParent();

		// already processed this frame? Then don't do it again!
		if ( VisitSurface( visitedSurfs, parentSurfID ) )
		{
			if ( MSurf_Flags( parentSurfID ) & SURFDRAW_TRANS)
			{
				Shader_TranslucentDisplacementSurface( pRenderList, parentSurfID );
			}
			else
			{
				Shader_DisplacementSurface( pRenderList, parentSurfID );
			}
		}
	}
}

int LeafToIndex( mleaf_t* pLeaf );

//-----------------------------------------------------------------------------
// Updates visibility + alpha lists
//-----------------------------------------------------------------------------
static inline void UpdateVisibleLeafLists( CWorldRenderList *pRenderList, mleaf_t* pLeaf )
{
	// Consistency check...
	MEM_ALLOC_CREDIT();
	
	// Add this leaf to the list of visible leafs
	int nLeafIndex = LeafToIndex( pLeaf );
	pRenderList->m_VisibleLeaves.AddToTail( nLeafIndex );
	int leafCount = pRenderList->m_VisibleLeaves.Count();
	pRenderList->m_VisibleLeafFogVolumes.AddToTail( pLeaf->leafWaterDataID );
	pRenderList->m_AlphaSortList.EnsureMaxSortIDs( leafCount );
	pRenderList->m_DispAlphaSortList.EnsureMaxSortIDs( leafCount );
}

 
//-----------------------------------------------------------------------------
// Draws all displacements + surfaces in a leaf
//-----------------------------------------------------------------------------
static void FASTCALL R_DrawLeaf( CWorldRenderList *pRenderList, mleaf_t *pleaf )
{
	// Add this leaf to the list of visible leaves
	UpdateVisibleLeafLists( pRenderList, pleaf );

	// Debugging to only draw at a particular leaf
#ifdef USE_CONVARS
	if ( (s_ShaderConvars.m_nDrawLeaf >= 0) && (s_ShaderConvars.m_nDrawLeaf != LeafToIndex(pleaf)) )
		return;
#endif

	// add displacement surfaces
	DrawDisplacementsInLeaf( pRenderList, pleaf );

#ifdef USE_CONVARS
	if( !s_ShaderConvars.m_bDrawWorld )
		return;
#endif

	// Add non-displacement surfaces
	int i;
	int nSurfaceCount = pleaf->nummarknodesurfaces;
	SurfaceHandle_t *pSurfID = &host_state.worldbrush->marksurfaces[pleaf->firstmarksurface];
	CVisitedSurfs &visitedSurfs = pRenderList->m_VisitedSurfs;
	for ( i = 0; i < nSurfaceCount; ++i )
	{
		// garymctoptimize - can we prefetch the next surfaces?
		// We seem to be taking a huge hit here for referencing the surface for the first time.
		SurfaceHandle_t surfID = pSurfID[i];
		ASSERT_SURF_VALID( surfID );
		// there are never any displacements or nodraws in the leaf list
		Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );
		Assert( (MSurf_Flags( surfID ) & SURFDRAW_NODE) );
		Assert( !SurfaceHasDispInfo(surfID) );
		// mark this one to be drawn at the node
		MarkSurfaceVisited( visitedSurfs, surfID );
	}

#ifdef USE_CONVARS
	if( !s_ShaderConvars.m_bDrawFuncDetail )
		return;
#endif

	for ( ; i < pleaf->nummarksurfaces; i++ )
	{
		SurfaceHandle_t surfID = pSurfID[i];

		// Don't process the same surface twice
		if ( !VisitSurface( visitedSurfs, surfID ) )
			continue;

		Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODE) );

		// Back face cull; only func_detail are drawn here
		if ( (MSurf_Flags( surfID ) & SURFDRAW_NOCULL) == 0 )
		{
			if ( (DotProduct(MSurf_Plane( surfID ).normal, modelorg) -
				  MSurf_Plane( surfID ).dist ) < BACKFACE_EPSILON )
				continue;
		}

		R_DrawSurface( pRenderList, surfID );
	}
}

static ConVar r_frustumcullworld( "r_frustumcullworld", "1" );

static void FASTCALL R_DrawLeafNoCull( CWorldRenderList *pRenderList, mleaf_t *pleaf )
{
	// Add this leaf to the list of visible leaves
	UpdateVisibleLeafLists( pRenderList, pleaf );

	// add displacement surfaces
	DrawDisplacementsInLeaf( pRenderList, pleaf );
	int i;
	SurfaceHandle_t *pSurfID = &host_state.worldbrush->marksurfaces[pleaf->firstmarksurface];
	CVisitedSurfs &visitedSurfs = pRenderList->m_VisitedSurfs;
	for ( i = 0; i < pleaf->nummarksurfaces; i++ )
	{
		SurfaceHandle_t surfID = pSurfID[i];

		// Don't process the same surface twice
		if ( !VisitSurface( visitedSurfs, surfID ) )
			continue;

		R_DrawSurfaceNoCull( pRenderList, surfID );
	}
}

//-----------------------------------------------------------------------------
// Purpose: recurse on the BSP tree, calling the surface visitor
// Input  : *node - BSP node
//-----------------------------------------------------------------------------
static void R_RecursiveWorldNodeNoCull( CWorldRenderList *pRenderList, mnode_t *node, int nCullMask )
{
	int			side;
	cplane_t	*plane;
	float		dot;

	while (true)
	{
		// no polygons in solid nodes
		if (node->contents == CONTENTS_SOLID)
			return;		// solid

		// Check PVS signature
		if (node->visframe != r_visframecount)
			return;

		// Cull against the screen frustum or the appropriate area's frustum.
		if ( nCullMask != FRUSTUM_SUPPRESS_CLIPPING )
		{
			if (node->contents >= -1)
			{
				if ((nCullMask != 0) || ( node->area > 0 ))
				{
					if ( R_CullNode( &g_Frustum, node, nCullMask ) )
						return;
				}
			}
			else
			{
				// This prevents us from culling nodes that are too small to worry about
				if (node->contents == -2)
				{
					nCullMask = FRUSTUM_SUPPRESS_CLIPPING;
				}
			}
		}

		// if a leaf node, draw stuff
		if (node->contents >= 0)
		{
			R_DrawLeafNoCull( pRenderList, (mleaf_t *)node );
			return;
		}

		// node is just a decision point, so go down the appropriate sides

		// find which side of the node we are on
		plane = node->plane;
		if ( plane->type <= PLANE_Z )
		{
			dot = modelorg[plane->type] - plane->dist;
		}
		else
		{
			dot = DotProduct (modelorg, plane->normal) - plane->dist;
		}

		// recurse down the children, closer side first.
		// We have to do this because we need to find if the surfaces at this node
		// exist in any visible leaves closer to the camera than the node is. If so,
		// their r_surfacevisframe is set to indicate that we need to render them
		// at this node.
		side = dot >= 0 ? 0 : 1;

		// Recurse down the side closer to the camera
		R_RecursiveWorldNodeNoCull (pRenderList, node->children[side], nCullMask );

		// recurse down the side farther from the camera
		// NOTE: With this while loop, this is identical to just calling
		// R_RecursiveWorldNodeNoCull (node->children[!side], nCullMask );
		node = node->children[!side];
	}
}


//-----------------------------------------------------------------------------
// Purpose: recurse on the BSP tree, calling the surface visitor
// Input  : *node - BSP node
//-----------------------------------------------------------------------------

static void R_RecursiveWorldNode( CWorldRenderList *pRenderList, mnode_t *node, int nCullMask )
{
	int			side;
	cplane_t	*plane;
	float		dot;

	while (true)
	{
		// no polygons in solid nodes
		if (node->contents == CONTENTS_SOLID)
			return;		// solid

		// Check PVS signature
		if (node->visframe != r_visframecount)
			return;

		// Cull against the screen frustum or the appropriate area's frustum.
		if ( nCullMask != FRUSTUM_SUPPRESS_CLIPPING )
		{
			if (node->contents >= -1)
			{
				if ((nCullMask != 0) || ( node->area > 0 ))
				{
					if ( R_CullNode( &g_Frustum, node, nCullMask ) )
						return;
				}
			}
			else
			{
				// This prevents us from culling nodes that are too small to worry about
				if (node->contents == -2)
				{
					nCullMask = FRUSTUM_SUPPRESS_CLIPPING;
				}
			}
		}

		// if a leaf node, draw stuff
		if (node->contents >= 0)
		{
			R_DrawLeaf( pRenderList, (mleaf_t *)node );
			return;
		}

		// node is just a decision point, so go down the appropriate sides

		// find which side of the node we are on
		plane = node->plane;
		if ( plane->type <= PLANE_Z )
		{
			dot = modelorg[plane->type] - plane->dist;
		}
		else
		{
			dot = DotProduct (modelorg, plane->normal) - plane->dist;
		}

		// recurse down the children, closer side first.
		// We have to do this because we need to find if the surfaces at this node
		// exist in any visible leaves closer to the camera than the node is. If so,
		// their r_surfacevisframe is set to indicate that we need to render them
		// at this node.
		side = dot >= 0 ? 0 : 1;

		// Recurse down the side closer to the camera
		R_RecursiveWorldNode (pRenderList, node->children[side], nCullMask );

		// draw stuff on the node

		SurfaceHandle_t surfID = SurfaceHandleFromIndex( node->firstsurface );
		int i = MSurf_Index( surfID );
		int nLastSurface = i + node->numsurfaces;
		CVisitedSurfs &visitedSurfs = pRenderList->m_VisitedSurfs;
		for ( ; i < nLastSurface; ++i, ++surfID )
		{
			// Only render things at this node that have previously been marked as visible
			if ( !VisitedSurface( visitedSurfs, i ) )
				continue;

			// Don't add surfaces that have displacement
			// UNDONE: Don't emit these at nodes in vbsp!
			// UNDONE: Emit them at the end of the surface list
			Assert( !SurfaceHasDispInfo( surfID ) );

			// If a surface is marked to draw at a node, then it's not a func_detail.
			// Only func_detail render at leaves. In the case of normal world surfaces,
			// we only want to render them if they intersect a visible leaf.
			int nFlags = MSurf_Flags( surfID );

			Assert( nFlags & SURFDRAW_NODE );

			Assert( !(nFlags & SURFDRAW_NODRAW) );

			if ( !(nFlags & SURFDRAW_UNDERWATER) && ( side ^ !!(nFlags & SURFDRAW_PLANEBACK)) )
				continue;		// wrong side

			R_DrawSurface( pRenderList, surfID );
		}

		// recurse down the side farther from the camera
		// NOTE: With this while loop, this is identical to just calling
		// R_RecursiveWorldNode (node->children[!side], nCullMask );
		node = node->children[!side];
	}
}


//-----------------------------------------------------------------------------
// Set up fog for a particular leaf
//-----------------------------------------------------------------------------
#define INVALID_WATER_HEIGHT 1000000.0f
inline float R_GetWaterHeight( int nFogVolume )
{
	if( nFogVolume < 0 || nFogVolume > host_state.worldbrush->numleafwaterdata )
		return INVALID_WATER_HEIGHT;

	mleafwaterdata_t* pLeafWaterData = &host_state.worldbrush->leafwaterdata[nFogVolume];
	return pLeafWaterData->surfaceZ;
}

IMaterial *R_GetFogVolumeMaterial( int nFogVolume, bool bEyeInFogVolume )
{
	if( nFogVolume < 0 || nFogVolume > host_state.worldbrush->numleafwaterdata )
		return NULL;

	mleafwaterdata_t* pLeafWaterData = &host_state.worldbrush->leafwaterdata[nFogVolume];
	mtexinfo_t* pTexInfo = &host_state.worldbrush->texinfo[pLeafWaterData->surfaceTexInfoID];

	IMaterial* pMaterial = pTexInfo->material;
	if( bEyeInFogVolume )
	{
		IMaterialVar *pVar = pMaterial->FindVar( "$bottommaterial", NULL );
		if( pVar )
		{
			const char *pMaterialName = pVar->GetStringValue();
			if( pMaterialName )
			{
				pMaterial = materials->FindMaterial( pMaterialName, TEXTURE_GROUP_OTHER );
			}
		}
	}
	return pMaterial;
}

void R_SetFogVolumeState( int fogVolume, bool useHeightFog )
{
	// useHeightFog == eye out of water
	// !useHeightFog == eye in water
	IMaterial *pMaterial = R_GetFogVolumeMaterial( fogVolume, !useHeightFog );
	mleafwaterdata_t* pLeafWaterData = &host_state.worldbrush->leafwaterdata[fogVolume];
	IMaterialVar* pFogColorVar	= pMaterial->FindVar( "$fogcolor", NULL );
	IMaterialVar* pFogEnableVar = pMaterial->FindVar( "$fogenable", NULL );
	IMaterialVar* pFogStartVar	= pMaterial->FindVar( "$fogstart", NULL );
	IMaterialVar* pFogEndVar	= pMaterial->FindVar( "$fogend", NULL );

	CMatRenderContextPtr pRenderContext( materials );

	if( pMaterial && pFogEnableVar->GetIntValueFast() && fog_enable_water_fog.GetBool() )
	{
		pRenderContext->SetFogZ( pLeafWaterData->surfaceZ );
		if( useHeightFog )
		{
			pRenderContext->FogMode( MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
		}
		else
		{
			pRenderContext->FogMode( MATERIAL_FOG_LINEAR );
		}
		float fogColor[3];
		pFogColorVar->GetVecValueFast( fogColor, 3 );

		pRenderContext->FogColor3fv( fogColor );
		pRenderContext->FogStart( pFogStartVar->GetFloatValueFast() );
		pRenderContext->FogEnd( pFogEndVar->GetFloatValueFast() );
		pRenderContext->FogMaxDensity( 1.0 );
	}
	else
	{
		pRenderContext->FogMode( MATERIAL_FOG_NONE );
	}
}

static inline bool R_CullNodeTopView( mnode_t *pNode )
{
	Vector2D delta, size;
	Vector2DSubtract( pNode->m_vecCenter.AsVector2D(), s_OrthographicCenter, delta );
	Vector2DAdd( pNode->m_vecHalfDiagonal.AsVector2D(), s_OrthographicHalfDiagonal, size );
	return ( FloatMakePositive( delta.x ) > size.x ) ||
		( FloatMakePositive( delta.y ) > size.y );
}


//-----------------------------------------------------------------------------
// Draws all displacements + surfaces in a leaf
//-----------------------------------------------------------------------------
static void R_DrawTopViewLeaf( CWorldRenderList *pRenderList, mleaf_t *pleaf )
{
	// Add this leaf to the list of visible leaves
	UpdateVisibleLeafLists( pRenderList, pleaf );

	// add displacement surfaces
	DrawDisplacementsInLeaf( pRenderList, pleaf );

#ifdef USE_CONVARS
	if( !s_ShaderConvars.m_bDrawWorld )
		return;
#endif

	// Add non-displacement surfaces
	SurfaceHandle_t *pHandle = &host_state.worldbrush->marksurfaces[pleaf->firstmarksurface];
	CVisitedSurfs &visitedSurfs = pRenderList->m_VisitedSurfs;
	for ( int i = 0; i < pleaf->nummarksurfaces; i++ )
	{
		SurfaceHandle_t surfID = pHandle[i];

		// Mark this surface as being in a visible leaf this frame. If this
		// surface is meant to be drawn at a node (SURFDRAW_NODE), 
		// then it will be drawn in the recursive code down below.
		if ( !VisitSurface( visitedSurfs, surfID ) )
			continue;

		// Don't add surfaces that have displacement; they are handled above
		// In fact, don't even set the vis frame; we need it unset for translucent
		// displacement code
		if ( SurfaceHasDispInfo(surfID) )
			continue;

		if ( MSurf_Flags( surfID ) & SURFDRAW_NODE )
			continue;

		Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );

		// Back face cull; only func_detail are drawn here
		if ( (MSurf_Flags( surfID ) & SURFDRAW_NOCULL) == 0 )
		{
			if (MSurf_Plane( surfID ).normal.z <= 0.0f)
				continue;
		}

		// FIXME: For now, blow off translucent world polygons.
		// Gotta solve the problem of how to render them all, unsorted,
		// in a pass after the opaque world polygons, and before the
		// translucent entities.

		if ( !( MSurf_Flags( surfID ) & SURFDRAW_TRANS ))
//		if ( !surf->texinfo->material->IsTranslucent() )
			Shader_WorldSurface( pRenderList, surfID );
	}
}


//-----------------------------------------------------------------------------
// Fast path for rendering top-views
//-----------------------------------------------------------------------------
void R_RenderWorldTopView( CWorldRenderList *pRenderList, mnode_t *node )
{
	CVisitedSurfs &visitedSurfs = pRenderList->m_VisitedSurfs;
	do
	{
		// no polygons in solid nodes
		if (node->contents == CONTENTS_SOLID)
			return;		// solid

		// Check PVS signature
		if (node->visframe != r_visframecount)
			return;

		// Cull against the screen frustum or the appropriate area's frustum.
		if( R_CullNodeTopView( node ) )
			return;

		// if a leaf node, draw stuff
		if (node->contents >= 0)
		{
			R_DrawTopViewLeaf( pRenderList, (mleaf_t *)node );
			return;
		}

#ifdef USE_CONVARS
		if (s_ShaderConvars.m_bDrawWorld)
#endif
		{
			// draw stuff on the node
			SurfaceHandle_t surfID = SurfaceHandleFromIndex( node->firstsurface );
			for ( int i = 0; i < node->numsurfaces; i++, surfID++ )
			{
				if ( !VisitSurface( visitedSurfs, surfID ) )
					continue;

				// Don't add surfaces that have displacement
				if ( SurfaceHasDispInfo( surfID ) )
					continue;

				// If a surface is marked to draw at a node, then it's not a func_detail.
				// Only func_detail render at leaves. In the case of normal world surfaces,
				// we only want to render them if they intersect a visible leaf.
				Assert( (MSurf_Flags( surfID ) & SURFDRAW_NODE) );

				if ( MSurf_Flags( surfID ) & (SURFDRAW_UNDERWATER|SURFDRAW_SKY) )
					continue;

				Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );
				// Back face cull
				if ( (MSurf_Flags( surfID ) & SURFDRAW_NOCULL) == 0 )
				{
					if (MSurf_Plane( surfID ).normal.z <= 0.0f)
						continue;
				}

				// FIXME: For now, blow off translucent world polygons.
				// Gotta solve the problem of how to render them all, unsorted,
				// in a pass after the opaque world polygons, and before the
				// translucent entities.

				if ( !( MSurf_Flags( surfID ) & SURFDRAW_TRANS ) )
//				if ( !surf->texinfo->material->IsTranslucent() )
					Shader_WorldSurface( pRenderList, surfID );
			}
		}

		// Recurse down both children, we don't care the order...
		R_RenderWorldTopView ( pRenderList, node->children[0]);
		node = node->children[1];

	} while (node);
}

//-----------------------------------------------------------------------------
// Spews the leaf we're in
//-----------------------------------------------------------------------------
static void SpewLeaf()
{
	int leaf = CM_PointLeafnum( g_EngineRenderer->ViewOrigin() );
	ConMsg(	"view leaf %d\n", leaf );
}


//-----------------------------------------------------------------------------
// Main entry points for starting + ending rendering the world
//-----------------------------------------------------------------------------
void R_BuildWorldLists( IWorldRenderList *pRenderListIn, WorldListInfo_t* pInfo, 
	int iForceViewLeaf, const VisOverrideData_t* pVisData, bool bShadowDepth /* = false */, float *pWaterReflectionHeight )
{
	CWorldRenderList *pRenderList = assert_cast<CWorldRenderList *>(pRenderListIn);
	// Safety measure just in case. I haven't seen that we need this, but...
	if ( g_LostVideoMemory )
	{
		if (pInfo)
		{
			pInfo->m_ViewFogVolume = MAT_SORT_GROUP_STRICTLY_ABOVEWATER;
			pInfo->m_LeafCount = 0;
			pInfo->m_pLeafList = pRenderList->m_VisibleLeaves.Base();
			pInfo->m_pLeafFogVolume = pRenderList->m_VisibleLeafFogVolumes.Base();
		}
		return;
	}

	VPROF( "R_BuildWorldLists" );
	VectorCopy( g_EngineRenderer->ViewOrigin(), modelorg );

#ifdef USE_CONVARS
	static ConVar r_spewleaf("r_spewleaf", "0");
	if ( r_spewleaf.GetInt() )
	{
		SpewLeaf();
	}
#endif

	Shader_WorldBegin( pRenderList );

	if ( !r_drawtopview )
	{
		R_SetupAreaBits( iForceViewLeaf, pVisData, pWaterReflectionHeight );

		if ( bShadowDepth )
		{
			R_RecursiveWorldNodeNoCull( pRenderList, host_state.worldbrush->nodes, r_frustumcullworld.GetBool() ? FRUSTUM_CLIP_ALL : FRUSTUM_SUPPRESS_CLIPPING );
		}
		else
		{
			R_RecursiveWorldNode( pRenderList, host_state.worldbrush->nodes, r_frustumcullworld.GetBool() ? FRUSTUM_CLIP_ALL : FRUSTUM_SUPPRESS_CLIPPING );
		}
	}
	else
	{
		R_RenderWorldTopView( pRenderList, host_state.worldbrush->nodes );
	}

		// This builds all lightmaps, including those for translucent surfaces
	// Don't bother in topview?
	if ( !r_drawtopview && !bShadowDepth )
	{
		Shader_BuildDynamicLightmaps( pRenderList );
	}

	// Return the back-to-front leaf ordering
	if ( pInfo )
	{
		// Compute fog volume info for rendering
		if ( !bShadowDepth )
		{
			FogVolumeInfo_t fogInfo;
			ComputeFogVolumeInfo( &fogInfo );
			if( fogInfo.m_InFogVolume )
			{
				pInfo->m_ViewFogVolume = MAT_SORT_GROUP_STRICTLY_UNDERWATER;
			}
			else
			{
				pInfo->m_ViewFogVolume = MAT_SORT_GROUP_STRICTLY_ABOVEWATER;
			}
		}
		else
		{
			pInfo->m_ViewFogVolume = MAT_SORT_GROUP_STRICTLY_ABOVEWATER;
		}
		pInfo->m_LeafCount = pRenderList->m_VisibleLeaves.Count();
		pInfo->m_pLeafList = pRenderList->m_VisibleLeaves.Base();
		pInfo->m_pLeafFogVolume = pRenderList->m_VisibleLeafFogVolumes.Base();
	}
}


//-----------------------------------------------------------------------------
// Used to determine visible fog volumes
//-----------------------------------------------------------------------------
class CVisibleFogVolumeQuery
{
public:
	void FindVisibleFogVolume( const Vector &vecViewPoint, int *pVisibleFogVolume, int *pVisibleFogVolumeLeaf );

private:
	bool RecursiveGetVisibleFogVolume( mnode_t *node );

	// Input
	Vector m_vecSearchPoint;

	// Output
	int m_nVisibleFogVolume;
	int m_nVisibleFogVolumeLeaf;
};


//-----------------------------------------------------------------------------
// Main entry point for the query
//-----------------------------------------------------------------------------
void CVisibleFogVolumeQuery::FindVisibleFogVolume( const Vector &vecViewPoint, int *pVisibleFogVolume, int *pVisibleFogVolumeLeaf )
{
	R_SetupAreaBits();

	m_vecSearchPoint = vecViewPoint;
	m_nVisibleFogVolume = -1;
	m_nVisibleFogVolumeLeaf = -1;

	RecursiveGetVisibleFogVolume( host_state.worldbrush->nodes );

	*pVisibleFogVolume = m_nVisibleFogVolume;
	*pVisibleFogVolumeLeaf = m_nVisibleFogVolumeLeaf;
}


//-----------------------------------------------------------------------------
// return true to continue searching
//-----------------------------------------------------------------------------
bool CVisibleFogVolumeQuery::RecursiveGetVisibleFogVolume( mnode_t *node )
{
	int			side;
	cplane_t	*plane;
	float		dot;

	// no polygons in solid nodes
	if (node->contents == CONTENTS_SOLID)
		return true;		// solid

	// Check PVS signature
	if (node->visframe != r_visframecount)
		return true;

	// Cull against the screen frustum or the appropriate area's frustum.
	int fixmeTempRemove = FRUSTUM_CLIP_ALL;
	if( R_CullNode( &g_Frustum, node, fixmeTempRemove ) )
		return true;

	// if a leaf node, check if we are in a fog volume and get outta here.
	if (node->contents >= 0)
	{
		mleaf_t *pLeaf = (mleaf_t *)node;

		// Don't return a leaf that's not filled with liquid
		if ( pLeaf->leafWaterDataID == -1 )
			return true;

		// Never return SLIME as being visible, as it's opaque
		if ( pLeaf->contents & CONTENTS_SLIME )
			return true;

		m_nVisibleFogVolume = pLeaf->leafWaterDataID;
		m_nVisibleFogVolumeLeaf = pLeaf - host_state.worldbrush->leafs;
		return false;  // found it, so stop searching
	}

	// node is just a decision point, so go down the apropriate sides

	// find which side of the node we are on
	plane = node->plane;
	if ( plane->type <= PLANE_Z )
	{
		dot = m_vecSearchPoint[plane->type] - plane->dist;
	}
	else
	{
		dot = DotProduct( m_vecSearchPoint, plane->normal ) - plane->dist;
	}

	// recurse down the children, closer side first.
	// We have to do this because we need to find if the surfaces at this node
	// exist in any visible leaves closer to the camera than the node is. If so,
	// their r_surfacevisframe is set to indicate that we need to render them
	// at this node.
	side = (dot >= 0) ? 0 : 1;

	// Recurse down the side closer to the camera
	if( !RecursiveGetVisibleFogVolume (node->children[side]) )
		return false;

	// recurse down the side farther from the camera
	return RecursiveGetVisibleFogVolume (node->children[!side]);
}


static void ClearFogInfo( VisibleFogVolumeInfo_t *pInfo )
{
	pInfo->m_bEyeInFogVolume = false;
	pInfo->m_nVisibleFogVolume = -1;
	pInfo->m_nVisibleFogVolumeLeaf = -1;
	pInfo->m_pFogVolumeMaterial = NULL;
	pInfo->m_flWaterHeight = INVALID_WATER_HEIGHT;
}

ConVar fast_fogvolume("fast_fogvolume", "0");
//-----------------------------------------------------------------------------
// Main entry point from renderer to get the fog volume
//-----------------------------------------------------------------------------
void R_GetVisibleFogVolume( const Vector& vEyePoint, VisibleFogVolumeInfo_t *pInfo )
{
	VPROF_BUDGET( "R_GetVisibleFogVolume", VPROF_BUDGETGROUP_WORLD_RENDERING );

	if ( host_state.worldmodel->brush.pShared->numleafwaterdata == 0 )
	{
		ClearFogInfo( pInfo );
		return;
	}

	int nLeafID = CM_PointLeafnum( vEyePoint );
	mleaf_t* pLeaf = &host_state.worldbrush->leafs[nLeafID];

	int nLeafContents = pLeaf->contents;
	if ( pLeaf->leafWaterDataID != -1 )
	{
		Assert( nLeafContents & (CONTENTS_SLIME | CONTENTS_WATER) );
		pInfo->m_bEyeInFogVolume = true;
		pInfo->m_nVisibleFogVolume = pLeaf->leafWaterDataID;
		pInfo->m_nVisibleFogVolumeLeaf = nLeafID;
		pInfo->m_pFogVolumeMaterial = R_GetFogVolumeMaterial( pInfo->m_nVisibleFogVolume, true );
		pInfo->m_flWaterHeight = R_GetWaterHeight( pInfo->m_nVisibleFogVolume );
	}
	else if ( nLeafContents & CONTENTS_TESTFOGVOLUME )
	{
		Assert( (nLeafContents & (CONTENTS_SLIME | CONTENTS_WATER)) == 0 );
		if ( fast_fogvolume.GetBool() && host_state.worldbrush->numleafwaterdata == 1 )
		{
			pInfo->m_nVisibleFogVolume = 0;
			pInfo->m_nVisibleFogVolumeLeaf = host_state.worldbrush->leafwaterdata[0].firstLeafIndex;
		}
		else
		{
			CVisibleFogVolumeQuery query;
			query.FindVisibleFogVolume( vEyePoint, &pInfo->m_nVisibleFogVolume, &pInfo->m_nVisibleFogVolumeLeaf ); 
		}

		pInfo->m_bEyeInFogVolume = false;
		pInfo->m_pFogVolumeMaterial = R_GetFogVolumeMaterial( pInfo->m_nVisibleFogVolume, false );
		pInfo->m_flWaterHeight = R_GetWaterHeight( pInfo->m_nVisibleFogVolume );
	}
	else
	{
		ClearFogInfo( pInfo );
	}

	if( host_state.worldbrush->m_LeafMinDistToWater )
	{
		pInfo->m_flDistanceToWater = ( float )host_state.worldbrush->m_LeafMinDistToWater[nLeafID];
	}
	else
	{
		pInfo->m_flDistanceToWater = 0.0f;
	}
}


//-----------------------------------------------------------------------------
// Draws the list of surfaces build in the BuildWorldLists phase
//-----------------------------------------------------------------------------

// Uncomment this to allow code to draw wireframe over a particular surface for debugging
//#define DEBUG_SURF 1

#ifdef DEBUG_SURF
int g_DebugSurfIndex = -1;
#endif

void R_DrawWorldLists( IWorldRenderList *pRenderListIn, unsigned long flags, float waterZAdjust )
{
	CWorldRenderList *pRenderList = assert_cast<CWorldRenderList *>(pRenderListIn);
	if ( g_bTextMode || g_LostVideoMemory )
		return;

	VPROF("R_DrawWorldLists");
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__  );
	Shader_WorldEnd( pRenderList, flags, waterZAdjust );

#ifdef DEBUG_SURF
	{
		VPROF("R_DrawWorldLists (DEBUG_SURF)");
		if (g_pDebugSurf)
		{
			CMatRenderContextPtr pRenderContext( materials );
			pRenderContext->Bind( g_materialWorldWireframe );
			Shader_DrawSurfaceDynamic( pRenderContext, g_pDebugSurf, false );
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void R_SceneBegin( void )
{
	ComputeDebugSettings();
}

void R_SceneEnd( void )
{
}

//-----------------------------------------------------------------------------
// Debugging code to draw the lightmap pages
//-----------------------------------------------------------------------------

void Shader_DrawLightmapPageSurface( SurfaceHandle_t surfID, float red, float green, float blue )
{
	Vector2D lightCoords[32][4];

	int bumpID, count;
	if ( MSurf_Flags( surfID ) & SURFDRAW_BUMPLIGHT )
	{
		count = NUM_BUMP_VECTS + 1;
	}
	else
	{
		count = 1;
	}

	BuildMSurfaceVerts( host_state.worldbrush, surfID, NULL, NULL, lightCoords );

	int lightmapPageWidth, lightmapPageHeight;

	CMatRenderContextPtr pRenderContext( materials );

	pRenderContext->Bind( g_materialWireframe );
	materials->GetLightmapPageSize( 
		SortInfoToLightmapPage(MSurf_MaterialSortID( surfID )), 
		&lightmapPageWidth, &lightmapPageHeight );

	for( bumpID = 0; bumpID < count; bumpID++ )
	{
		// assumes that we are already in ortho mode.
		IMesh* pMesh = pRenderContext->GetDynamicMesh( );
					
		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_LINES, MSurf_VertCount( surfID ) );
		
		int i;

		for( i = 0; i < MSurf_VertCount( surfID ); i++ )
		{
			float x, y;
			float *texCoord;

			texCoord = &lightCoords[i][bumpID][0];

			x = lightmapPageWidth * texCoord[0];
			y = lightmapPageHeight * texCoord[1];
#ifdef _XBOX
			// xboxissue - border safe
			x += 32;
			y += 32;
#endif			
			meshBuilder.Position3f( x, y, 0.0f );
			meshBuilder.AdvanceVertex();

			texCoord = &lightCoords[(i+1)%MSurf_VertCount( surfID )][bumpID][0];
			x = lightmapPageWidth * texCoord[0];
			y = lightmapPageHeight * texCoord[1];
#ifdef _XBOX
			// xboxissue - border safe
			x += 32;
			y += 32;
#endif			
			meshBuilder.Position3f( x, y, 0.0f );
			meshBuilder.AdvanceVertex();
		}
		
		meshBuilder.End();
		pMesh->Draw();
	}
}

void Shader_DrawLightmapPageChains( IWorldRenderList *pRenderListIn, int pageId )
{
	CWorldRenderList *pRenderList = assert_cast<CWorldRenderList *>(pRenderListIn);
	for (int j = 0; j < MAX_MAT_SORT_GROUPS; ++j)
	{
		MSL_FOREACH_GROUP_BEGIN( pRenderList->m_SortList, j, group )
		{
			SurfaceHandle_t surfID = pRenderList->m_SortList.GetSurfaceAtHead( group );
			Assert(IS_SURF_VALID(surfID));
			Assert( MSurf_MaterialSortID( surfID ) >= 0 && MSurf_MaterialSortID( surfID ) < g_WorldStaticMeshes.Count() );
			if( materialSortInfoArray[MSurf_MaterialSortID( surfID ) ].lightmapPageID != pageId )
			{
				continue;
			}
			MSL_FOREACH_SURFACE_IN_GROUP_BEGIN( pRenderList->m_SortList, group, surfIDList )
			{
				Assert( !SurfaceHasDispInfo( surfIDList ) );
				Shader_DrawLightmapPageSurface( surfIDList, 0.0f, 1.0f, 0.0f );
			}
			MSL_FOREACH_SURFACE_IN_GROUP_END()
		}
		MSL_FOREACH_GROUP_END()

		// render displacement lightmap page info
		MSL_FOREACH_SURFACE_BEGIN(pRenderList->m_DispSortList, j, surfID)
		{
			surfID->pDispInfo->RenderWireframeInLightmapPage( pageId );
		}
		MSL_FOREACH_SURFACE_END()
	}
}

//-----------------------------------------------------------------------------
//
// All code related to brush model rendering
//
//-----------------------------------------------------------------------------

class CBrushSurface : public IBrushSurface
{
public:
	CBrushSurface( SurfaceHandle_t surfID );

	// Computes texture coordinates + lightmap coordinates given a world position
	virtual void ComputeTextureCoordinate( const Vector& worldPos, Vector2D& texCoord );
	virtual void ComputeLightmapCoordinate( const Vector& worldPos, Vector2D& lightmapCoord );

	// Gets the vertex data for this surface
	virtual int  GetVertexCount() const;
	virtual void GetVertexData( BrushVertex_t* pVerts );

	// Gets at the material properties for this surface
	virtual IMaterial* GetMaterial();

private:
	SurfaceHandle_t m_SurfaceID;
	SurfaceCtx_t m_Ctx;
};


//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CBrushSurface::CBrushSurface( SurfaceHandle_t surfID ) : m_SurfaceID(surfID)
{
	Assert(IS_SURF_VALID(surfID));
	SurfSetupSurfaceContext( m_Ctx, surfID );
}


//-----------------------------------------------------------------------------
// Computes texture coordinates + lightmap coordinates given a world position
//-----------------------------------------------------------------------------
void CBrushSurface::ComputeTextureCoordinate( const Vector& worldPos, Vector2D& texCoord )
{
	SurfComputeTextureCoordinate( m_Ctx, m_SurfaceID, worldPos, texCoord );
}

void CBrushSurface::ComputeLightmapCoordinate( const Vector& worldPos, Vector2D& lightmapCoord )
{
	SurfComputeLightmapCoordinate( m_Ctx, m_SurfaceID, worldPos, lightmapCoord );
}


//-----------------------------------------------------------------------------
// Gets the vertex data for this surface
//-----------------------------------------------------------------------------
int  CBrushSurface::GetVertexCount() const
{
	if( !SurfaceHasPrims( m_SurfaceID ) )
	{
		// Create a temporary vertex array for the data...
		return MSurf_VertCount( m_SurfaceID );
	}
	else
	{
		// not implemented yet
		Assert(0);
		return 0;
	}
}

void CBrushSurface::GetVertexData( BrushVertex_t* pVerts )
{
	Assert( pVerts );

	if( !SurfaceHasPrims( m_SurfaceID ) )
	{
		// Fill in the vertex data
		BuildBrushModelVertexArray( host_state.worldbrush, m_SurfaceID, pVerts );
	}
	else
	{
		// not implemented yet
		Assert(0);
	}
}


//-----------------------------------------------------------------------------
// Activates fast z reject for displacements
//-----------------------------------------------------------------------------
void R_FastZRejectDisplacements( bool bEnable )
{
	s_bFastZRejectDisplacements = bEnable;
}


//-----------------------------------------------------------------------------
// Gets at the material properties for this surface
//-----------------------------------------------------------------------------
IMaterial* CBrushSurface::GetMaterial()
{
	return MSurf_TexInfo( m_SurfaceID )->material;
}

//-----------------------------------------------------------------------------
// Installs a client-side renderer for brush models
//-----------------------------------------------------------------------------
void R_InstallBrushRenderOverride( IBrushRenderer* pBrushRenderer )
{
	s_pBrushRenderOverride = pBrushRenderer;
}

//-----------------------------------------------------------------------------
// Here, we allow the client DLL to render brush surfaces however they'd like
// NOTE: This involves a vertex copy, so don't use this everywhere
//-----------------------------------------------------------------------------

bool Shader_DrawBrushSurfaceOverride( IMatRenderContext *pRenderContext, SurfaceHandle_t surfID, IClientEntity *baseentity )
{
	// Set the lightmap state
	Shader_SetChainLightmapState( pRenderContext, surfID );

	CBrushSurface brushSurface( surfID );
	return s_pBrushRenderOverride->RenderBrushModelSurface( baseentity, &brushSurface );
}


FORCEINLINE void ModulateMaterial( IMaterial *pMaterial, float *pOldColor )
{
	if ( g_bIsBlendingOrModulating )
	{
		pOldColor[3] = pMaterial->GetAlphaModulation( );
		pMaterial->GetColorModulation( &pOldColor[0], &pOldColor[1], &pOldColor[2] );
		pMaterial->AlphaModulate( r_blend );
		pMaterial->ColorModulate( r_colormod[0], r_colormod[1], r_colormod[2] );
	}

}

FORCEINLINE void UnModulateMaterial( IMaterial *pMaterial, float *pOldColor )
{
	if ( g_bIsBlendingOrModulating )
	{
		pMaterial->AlphaModulate( pOldColor[3] );
		pMaterial->ColorModulate( pOldColor[0], pOldColor[1], pOldColor[2] );
	}
}

//-----------------------------------------------------------------------------
// Main method to draw brush surfaces
//-----------------------------------------------------------------------------
void Shader_BrushSurface( SurfaceHandle_t surfID, model_t *model, IClientEntity *baseentity )
{
	CMatRenderContextPtr pRenderContext(materials);
	float pOldColor[4];

	bool drawDecals;
	if (!s_pBrushRenderOverride)
	{
		drawDecals = true;

		IMaterial *pMaterial = MSurf_TexInfo( surfID )->material;

		ModulateMaterial( pMaterial, pOldColor );
		Shader_SetChainTextureState( pRenderContext, surfID, baseentity, false );

//		NOTE: Since a static vb/dynamic ib IMesh doesn't buffer, we shouldn't use this
//		since it causes a lock and drawindexedprimitive per surface! (gary)
//		Shader_DrawSurfaceStatic( surfID );
		Shader_DrawSurfaceDynamic( pRenderContext, surfID, false );

		// FIXME: This may cause an unnecessary flush to occur!
		// Thankfully, this is a rare codepath. I don't think anything uses it now.
		UnModulateMaterial( pMaterial, pOldColor );
	}
	else
	{
		drawDecals = Shader_DrawBrushSurfaceOverride( pRenderContext, surfID, baseentity );
	}

	// fixme: need to get "allowDecals" from the material
	//	if ( g_BrushProperties.allowDecals && pSurf->pdecals ) 
	if( SurfaceHasDecals( surfID ) && drawDecals )
	{
		DecalSurfaceAdd( surfID, BRUSHMODEL_DECAL_SORT_GROUP );
	}

	// Add overlay fragments to list.
	// FIXME: A little code support is necessary to get overlays working on brush models
//	OverlayMgr()->AddFragmentListToRenderList( MSurf_OverlayFragmentList( surfID ), false );

	// Add shadows too....
	ShadowDecalHandle_t decalHandle = MSurf_ShadowDecals( surfID );
	if (decalHandle != SHADOW_DECAL_HANDLE_INVALID)
	{
		g_pShadowMgr->AddShadowsOnSurfaceToRenderList( decalHandle );
	}
}


// UNDONE: These are really guesses.  Do we ever exceed these limits?
const int MAX_TRANS_NODES = 256;
const int MAX_TRANS_DECALS = 256;
const int MAX_TRANS_BATCHES = 1024;
const int MAX_TRANS_SURFACES = 1024;

class CBrushBatchRender
{
public:
	// These are the compact structs produced by the brush render cache.  The goal is to have a compact
	// list of drawing instructions for drawing an opaque brush model in the most optimal order.
	// These structs contain ONLY the opaque surfaces of a brush model.
	struct brushrendersurface_t
	{
		short	surfaceIndex;
		short	planeIndex;
	};

	// a batch is a list of surfaces with the same material - they can be drawn with one call to the materialsystem
	struct brushrenderbatch_t
	{
		short	firstSurface;
		short	surfaceCount;
		IMaterial *pMaterial;
		int		sortID;
		int		indexCount;
	};

	// a mesh is a list of batches with the same vertex format.
	struct brushrendermesh_t
	{
		short		firstBatch;
		short		batchCount;
	};

	// This is the top-level struct containing all data necessary to render an opaque brush model in optimal order
	struct brushrender_t
	{
		// UNDONE: Compact these arrays into a single allocation
		// UNDONE: Compact entire struct to a single allocation?  Store brushrender_t * in the linked list?
		void Free()
		{
			delete[] pPlanes;
			delete[] pMeshes;
			delete[] pBatches;
			delete[] pSurfaces;
			pPlanes = NULL;
			pMeshes = NULL;
			pBatches = NULL;
			pSurfaces = NULL;
		}

		cplane_t				**pPlanes;
		brushrendermesh_t		*pMeshes;			
		brushrenderbatch_t		*pBatches;
		brushrendersurface_t	*pSurfaces;
		short planeCount;
		short meshCount;
		short batchCount;
		short surfaceCount;
		short totalIndexCount;
		short totalVertexCount;
	};

	// Surfaces are stored in a list like this temporarily for sorting purposes only.  The compact structs do not store these.
	struct surfacelist_t
	{
		SurfaceHandle_t surfID;
		short	surfaceIndex;
		short	planeIndex;
	};
	
	// These are the compact structs produced for translucent brush models.  These structs contain
	// only the translucent surfaces of a brush model.

	// a batch is a list of surfaces with the same material - they can be drawn with one call to the materialsystem
	struct transbatch_t
	{
		short	firstSurface;
		short	surfaceCount;
		IMaterial *pMaterial;
		int		sortID;
		int		indexCount;
	};

	// This is a list of surfaces that have decals.
	struct transdecal_t
	{
		short firstSurface;
		short surfaceCount;
	};

	// A node is the list of batches that can be drawn without sorting errors.  When no decals are present, surfaces
	// from the next node may be appended to this one to improve performance without causing sorting errors.
	struct transnode_t
	{
		short			firstBatch;
		short			batchCount;
		short			firstDecalSurface;
		short			decalSurfaceCount;
	};

	// This is the top-level struct containing all data necessary to render a translucent brush model in optimal order.
	// NOTE: Unlike the opaque struct, the order of the batches is view-dependent, so caching this is pointless since 
	// the view usually changes.
	struct transrender_t
	{
		transnode_t		nodes[MAX_TRANS_NODES];
		SurfaceHandle_t	surfaces[MAX_TRANS_SURFACES];
		SurfaceHandle_t	decalSurfaces[MAX_TRANS_DECALS];
		transbatch_t	batches[MAX_TRANS_BATCHES];
		transbatch_t	*pLastBatch;	// These are used to append surfaces to existing batches across nodes.
		transnode_t		*pLastNode;		// This improves performance.
		short			nodeCount;
		short			batchCount;
		short			surfaceCount;
		short			decalSurfaceCount;
	};

	// Builds a transrender_t, then executes it's drawing commands
	void DrawTranslucentBrushModel( model_t *model, IClientEntity *baseentity )
	{
		transrender_t renderT;
		renderT.pLastBatch = NULL;
		renderT.pLastNode = NULL;
		renderT.nodeCount = 0;
		renderT.surfaceCount = 0;
		renderT.batchCount = 0;
		renderT.decalSurfaceCount = 0;
		BuildTransLists_r( renderT, model, model->brush.pShared->nodes + model->brush.firstnode );
		void *pProxyData = baseentity ? baseentity->GetClientRenderable() : NULL;
		DrawTransLists( renderT, pProxyData );
	}

	void AddSurfaceToBatch( transrender_t &renderT, transnode_t *pNode, transbatch_t *pBatch, SurfaceHandle_t surfID )
	{
		pBatch->surfaceCount++;
		Assert( renderT.surfaceCount < MAX_TRANS_SURFACES);

		pBatch->indexCount += (MSurf_VertCount( surfID )-2)*3;
		renderT.surfaces[renderT.surfaceCount] = surfID;
		renderT.surfaceCount++;
		if ( SurfaceHasDecals( surfID ) )
		{
			Assert( renderT.decalSurfaceCount < MAX_TRANS_DECALS);
			pNode->decalSurfaceCount++;
			renderT.decalSurfaces[renderT.decalSurfaceCount] = surfID;
			renderT.decalSurfaceCount++;
		}
	}

	void AddTransNode( transrender_t &renderT )
	{
		renderT.pLastNode = &renderT.nodes[renderT.nodeCount];
		renderT.nodeCount++;
		Assert( renderT.nodeCount < MAX_TRANS_NODES);
		renderT.pLastBatch = NULL;
		renderT.pLastNode->firstBatch = renderT.batchCount;
		renderT.pLastNode->firstDecalSurface = renderT.decalSurfaceCount;
		renderT.pLastNode->batchCount = 0;
		renderT.pLastNode->decalSurfaceCount = 0;
	}

	void AddTransBatch( transrender_t &renderT, SurfaceHandle_t surfID )
	{
		transbatch_t &batch = renderT.batches[renderT.pLastNode->firstBatch + renderT.pLastNode->batchCount];
		Assert( renderT.batchCount < MAX_TRANS_BATCHES);
		renderT.pLastNode->batchCount++;
		renderT.batchCount++;
		batch.firstSurface = renderT.surfaceCount;
		batch.surfaceCount = 0;
		batch.pMaterial = MSurf_TexInfo( surfID )->material;
		batch.sortID = MSurf_MaterialSortID( surfID );
		batch.indexCount = 0;
		renderT.pLastBatch = &batch;
		AddSurfaceToBatch( renderT, renderT.pLastNode, &batch, surfID );
	}

	// build node lists
	void BuildTransLists_r( transrender_t &renderT, model_t *model, mnode_t *node )
	{
		float		dot;

		if (node->contents >= 0)
			return;

		// node is just a decision point, so go down the apropriate sides
		// find which side of the node we are on
		cplane_t *plane = node->plane;
		if ( plane->type <= PLANE_Z )
		{
			dot = modelorg[plane->type] - plane->dist;
		}
		else
		{
			dot = DotProduct (modelorg, plane->normal) - plane->dist;
		}

		int side = (dot >= 0) ? 0 : 1;

		// back side first - translucent surfaces need to render in back to front order
		// to appear correctly.
		BuildTransLists_r( renderT, model, node->children[!side]);

		// emit all surfaces on node
		CUtlVectorFixed<surfacelist_t, 256> sortList;
		SurfaceHandle_t surfID = SurfaceHandleFromIndex( node->firstsurface, model->brush.pShared );
		for ( int i = 0; i < node->numsurfaces; i++, surfID++ )
		{
			// skip opaque surfaces
			if ( MSurf_Flags(surfID) & SURFDRAW_TRANS )
			{
				if ( ((MSurf_Flags( surfID ) & SURFDRAW_NOCULL) == 0) )
				{
					// Backface cull here, so they won't do any more work
					if ( ( side ^ !!(MSurf_Flags( surfID ) & SURFDRAW_PLANEBACK)) )
						continue;
				}

				// If this can be appended to the previous batch, do so
				int sortID = MSurf_MaterialSortID( surfID );
				if ( renderT.pLastBatch && renderT.pLastBatch->sortID == sortID )
				{
					AddSurfaceToBatch( renderT, renderT.pLastNode, renderT.pLastBatch, surfID );
				}
				else
				{
					// save it off for sorting, then a later append
					int sortIndex = sortList.AddToTail();
					sortList[sortIndex].surfID = surfID;
				}
			}
		}

		// We've got surfaces on this node that can't be added to the previous node
		if ( sortList.Count() )
		{
			// sort by material
			sortList.Sort( SurfaceCmp );
			
			// add a new sort group
			AddTransNode( renderT );
			int lastSortID = -1;
			// now add the optimal number of batches to that group
			for ( int i = 0; i < sortList.Count(); i++ )
			{
				surfID = sortList[i].surfID;
				int sortID = MSurf_MaterialSortID( surfID );
				if ( lastSortID == sortID )
				{
					// can be drawn in a single call with the current list of surfaces, append
					AddSurfaceToBatch( renderT, renderT.pLastNode, renderT.pLastBatch, surfID );
				}
				else
				{
					// requires a break (material/lightmap change).
					AddTransBatch( renderT, surfID );
					lastSortID = sortID;
				}
			}

			// don't batch across decals or decals will sort incorrectly
			if ( renderT.pLastNode->decalSurfaceCount )
			{
				renderT.pLastNode = NULL;
				renderT.pLastBatch = NULL;
			}
		}

		// front side
		BuildTransLists_r( renderT, model, node->children[side]);
	}

	void DrawTransLists( transrender_t &renderT, void *pProxyData )
	{
		CMatRenderContextPtr pRenderContext( materials );

		PIXEVENT( pRenderContext, "DrawTransLists" );

		bool skipLight = false;
		if ( g_pMaterialSystemConfig->nFullbright == 1 )
		{
			pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP );
			skipLight = true;
		}

		float pOldColor[4];


		for ( int i = 0; i < renderT.nodeCount; i++ )
		{
			int j;
			const transnode_t &node = renderT.nodes[i];
			for ( j = 0; j < node.batchCount; j++ )
			{
				const transbatch_t &batch = renderT.batches[node.firstBatch+j];
				
#ifdef NEWMESH
				CIndexBufferBuilder indexBufferBuilder;
#else
				CMeshBuilder meshBuilder;
#endif
				IMaterial *pMaterial = batch.pMaterial;

				ModulateMaterial( pMaterial, pOldColor );

				if ( !skipLight )
				{
					pRenderContext->BindLightmapPage( materialSortInfoArray[batch.sortID].lightmapPageID );
				}
				pRenderContext->Bind( pMaterial, pProxyData );

#ifdef NEWMESH
				IIndexBuffer *pBuildIndexBuffer = pRenderContext->GetDynamicIndexBuffer( MATERIAL_INDEX_FORMAT_16BIT, false );
				indexBufferBuilder.Begin( pBuildIndexBuffer, batch.indexCount );
#else
				IMesh *pBuildMesh = pRenderContext->GetDynamicMesh( false, g_WorldStaticMeshes[batch.sortID], NULL, NULL );
				meshBuilder.Begin( pBuildMesh, MATERIAL_TRIANGLES, 0, batch.indexCount );
#endif

				for ( int k = 0; k < batch.surfaceCount; k++ )
				{
					SurfaceHandle_t surfID = renderT.surfaces[batch.firstSurface + k];
					Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );
#ifdef NEWMESH
					BuildIndicesForSurface( indexBufferBuilder, surfID );
#else
					BuildIndicesForSurface( meshBuilder, surfID );
#endif

				}
#ifdef NEWMESH
				indexBufferBuilder.End( false ); // haven't tested this one yet (alpha blended world geom I think)
				// FIXME: IMaterial::GetVertexFormat() should do this stripping (add a separate 'SupportsCompression' accessor)
				VertexFormat_t vertexFormat = pMaterial->GetVertexFormat() & ~VERTEX_FORMAT_COMPRESSED;
				pRenderContext->BindVertexBuffer( 0, g_WorldStaticMeshes[batch.sortID], 0, vertexFormat );
				pRenderContext->BindIndexBuffer( pBuildIndexBuffer, 0 );
				pRenderContext->Draw( MATERIAL_TRIANGLES, 0, batch.indexCount );
#else
				meshBuilder.End( false, true );
#endif

				// Don't leave the material in a bogus state
				UnModulateMaterial( pMaterial, pOldColor );
			}

			if ( node.decalSurfaceCount )
			{
				for ( j = 0; j < node.decalSurfaceCount; j++ )
				{
					SurfaceHandle_t surfID = renderT.decalSurfaces[node.firstDecalSurface + j];
					Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );
					if( SurfaceHasDecals( surfID ) )
					{
						DecalSurfaceAdd( surfID, BRUSHMODEL_DECAL_SORT_GROUP );
					}

					// Add shadows too....
					ShadowDecalHandle_t decalHandle = MSurf_ShadowDecals( surfID );
					if (decalHandle != SHADOW_DECAL_HANDLE_INVALID)
					{
						g_pShadowMgr->AddShadowsOnSurfaceToRenderList( decalHandle );
					}
				}

				// Now draw the decals + shadows for this node
				// This order relative to the surfaces is important for translucency to work correctly.
				DecalSurfaceDraw(pRenderContext, BRUSHMODEL_DECAL_SORT_GROUP);

				// FIXME: Decals are not being rendered while illuminated by the flashlight
				DecalSurfacesInit( true );

				// Draw all shadows on the brush
				g_pShadowMgr->RenderProjectedTextures( );
			}
			if ( g_ShaderDebug.anydebug )
			{
				CUtlVector<msurface2_t *> brushList;
				for ( j = 0; j < node.batchCount; j++ )
				{
					const transbatch_t &batch = renderT.batches[node.firstBatch+j];
					for ( int k = 0; k < batch.surfaceCount; k++ )
					{
						brushList.AddToTail( renderT.surfaces[batch.firstSurface + k] );
					}
				}
				DrawDebugInformation( brushList );
			}
		}
	}

	static int __cdecl SurfaceCmp(const surfacelist_t *s0, const surfacelist_t *s1 );

	void LevelInit();
	brushrender_t *FindOrCreateRenderBatch( model_t *pModel );
	void DrawOpaqueBrushModel( IClientEntity *baseentity, model_t *model, const Vector& origin, ERenderDepthMode DepthMode );
	void DrawTranslucentBrushModel( IClientEntity *baseentity, model_t *model, const Vector& origin, bool bShadowDepth, bool bDrawOpaque, bool bDrawTranslucent );
	void DrawBrushModelShadow( model_t *model, IClientRenderable *pRenderable );

private:
	void ClearRenderHandles();

	CUtlLinkedList<brushrender_t> m_renderList;
};

int __cdecl CBrushBatchRender::SurfaceCmp(const surfacelist_t *s0, const surfacelist_t *s1 )
{
	int sortID0 = MSurf_MaterialSortID( s0->surfID );
	int sortID1 = MSurf_MaterialSortID( s1->surfID );

	return sortID0 - sortID1;
}


CBrushBatchRender g_BrushBatchRenderer;

//-----------------------------------------------------------------------------
// Purpose: This is used when the mat_dxlevel is changed to reset the brush
//          models.
//-----------------------------------------------------------------------------
void R_BrushBatchInit( void )
{
	g_BrushBatchRenderer.LevelInit();
}

void CBrushBatchRender::LevelInit()
{
	unsigned short iNext;
	for( unsigned short i=m_renderList.Head(); i != m_renderList.InvalidIndex(); i=iNext )
	{
		iNext = m_renderList.Next(i);
		m_renderList.Element(i).Free();
	}

	m_renderList.Purge();

	ClearRenderHandles();
}

void CBrushBatchRender::ClearRenderHandles( void )
{
	for ( int iBrush = 1 ; iBrush < host_state.worldbrush->numsubmodels ; ++iBrush )
	{
		char szBrushModel[5]; // inline model names "*1", "*2" etc
		Q_snprintf( szBrushModel, sizeof( szBrushModel ), "*%i", iBrush );
		model_t *pModel = modelloader->GetModelForName( szBrushModel, IModelLoader::FMODELLOADER_SERVER );	
		if ( pModel )
		{
			pModel->brush.renderHandle = 0;
		}
	}
}

// Create a compact, optimal list of rendering commands for the opaque parts of a brush model
// NOTE: This just skips translucent surfaces assuming a separate transrender_t pass!
CBrushBatchRender::brushrender_t *CBrushBatchRender::FindOrCreateRenderBatch( model_t *pModel )
{
	if ( !pModel->brush.nummodelsurfaces )
		return NULL;

	unsigned short index = pModel->brush.renderHandle - 1;

	if ( m_renderList.IsValidIndex( index ) )
		return &m_renderList.Element(index);

	index = m_renderList.AddToTail();
	pModel->brush.renderHandle = index + 1;
	brushrender_t &renderT = m_renderList.Element(index);
	renderT.pPlanes = NULL;
	renderT.pMeshes = NULL;
	renderT.planeCount = 0;
	renderT.meshCount = 0;
	renderT.totalIndexCount = 0;
	renderT.totalVertexCount = 0;

	CUtlVector<cplane_t *>	planeList;
	CUtlVector<surfacelist_t> surfaceList;

	int i;

	SurfaceHandle_t surfID = SurfaceHandleFromIndex( pModel->brush.firstmodelsurface, pModel->brush.pShared );
	for (i=0 ; i<pModel->brush.nummodelsurfaces; i++, surfID++)
	{
		// UNDONE: For now, just draw these in a separate pass
		if ( MSurf_Flags(surfID) & SURFDRAW_TRANS )
			continue;

		cplane_t *plane = surfID->plane;
		int planeIndex = planeList.Find(plane);
		if ( planeIndex == -1 )
		{
			planeIndex = planeList.AddToTail( plane );
		}
		surfacelist_t tmp;
		tmp.surfID = surfID;
		tmp.surfaceIndex = i;
		tmp.planeIndex = planeIndex;
		surfaceList.AddToTail( tmp );
	}
	surfaceList.Sort( SurfaceCmp );
	renderT.pPlanes = new cplane_t *[planeList.Count()];
	renderT.planeCount = planeList.Count();
	memcpy( renderT.pPlanes, planeList.Base(), sizeof(cplane_t *)*planeList.Count() );
	renderT.pSurfaces = new brushrendersurface_t[surfaceList.Count()];
	renderT.surfaceCount = surfaceList.Count();

	int meshCount = 0;
	int batchCount = 0;
	int lastSortID = -1;
#ifdef NEWMESH
	IVertexBuffer *pLastVertexBuffer = NULL;
#else
	IMesh *pLastMesh = NULL;
#endif
	brushrendermesh_t *pMesh = NULL;
	brushrendermesh_t tmpMesh[MAX_VERTEX_FORMAT_CHANGES];
	brushrenderbatch_t *pBatch = NULL;
	brushrenderbatch_t tmpBatch[128];

	for ( i = 0; i < surfaceList.Count(); i++ )
	{
		renderT.pSurfaces[i].surfaceIndex = surfaceList[i].surfaceIndex;
		renderT.pSurfaces[i].planeIndex = surfaceList[i].planeIndex;

		surfID = surfaceList[i].surfID;
		int sortID = MSurf_MaterialSortID( surfID );
#ifdef NEWMESH
		if ( g_WorldStaticMeshes[sortID] != pLastVertexBuffer )
#else
		if ( g_WorldStaticMeshes[sortID] != pLastMesh )
#endif
		{
			pMesh = tmpMesh + meshCount;
			pMesh->firstBatch = batchCount;
			pMesh->batchCount = 0;
			lastSortID = -1; // force a new batch
			meshCount++;
		}
		if ( sortID != lastSortID )
		{
			pBatch = tmpBatch + batchCount;
			pBatch->firstSurface = i;
			pBatch->surfaceCount = 0;
			pBatch->sortID = sortID;
			pBatch->pMaterial = MSurf_TexInfo( surfID )->material;
			pBatch->indexCount = 0;
			pMesh->batchCount++;
			batchCount++;
		}
#ifdef NEWMESH
		pLastVertexBuffer = g_WorldStaticMeshes[sortID];
#else
		pLastMesh = g_WorldStaticMeshes[sortID];
#endif
		lastSortID = sortID;
		pBatch->surfaceCount++;
		int vertCount = MSurf_VertCount( surfID );
		int indexCount = (vertCount - 2) * 3;
		pBatch->indexCount += indexCount;
		renderT.totalIndexCount += indexCount;
		renderT.totalVertexCount += vertCount;
	}

	renderT.pMeshes = new brushrendermesh_t[meshCount];
	memcpy( renderT.pMeshes, tmpMesh, sizeof(brushrendermesh_t) * meshCount );
	renderT.meshCount = meshCount;
	renderT.pBatches = new brushrenderbatch_t[batchCount];
	memcpy( renderT.pBatches, tmpBatch, sizeof(brushrenderbatch_t) * batchCount );
	renderT.batchCount = batchCount;
	return &renderT;
}


//-----------------------------------------------------------------------------
// Draws an opaque (parts of a) brush model
//-----------------------------------------------------------------------------
void CBrushBatchRender::DrawOpaqueBrushModel( IClientEntity *baseentity, model_t *model, const Vector& origin, ERenderDepthMode DepthMode )
{
	VPROF( "R_DrawOpaqueBrushModel" );
	SurfaceHandle_t firstSurfID = SurfaceHandleFromIndex( model->brush.firstmodelsurface, model->brush.pShared );

	brushrender_t *pRender = FindOrCreateRenderBatch( model );
	int i;
	if ( !pRender )
		return;

	bool skipLight = false;
	CMatRenderContextPtr pRenderContext( materials );

	PIXEVENT( pRenderContext, "DrawOpaqueBrushModel" );

	if ( (g_pMaterialSystemConfig->nFullbright == 1) || DepthMode == DEPTH_MODE_SHADOW )
	{
		pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP );
		skipLight = true;
	}

	void *pProxyData = baseentity ? baseentity->GetClientRenderable() : NULL;
	bool backface[1024];
	Assert( pRender->planeCount < 1024 );

	// NOTE: Backface culling is almost no perf gain.  Can be removed from brush model rendering.
	// Check the shared planes once
	for ( i = 0; i < pRender->planeCount; i++ )
	{
		float dot = DotProduct( modelorg, pRender->pPlanes[i]->normal) - pRender->pPlanes[i]->dist;
		backface[i] = ( DepthMode == DEPTH_MODE_NORMAL && ( dot < BACKFACE_EPSILON ) ) ? true : false; // don't backface cull when rendering to shadow map
	}

	float pOldColor[4];

	for ( i = 0; i < pRender->meshCount; i++ )
	{
		brushrendermesh_t &mesh = pRender->pMeshes[i];
		for ( int j = 0; j < mesh.batchCount; j++ )
		{
			brushrenderbatch_t &batch = pRender->pBatches[mesh.firstBatch + j];

			int k;
			for ( k = 0; k < batch.surfaceCount; k++ )
			{
				brushrendersurface_t &surface = pRender->pSurfaces[batch.firstSurface + k];
				if ( !backface[surface.planeIndex] )
					break;
			}

			if ( k == batch.surfaceCount )
				continue;

			CMeshBuilder meshBuilder;
			IMaterial *pMaterial = NULL;

			if ( DepthMode != DEPTH_MODE_NORMAL )
			{
				// Select proper override material
				int nAlphaTest = (int) batch.pMaterial->IsAlphaTested();
				int nNoCull = (int) batch.pMaterial->IsTwoSided();
				IMaterial *pDepthWriteMaterial;
				
				if ( DepthMode == DEPTH_MODE_SSA0 )
				{
					pDepthWriteMaterial = g_pMaterialSSAODepthWrite[nAlphaTest][nNoCull];
				}
				else
				{
					pDepthWriteMaterial = g_pMaterialDepthWrite[nAlphaTest][nNoCull];
				}

				if ( nAlphaTest == 1 )
				{
					static unsigned int originalTextureVarCache = 0;
					IMaterialVar *pOriginalTextureVar = batch.pMaterial->FindVarFast( "$basetexture", &originalTextureVarCache );
					static unsigned int originalTextureFrameVarCache = 0;
					IMaterialVar *pOriginalTextureFrameVar = batch.pMaterial->FindVarFast( "$frame", &originalTextureFrameVarCache );
					static unsigned int originalAlphaRefCache = 0;
					IMaterialVar *pOriginalAlphaRefVar = batch.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() );
					}
				}

				pMaterial = pDepthWriteMaterial;
			}
			else
			{
				pMaterial = batch.pMaterial;

				// Store off the old color + alpha
				ModulateMaterial( pMaterial, pOldColor );
				if ( !skipLight )
				{
					pRenderContext->BindLightmapPage( materialSortInfoArray[batch.sortID].lightmapPageID );
				}
			}

			pRenderContext->Bind( pMaterial, pProxyData );
#ifdef NEWMESH
			IIndexBuffer *pBuildIndexBuffer = pRenderContext->GetDynamicIndexBuffer( MATERIAL_INDEX_FORMAT_16BIT, false );
			CIndexBufferBuilder indexBufferBuilder;
			indexBufferBuilder.Begin( pBuildIndexBuffer, batch.indexCount );
#else
			IMesh *pBuildMesh = pRenderContext->GetDynamicMesh( false, g_WorldStaticMeshes[batch.sortID], NULL, NULL );
			meshBuilder.Begin( pBuildMesh, MATERIAL_TRIANGLES, 0, batch.indexCount );
#endif

			for ( ; k < batch.surfaceCount; k++ )
			{
				brushrendersurface_t &surface = pRender->pSurfaces[batch.firstSurface + k];
				if ( backface[surface.planeIndex] )
					continue;
				SurfaceHandle_t surfID = firstSurfID + surface.surfaceIndex;

				Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );
#ifdef NEWMESH
				BuildIndicesForSurface( indexBufferBuilder, surfID );
#else
				BuildIndicesForSurface( meshBuilder, surfID );
#endif

				if( SurfaceHasDecals( surfID ) && DepthMode == DEPTH_MODE_NORMAL )
				{
					DecalSurfaceAdd( surfID, BRUSHMODEL_DECAL_SORT_GROUP );
				}

				// Add overlay fragments to list.
				// FIXME: A little code support is necessary to get overlays working on brush models
				//	OverlayMgr()->AddFragmentListToRenderList( MSurf_OverlayFragmentList( surfID ), false );

				if ( DepthMode == DEPTH_MODE_NORMAL )
				{
					// Add render-to-texture shadows too....
					ShadowDecalHandle_t decalHandle = MSurf_ShadowDecals( surfID );
					if (decalHandle != SHADOW_DECAL_HANDLE_INVALID)
					{
						g_pShadowMgr->AddShadowsOnSurfaceToRenderList( decalHandle );
					}
				}
			}
			
#ifdef NEWMESH
			indexBufferBuilder.End( false ); // this one is broken (opaque brush model. .tv)
			pRenderContext->BindVertexBuffer( 0, g_WorldStaticMeshes[batch.sortID], 0, g_WorldStaticMeshes[batch.sortID]->GetVertexFormat() );
			pRenderContext->BindIndexBuffer( pBuildIndexBuffer, 0 );
			pRenderContext->Draw( MATERIAL_TRIANGLES, 0, pBuildIndexBuffer->NumIndices() );//batch.indexCount );
#else
			meshBuilder.End( false, true );
#endif

			if ( DepthMode == DEPTH_MODE_NORMAL )
			{
				// Don't leave the material in a bogus state
				UnModulateMaterial( pMaterial, pOldColor );
			}
		}
	}

	if ( DepthMode != DEPTH_MODE_NORMAL )
	{
		return;
	}

	if ( g_ShaderDebug.anydebug )
	{
		for ( i = 0; i < pRender->meshCount; i++ )
		{
			brushrendermesh_t &mesh = pRender->pMeshes[i];
			CUtlVector<msurface2_t *> brushList;
			for ( int j = 0; j < mesh.batchCount; j++ )
			{
				brushrenderbatch_t &batch = pRender->pBatches[mesh.firstBatch + j];
				for ( int k = 0; k < batch.surfaceCount; k++ )
				{
					brushrendersurface_t &surface = pRender->pSurfaces[batch.firstSurface + k];
					if ( backface[surface.planeIndex] )
						continue;
					SurfaceHandle_t surfID = firstSurfID + surface.surfaceIndex;
					brushList.AddToTail(surfID);
				}
			}
			// now draw debug for each drawn surface
			DrawDebugInformation( brushList );
		}
	}
}

//-----------------------------------------------------------------------------
// Draws an translucent (sorted) brush model
//-----------------------------------------------------------------------------
void CBrushBatchRender::DrawTranslucentBrushModel( IClientEntity *baseentity, model_t *model, const Vector& origin, bool bShadowDepth, bool bDrawOpaque, bool bDrawTranslucent )
{
	if ( bDrawOpaque )
	{
		DrawOpaqueBrushModel( baseentity, model, origin, bShadowDepth ? DEPTH_MODE_SHADOW : DEPTH_MODE_NORMAL );
	}

	if ( !bShadowDepth && bDrawTranslucent )
	{
		DrawTranslucentBrushModel( model, baseentity );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Draws a brush model shadow for render-to-texture shadows
//-----------------------------------------------------------------------------
// UNDONE: This is reasonable, but it could be much faster as follows:
// Build a vertex buffer cache.  A block-allocated static mesh with 1024 verts
// per block or something.
// When a new brush is encountered, fill it in to the current block or the 
// next one (first fit allocator).  Then this routine could simply draw
// a static mesh with a single index buffer build, draw call (no dynamic vb).
void CBrushBatchRender::DrawBrushModelShadow( model_t *model, IClientRenderable *pRenderable )
{
	brushrender_t *pRender = FindOrCreateRenderBatch( (model_t *)model );
	if ( !pRender )
		return;

	CMatRenderContextPtr pRenderContext( materials );

	pRenderContext->Bind( g_pMaterialShadowBuild, pRenderable );

	// Draws all surfaces in the brush model in arbitrary order
	SurfaceHandle_t surfID = SurfaceHandleFromIndex( model->brush.firstmodelsurface, model->brush.pShared );
	IMesh *pMesh = pRenderContext->GetDynamicMesh();
	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, pRender->totalVertexCount, pRender->totalIndexCount );

	for ( int i=0 ; i<model->brush.nummodelsurfaces ; i++, surfID++)
	{
		Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );

		if ( MSurf_Flags(surfID) & SURFDRAW_TRANS )
			continue;

		int startVert = MSurf_FirstVertIndex( surfID );
		int vertCount = MSurf_VertCount( surfID );
		int startIndex = meshBuilder.GetCurrentVertex();
		int j;
		for ( j = 0; j < vertCount; j++ )
		{
			int vertIndex = model->brush.pShared->vertindices[startVert + j];

			// world-space vertex
			meshBuilder.Position3fv( model->brush.pShared->vertexes[vertIndex].position.Base() );
			meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
			meshBuilder.AdvanceVertex();
		}

		for ( j = 0; j < vertCount-2; j++ )
		{
			meshBuilder.FastIndex( startIndex );
			meshBuilder.FastIndex( startIndex + j + 1 );
			meshBuilder.FastIndex( startIndex + j + 2 );
		}
	}
	meshBuilder.End();
	pMesh->Draw();
}

void R_Surface_LevelInit()
{
	g_BrushBatchRenderer.LevelInit();
	// reset this to the default at the start of each level
	g_MaxLeavesVisible = 512;
}


void R_Surface_LevelShutdown()
{
	CWorldRenderList::PurgeAll();
}

//-----------------------------------------------------------------------------
static void R_DrawBrushModel_Override( IClientEntity *baseentity, model_t *model, const Vector& origin )
{
	VPROF( "R_DrawOpaqueBrushModel_Override" );
	SurfaceHandle_t surfID = SurfaceHandleFromIndex( model->brush.firstmodelsurface, model->brush.pShared );
	for (int i=0 ; i<model->brush.nummodelsurfaces ; i++, surfID++)
	{
		Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );

		Shader_BrushSurface( surfID, model, baseentity );
	}
	// now draw debug for each drawn surface
	if ( g_ShaderDebug.anydebug )
	{
		CUtlVector<msurface2_t *> surfaceList;
		surfID = SurfaceHandleFromIndex( model->brush.firstmodelsurface, model->brush.pShared );
		for (int i=0 ; i<model->brush.nummodelsurfaces ; i++, surfID++)
		{
			surfaceList.AddToTail(surfID);
		}
		DrawDebugInformation( surfaceList );
	}
}

int R_MarkDlightsOnBrushModel( model_t *model, IClientRenderable *pRenderable )
{
	int count = 0;
	if ( g_bActiveDlights )
	{
		extern int R_MarkLights (dlight_t *light, int bit, mnode_t *node);

		g_BrushToWorldMatrix.SetupMatrixOrgAngles( pRenderable->GetRenderOrigin(), pRenderable->GetRenderAngles() );
		Vector saveOrigin;

		for (int k=0 ; k<MAX_DLIGHTS ; k++)
		{
			if ((cl_dlights[k].die < cl.GetTime()) ||
				(!cl_dlights[k].IsRadiusGreaterThanZero()))
				continue;

			VectorCopy( cl_dlights[k].origin, saveOrigin );
			cl_dlights[k].origin = g_BrushToWorldMatrix.VMul4x3Transpose( saveOrigin );

			mnode_t *node = model->brush.pShared->nodes + model->brush.firstnode;
			if ( IsBoxIntersectingSphereExtents( node->m_vecCenter, node->m_vecHalfDiagonal, cl_dlights[k].origin, cl_dlights[k].GetRadius() ) )
			{
				count += R_MarkLights( &cl_dlights[k], 1<<k, node );
			}
			VectorCopy( saveOrigin, cl_dlights[k].origin );
		}
		if ( count )
		{
			model->flags |= MODELFLAG_HAS_DLIGHT;
		}
		g_BrushToWorldMatrix.Identity();
	}
	return count;
}


//-----------------------------------------------------------------------------
// Stuff to do right before and after brush model rendering
//-----------------------------------------------------------------------------
void Shader_BrushBegin( model_t *model, IClientEntity *baseentity /*=NULL*/ )
{
	// Clear out the render list of decals
	DecalSurfacesInit( true );

	// Clear out the render lists of shadows
	g_pShadowMgr->ClearShadowRenderList( );
}

void Shader_BrushEnd( IMatRenderContext *pRenderContext, VMatrix const* pBrushToWorld, model_t *model, bool bShadowDepth, IClientEntity *baseentity /* = NULL */ )
{
	if ( bShadowDepth )
		return;

	DecalSurfaceDraw(pRenderContext, BRUSHMODEL_DECAL_SORT_GROUP);

	// draw the flashlight lighting for the decals on the brush.
	g_pShadowMgr->DrawFlashlightDecals( BRUSHMODEL_DECAL_SORT_GROUP, false );

	// Draw all shadows on the brush
	g_pShadowMgr->RenderProjectedTextures( pBrushToWorld );
}

class CBrushModelTransform
{
public:
	CBrushModelTransform( const Vector &origin, const QAngle &angles, IMatRenderContext *pRenderContext )
	{
		bool rotated = ( angles[0] || angles[1] || angles[2] );
		m_bIdentity = (origin == vec3_origin) && (!rotated);

		// Don't change state if we don't need to
		if (!m_bIdentity)
		{
			m_savedModelorg = modelorg;
			pRenderContext->MatrixMode( MATERIAL_MODEL );
			pRenderContext->PushMatrix();
			g_BrushToWorldMatrix.SetupMatrixOrgAngles( origin, angles );
			pRenderContext->LoadMatrix( g_BrushToWorldMatrix );
			modelorg = g_BrushToWorldMatrix.VMul4x3Transpose(g_EngineRenderer->ViewOrigin());
		}
	}
	~CBrushModelTransform()
	{
		if ( !m_bIdentity )
		{
			CMatRenderContextPtr pRenderContext( materials );
			pRenderContext->MatrixMode( MATERIAL_MODEL );
			pRenderContext->PopMatrix();
			g_BrushToWorldMatrix.Identity();
			modelorg = m_savedModelorg;
		}
	}

	VMatrix *GetNonIdentityMatrix()
	{
		return m_bIdentity ? NULL : &g_BrushToWorldMatrix;
	}

	inline bool IsIdentity() { return m_bIdentity; }

	Vector	m_savedModelorg;
	bool	m_bIdentity;
};

//-----------------------------------------------------------------------------
// Purpose: Draws a brush model using the global shader/surfaceVisitor
// Input  : *e - entity to draw
// Output : void R_DrawBrushModel
//-----------------------------------------------------------------------------
void R_DrawBrushModel( IClientEntity *baseentity, model_t *model, 
	const Vector& origin, const QAngle& angles, ERenderDepthMode DepthMode, bool bDrawOpaque, bool bDrawTranslucent )
{
	VPROF( "R_DrawBrushModel" );

#ifdef USE_CONVARS
	if ( !r_drawbrushmodels.GetInt() )
	{
		return;
	}
	bool bWireframe = false;
	if ( r_drawbrushmodels.GetInt() == 2 )
	{
		// save and override
		bWireframe = g_ShaderDebug.wireframe;
		g_ShaderDebug.wireframe = true;
		g_ShaderDebug.anydebug = true;
	}
#endif

	CMatRenderContextPtr pRenderContext( materials );
	CBrushModelTransform brushTransform( origin, angles, pRenderContext );

	Assert(model->brush.firstmodelsurface != 0);

	// Draw the puppy...
	Shader_BrushBegin( model, baseentity );
	
	if ( model->flags & MODELFLAG_FRAMEBUFFER_TEXTURE )
	{
		CMatRenderContextPtr pRenderContextMat( materials );
		pRenderContext->CopyRenderTargetToTexture( pRenderContextMat->GetFrameBufferCopyTexture( 0 ) );
	}

	if ( s_pBrushRenderOverride )
	{
		R_DrawBrushModel_Override( baseentity, model, origin );
	}
	else
	{
		if ( model->flags & MODELFLAG_TRANSLUCENT )
		{
			if ( DepthMode == DEPTH_MODE_NORMAL )
			{
				g_BrushBatchRenderer.DrawTranslucentBrushModel( baseentity, model, origin, false, bDrawOpaque, bDrawTranslucent );
			}
		}
		else if ( bDrawOpaque )
		{
			g_BrushBatchRenderer.DrawOpaqueBrushModel( baseentity, model, origin, DepthMode );
		}
	}

	Shader_BrushEnd( pRenderContext, brushTransform.GetNonIdentityMatrix(), model, DepthMode != DEPTH_MODE_NORMAL, baseentity );

#ifdef USE_CONVARS
	if ( r_drawbrushmodels.GetInt() == 2 )
	{
		// restore
		g_ShaderDebug.wireframe = bWireframe;
		g_ShaderDebug.TestAnyDebug();
	}
#endif
}


//-----------------------------------------------------------------------------
// Purpose: Draws a brush model shadow for render-to-texture shadows
//-----------------------------------------------------------------------------

void R_DrawBrushModelShadow( IClientRenderable *pRenderable )
{
	if( !r_drawbrushmodels.GetInt() )
		return;

	model_t *model = (model_t *)pRenderable->GetModel();
	const Vector& origin = pRenderable->GetRenderOrigin();
	QAngle const& angles = pRenderable->GetRenderAngles();

	CMatRenderContextPtr pRenderContext( materials );
	CBrushModelTransform brushTransform( origin, angles, pRenderContext );
	g_BrushBatchRenderer.DrawBrushModelShadow( model, pRenderable );
}


void R_DrawIdentityBrushModel( IWorldRenderList *pRenderListIn, model_t *model )
{
	if ( !model )
		return;

	CWorldRenderList *pRenderList = assert_cast<CWorldRenderList *>(pRenderListIn);

	SurfaceHandle_t surfID = SurfaceHandleFromIndex( model->brush.firstmodelsurface, model->brush.pShared );
	
	for (int j=0 ; j<model->brush.nummodelsurfaces ; ++j, surfID++)
	{
		Assert( !(MSurf_Flags( surfID ) & SURFDRAW_NODRAW) );

		// FIXME: Can't insert translucent stuff into the list
		// of translucent surfaces because we don't know what leaf
		// we're in. At the moment, the client doesn't add translucent
		// brushes to the identity brush model list
//		Assert ( (psurf->flags & SURFDRAW_TRANS ) == 0 );

		// OPTIMIZE: Backface cull these guys?!?!?
		if ( MSurf_Flags( surfID ) & SURFDRAW_TRANS)
//		if ( psurf->texinfo->material->IsTranslucent() )
		{
			Shader_TranslucentWorldSurface( pRenderList, surfID );
		}
		else
		{
			Shader_WorldSurface( pRenderList, surfID );
		}
	}
}
#endif
//-----------------------------------------------------------------------------
// Converts leaf pointer to index
//-----------------------------------------------------------------------------
inline int LeafToIndex( mleaf_t* pLeaf )
{
	return pLeaf - host_state.worldbrush->leafs;
}


//-----------------------------------------------------------------------------
// Structures to help out with enumeration
//-----------------------------------------------------------------------------
enum
{
	ENUM_SPHERE_TEST_X = 0x1,
	ENUM_SPHERE_TEST_Y = 0x2,
	ENUM_SPHERE_TEST_Z = 0x4,

	ENUM_SPHERE_TEST_ALL = 0x7
};

struct EnumLeafBoxInfo_t
{
	VectorAligned m_vecBoxMax;
	VectorAligned m_vecBoxMin;
	VectorAligned m_vecBoxCenter;
	VectorAligned m_vecBoxHalfDiagonal;
	ISpatialLeafEnumerator *m_pIterator;
	int	m_nContext;
};

struct EnumLeafSphereInfo_t
{
	Vector m_vecCenter;
	float m_flRadius;
	Vector m_vecBoxCenter;
	Vector m_vecBoxHalfDiagonal;
	ISpatialLeafEnumerator *m_pIterator;
	int	m_nContext;
};

//-----------------------------------------------------------------------------
// Finds all leaves of the BSP tree within a particular volume
//-----------------------------------------------------------------------------
static bool EnumerateLeafInBox_R(mnode_t *node, EnumLeafBoxInfo_t& info )
{
	// no polygons in solid nodes (don't report these leaves either)
	if (node->contents == CONTENTS_SOLID)
		return true;		// solid

	// rough cull...
	if (!IsBoxIntersectingBoxExtents(node->m_vecCenter, node->m_vecHalfDiagonal, 
		info.m_vecBoxCenter, info.m_vecBoxHalfDiagonal))
	{
		return true;
	}
	
	if (node->contents >= 0)
	{
		// if a leaf node, report it to the iterator...
		return info.m_pIterator->EnumerateLeaf( LeafToIndex( (mleaf_t *)node ), info.m_nContext ); 
	}

	// Does the node plane split the box?
	// find which side of the node we are on
	cplane_t* plane = node->plane;
	if ( plane->type <= PLANE_Z )
	{
		if (info.m_vecBoxMax[plane->type] <= plane->dist)
		{
			return EnumerateLeafInBox_R( node->children[1], info );
		}
		else if (info.m_vecBoxMin[plane->type] >= plane->dist)
		{
			return EnumerateLeafInBox_R( node->children[0], info );
		}
		else
		{
			// Here the box is split by the node
			bool ret = EnumerateLeafInBox_R( node->children[0], info );
			if (!ret)
				return false;

			return EnumerateLeafInBox_R( node->children[1], info );
		}
	}

	// Arbitrary split plane here
	Vector cornermin, cornermax;
	for (int i = 0; i < 3; ++i)
	{
		if (plane->normal[i] >= 0)
		{
			cornermin[i] = info.m_vecBoxMin[i];
			cornermax[i] = info.m_vecBoxMax[i];
		}
		else
		{
			cornermin[i] = info.m_vecBoxMax[i];
			cornermax[i] = info.m_vecBoxMin[i];
		}
	}

	if (DotProduct( plane->normal, cornermax ) <= plane->dist)
	{
		return EnumerateLeafInBox_R( node->children[1], info );
	}
	else if (DotProduct( plane->normal, cornermin ) >= plane->dist)
	{
		return EnumerateLeafInBox_R( node->children[0], info );
	}
	else
	{
		// Here the box is split by the node
		bool ret = EnumerateLeafInBox_R( node->children[0], info );
		if (!ret)
			return false;

		return EnumerateLeafInBox_R( node->children[1], info );
	}
}

#ifdef _X360

static fltx4 AlignThatVector(const Vector &vc)
{
	fltx4 out = __loadunalignedvector(vc.Base());

	/*
	out.x = vc.x;
	out.y = vc.y;
	out.z = vc.z;
	*/

	// squelch the w component 
	return __vrlimi( out, __vzero(), 1, 0 );
}

//-----------------------------------------------------------------------------
// Finds all leaves of the BSP tree within a particular volume
//-----------------------------------------------------------------------------
static bool EnumerateLeafInBox_R(mnode_t * RESTRICT node, const EnumLeafBoxInfo_t * RESTRICT pInfo )
{
	// no polygons in solid nodes (don't report these leaves either)
	if (node->contents == CONTENTS_SOLID)
		return true;		// solid

	// speculatively get the children into the cache
	__dcbt(0,node->children[0]);
	__dcbt(0,node->children[1]);

	// constructing these here prevents LHS if we spill.
	// it's not quite a quick enough operation to do extemporaneously.
	fltx4 infoBoxCenter = LoadAlignedSIMD(pInfo->m_vecBoxCenter);
	fltx4 infoBoxHalfDiagonal = LoadAlignedSIMD(pInfo->m_vecBoxHalfDiagonal);

	Assert(IsBoxIntersectingBoxExtents(AlignThatVector(node->m_vecCenter), AlignThatVector(node->m_vecHalfDiagonal), 
			LoadAlignedSIMD(pInfo->m_vecBoxCenter), LoadAlignedSIMD(pInfo->m_vecBoxHalfDiagonal)) ==
			IsBoxIntersectingBoxExtents((node->m_vecCenter), node->m_vecHalfDiagonal,
			pInfo->m_vecBoxCenter, pInfo->m_vecBoxHalfDiagonal));


	// rough cull...
	if (!IsBoxIntersectingBoxExtents(LoadAlignedSIMD(node->m_vecCenter), LoadAlignedSIMD(node->m_vecHalfDiagonal), 
		infoBoxCenter, infoBoxHalfDiagonal))
	{
		return true;
	}

	if (node->contents >= 0)
	{
		// if a leaf node, report it to the iterator...
		return pInfo->m_pIterator->EnumerateLeaf( LeafToIndex( (mleaf_t *)node ), pInfo->m_nContext ); 
	}

	// Does the node plane split the box?
	// find which side of the node we are on
	cplane_t* RESTRICT plane = node->plane;
	if ( plane->type <= PLANE_Z )
	{
		if (pInfo->m_vecBoxMax[plane->type] <= plane->dist)
		{
			return EnumerateLeafInBox_R( node->children[1], pInfo );
		}
		else if (pInfo->m_vecBoxMin[plane->type] >= plane->dist)
		{
			return EnumerateLeafInBox_R( node->children[0], pInfo );
		}
		else
		{
			// Here the box is split by the node
			return EnumerateLeafInBox_R( node->children[0], pInfo ) && 
				   EnumerateLeafInBox_R( node->children[1], pInfo );
		}
	}

	// Arbitrary split plane here
	/*
	Vector cornermin, cornermax;
	for (int i = 0; i < 3; ++i)
	{
		if (plane->normal[i] >= 0)
		{
			cornermin[i] = info.m_vecBoxMin[i];
			cornermax[i] = info.m_vecBoxMax[i];
		}
		else
		{
			cornermin[i] = info.m_vecBoxMax[i];
			cornermax[i] = info.m_vecBoxMin[i];
		}
	}
	*/
	
	// take advantage of high throughput/high latency
	fltx4 planeNormal = LoadUnaligned3SIMD( plane->normal.Base() );
	fltx4 vecBoxMin = LoadAlignedSIMD(pInfo->m_vecBoxMin);
	fltx4 vecBoxMax = LoadAlignedSIMD(pInfo->m_vecBoxMax);
	fltx4 cornermin, cornermax;
	// by now planeNormal is ready...
	fltx4 control = XMVectorGreaterOrEqual( planeNormal, __vzero() );
	// now control[i] = planeNormal[i] > 0 ? 0xFF : 0x00
	cornermin = XMVectorSelect( vecBoxMax, vecBoxMin, control); // cornermin[i] = control[i] ? vecBoxMin[i] : vecBoxMax[i]
	cornermax = XMVectorSelect( vecBoxMin, vecBoxMax, control);

	// compute dot products
	fltx4 dotCornerMax = __vmsum3fp(planeNormal, cornermax); // vsumfp ignores w component
	fltx4 dotCornerMin = __vmsum3fp(planeNormal, cornermin);
	fltx4 vPlaneDist = ReplicateX4(plane->dist);
	UINT conditionRegister;
	XMVectorGreaterR(&conditionRegister,vPlaneDist,dotCornerMax);
	if (XMComparisonAllTrue(conditionRegister)) // plane->normal . cornermax <= plane->dist
		return EnumerateLeafInBox_R( node->children[1], pInfo );

	XMVectorGreaterOrEqualR(&conditionRegister,dotCornerMin,vPlaneDist);
	if ( XMComparisonAllTrue(conditionRegister) )
		return EnumerateLeafInBox_R( node->children[0], pInfo );

	return EnumerateLeafInBox_R( node->children[0], pInfo ) &&
		   EnumerateLeafInBox_R( node->children[1], pInfo );

	/*
	if (DotProduct( plane->normal, cornermax ) <= plane->dist)
	{
		return EnumerateLeafInBox_R( node->children[1], info, infoBoxCenter, infoBoxHalfDiagonal );
	}
	else if (DotProduct( plane->normal, cornermin ) >= plane->dist)
	{
		return EnumerateLeafInBox_R( node->children[0], info, infoBoxCenter, infoBoxHalfDiagonal );
	}
	else
	{
		// Here the box is split by the node
		bool ret = EnumerateLeafInBox_R( node->children[0], info, infoBoxCenter, infoBoxHalfDiagonal );
		if (!ret)
			return false;

		return EnumerateLeafInBox_R( node->children[1], info, infoBoxCenter, infoBoxHalfDiagonal );
	}
	*/
}
#endif

//-----------------------------------------------------------------------------
// Returns all leaves that lie within a spherical volume
//-----------------------------------------------------------------------------
bool EnumerateLeafInSphere_R( mnode_t *node, EnumLeafSphereInfo_t& info, int nTestFlags )
{
	while (true)
	{
		// no polygons in solid nodes (don't report these leaves either)
		if (node->contents == CONTENTS_SOLID)
			return true;		// solid

		if (node->contents >= 0)
		{
			// leaf cull...
			// NOTE: using nTestFlags here means that we may be passing in some 
			// leaves that don't actually intersect the sphere, but instead intersect
			// the box that surrounds the sphere.
			if (nTestFlags)
			{
				if (!IsBoxIntersectingSphereExtents (node->m_vecCenter, node->m_vecHalfDiagonal, info.m_vecCenter, info.m_flRadius))
					return true;
			}

			// if a leaf node, report it to the iterator...
			return info.m_pIterator->EnumerateLeaf( LeafToIndex( (mleaf_t *)node ), info.m_nContext ); 
		}
		else if (nTestFlags)
		{
			if (node->contents == -1)
			{
				// faster cull...
				if (nTestFlags & ENUM_SPHERE_TEST_X)
				{
					float flDelta = FloatMakePositive( node->m_vecCenter.x - info.m_vecBoxCenter.x );
					float flSize = node->m_vecHalfDiagonal.x + info.m_vecBoxHalfDiagonal.x;
					if ( flDelta > flSize )
						return true;

					// This checks for the node being completely inside the box...
					if ( flDelta + node->m_vecHalfDiagonal.x < info.m_vecBoxHalfDiagonal.x )
						nTestFlags &= ~ENUM_SPHERE_TEST_X;
				}

				if (nTestFlags & ENUM_SPHERE_TEST_Y)
				{
					float flDelta = FloatMakePositive( node->m_vecCenter.y - info.m_vecBoxCenter.y );
					float flSize = node->m_vecHalfDiagonal.y + info.m_vecBoxHalfDiagonal.y;
					if ( flDelta > flSize )
						return true;

					// This checks for the node being completely inside the box...
					if ( flDelta + node->m_vecHalfDiagonal.y < info.m_vecBoxHalfDiagonal.y )
						nTestFlags &= ~ENUM_SPHERE_TEST_Y;
				}

				if (nTestFlags & ENUM_SPHERE_TEST_Z)
				{
					float flDelta = FloatMakePositive( node->m_vecCenter.z - info.m_vecBoxCenter.z );
					float flSize = node->m_vecHalfDiagonal.z + info.m_vecBoxHalfDiagonal.z;
					if ( flDelta > flSize )
						return true;
														   
					if ( flDelta + node->m_vecHalfDiagonal.z < info.m_vecBoxHalfDiagonal.z )
						nTestFlags &= ~ENUM_SPHERE_TEST_Z;
				}
			}
			else if (node->contents == -2)
			{
				// If the box is too small to bother with testing, then blat out the flags
				nTestFlags = 0;
			}
		}

		// Does the node plane split the sphere?
		// find which side of the node we are on
		float flNormalDotCenter;
		cplane_t* plane = node->plane;
		if ( plane->type <= PLANE_Z )
		{
			flNormalDotCenter = info.m_vecCenter[plane->type];
		}
		else
		{
			// Here, we've got a plane which is not axis aligned, so we gotta do more work
			flNormalDotCenter = DotProduct( plane->normal, info.m_vecCenter );
		}

		if (flNormalDotCenter + info.m_flRadius <= plane->dist)
		{
			node = node->children[1];
		}
		else if (flNormalDotCenter - info.m_flRadius >= plane->dist)
		{
			node = node->children[0];
		}
		else
		{
			// Here the box is split by the node
			if (!EnumerateLeafInSphere_R( node->children[0], info, nTestFlags ))
				return false;

			node = node->children[1];
		}
	}
}


//-----------------------------------------------------------------------------
// Enumerate leaves along a non-extruded ray
//-----------------------------------------------------------------------------

static bool EnumerateLeavesAlongRay_R( mnode_t *node, Ray_t const& ray, 
	float start, float end, ISpatialLeafEnumerator* pEnum, int context )
{
	// no polygons in solid nodes (don't report these leaves either)
	if (node->contents == CONTENTS_SOLID)
		return true;		// solid, keep recursing

	// didn't hit anything
	if (node->contents >= 0)
	{
		// if a leaf node, report it to the iterator...
		return pEnum->EnumerateLeaf( LeafToIndex( (mleaf_t *)node ), context ); 
	}
	
	// Determine which side of the node plane our points are on
	cplane_t* plane = node->plane;

	float startDotN,deltaDotN;
	if (plane->type <= PLANE_Z)
	{
		startDotN = ray.m_Start[plane->type];
		deltaDotN = ray.m_Delta[plane->type];
	}
	else
	{
		startDotN = DotProduct( ray.m_Start, plane->normal );
		deltaDotN = DotProduct( ray.m_Delta, plane->normal );
	}

	float front = startDotN + start * deltaDotN - plane->dist;
	float back = startDotN + end * deltaDotN - plane->dist;

	int side = front < 0;
	
	// If they're both on the same side of the plane, don't bother to split
	// just check the appropriate child
	if ( (back < 0) == side )
	{
		return EnumerateLeavesAlongRay_R (node->children[side], ray, start, end, pEnum, context );
	}
	
	// calculate mid point
	float frac = front / (front - back);
	float mid = start * (1.0f - frac) + end * frac;
	
	// go down front side	
	bool ok = EnumerateLeavesAlongRay_R (node->children[side], ray, start, mid, pEnum, context );
	if (!ok)
		return ok;

	// go down back side
	return EnumerateLeavesAlongRay_R (node->children[!side], ray, mid, end, pEnum, context );
}


//-----------------------------------------------------------------------------
// Enumerate leaves along a non-extruded ray
//-----------------------------------------------------------------------------

static bool EnumerateLeavesAlongExtrudedRay_R( mnode_t *node, Ray_t const& ray, 
	float start, float end, ISpatialLeafEnumerator* pEnum, int context )
{
	// no polygons in solid nodes (don't report these leaves either)
	if (node->contents == CONTENTS_SOLID)
		return true;		// solid, keep recursing

	// didn't hit anything
	if (node->contents >= 0)
	{
		// if a leaf node, report it to the iterator...
		return pEnum->EnumerateLeaf( LeafToIndex( (mleaf_t *)node ), context ); 
	}
	
	// Determine which side of the node plane our points are on
	cplane_t* plane = node->plane;

	//
	float t1, t2, offset;
	float startDotN,deltaDotN;
	if (plane->type <= PLANE_Z)
	{
		startDotN = ray.m_Start[plane->type];
		deltaDotN = ray.m_Delta[plane->type];
		offset = ray.m_Extents[plane->type] + DIST_EPSILON;
	}
	else
	{
		startDotN = DotProduct( ray.m_Start, plane->normal );
		deltaDotN = DotProduct( ray.m_Delta, plane->normal );
		offset = fabs(ray.m_Extents[0]*plane->normal[0]) +
				fabs(ray.m_Extents[1]*plane->normal[1]) +
				fabs(ray.m_Extents[2]*plane->normal[2]) + DIST_EPSILON;
	}
	t1 = startDotN + start * deltaDotN - plane->dist;
	t2 = startDotN + end * deltaDotN - plane->dist;

	// If they're both on the same side of the plane (further than the trace
	// extents), don't bother to split, just check the appropriate child
    if (t1 > offset && t2 > offset )
//	if (t1 >= offset && t2 >= offset)
	{
		return EnumerateLeavesAlongExtrudedRay_R( node->children[0], ray,
			start, end, pEnum, context );
	}
	if (t1 < -offset && t2 < -offset)
	{
		return EnumerateLeavesAlongExtrudedRay_R( node->children[1], ray,
			start, end, pEnum, context );
	}

	// For the segment of the line that we are going to use
	// to test against the back side of the plane, we're going
	// to use the part that goes from start to plane + extent
	// (which causes it to extend somewhat into the front halfspace,
	// since plane + extent is in the front halfspace).
	// Similarly, front the segment which tests against the front side,
	// we use the entire front side part of the ray + a portion of the ray that
	// extends by -extents into the back side.

	if (fabs(t1-t2) < DIST_EPSILON)
	{
		// Parallel case, send entire ray to both children...
		bool ret = EnumerateLeavesAlongExtrudedRay_R( node->children[0], 
			ray, start, end, pEnum, context );
		if (!ret)
			return false;
		return EnumerateLeavesAlongExtrudedRay_R( node->children[1],
			ray, start, end, pEnum, context );
	}
	
	// Compute the two fractions...
	// We need one at plane + extent and another at plane - extent.
	// put the crosspoint DIST_EPSILON pixels on the near side
	float idist, frac2, frac;
	int side;
	if (t1 < t2)
	{
		idist = 1.0/(t1-t2);
		side = 1;
		frac2 = (t1 + offset) * idist;
		frac = (t1 - offset) * idist;
	}
	else if (t1 > t2)
	{
		idist = 1.0/(t1-t2);
		side = 0;
		frac2 = (t1 - offset) * idist;
		frac = (t1 + offset) * idist;
	}
	else
	{
		side = 0;
		frac = 1;
		frac2 = 0;
	}

	// move up to the node
	frac = clamp( frac, 0.f, 1.f );
	float midf = start + (end - start)*frac;
	bool ret = EnumerateLeavesAlongExtrudedRay_R( node->children[side], ray, start, midf, pEnum, context );
	if (!ret)
		return ret;

	// go past the node
	frac2 = clamp( frac2, 0.f, 1.f );
	midf = start + (end - start)*frac2;
	return EnumerateLeavesAlongExtrudedRay_R( node->children[!side], ray, midf, end, pEnum, context );
}


//-----------------------------------------------------------------------------
//
// Helper class to iterate over leaves
//
//-----------------------------------------------------------------------------

class CEngineBSPTree : public IEngineSpatialQuery
{
public:
	// Returns the number of leaves
	int LeafCount() const;

	// Enumerates the leaves along a ray, box, etc.
	bool EnumerateLeavesAtPoint( const Vector& pt, ISpatialLeafEnumerator* pEnum, int context );
	bool EnumerateLeavesInBox( const Vector& mins, const Vector& maxs, ISpatialLeafEnumerator* pEnum, int context );
	bool EnumerateLeavesInSphere( const Vector& center, float radius, ISpatialLeafEnumerator* pEnum, int context );
	bool EnumerateLeavesAlongRay( Ray_t const& ray, ISpatialLeafEnumerator* pEnum, int context );
};

//-----------------------------------------------------------------------------
// Singleton accessor
//-----------------------------------------------------------------------------

static CEngineBSPTree s_ToolBSPTree;
IEngineSpatialQuery* g_pToolBSPTree = &s_ToolBSPTree;


//-----------------------------------------------------------------------------
// Returns the number of leaves
//-----------------------------------------------------------------------------

int CEngineBSPTree::LeafCount() const
{
	return host_state.worldbrush->numleafs;
}

//-----------------------------------------------------------------------------
// Enumerates the leaves at a point
//-----------------------------------------------------------------------------

bool CEngineBSPTree::EnumerateLeavesAtPoint( const Vector& pt, 
									ISpatialLeafEnumerator* pEnum, int context )
{
	int leaf = CM_PointLeafnum( pt );
	return pEnum->EnumerateLeaf( leaf, context );
}


static ConVar opt_EnumerateLeavesFastAlgorithm( "opt_EnumerateLeavesFastAlgorithm", "1", FCVAR_NONE, "Use the new SIMD version of CEngineBSPTree::EnumerateLeavesInBox." ); 


bool CEngineBSPTree::EnumerateLeavesInBox( const Vector& mins, const Vector& maxs, 
									ISpatialLeafEnumerator* pEnum, int context )
{
	if ( !host_state.worldmodel )
		return false;

	EnumLeafBoxInfo_t info;
	VectorAdd( mins, maxs, info.m_vecBoxCenter );
	info.m_vecBoxCenter *= 0.5f;
	VectorSubtract( maxs, info.m_vecBoxCenter, info.m_vecBoxHalfDiagonal );
	info.m_pIterator = pEnum;
	info.m_nContext = context;
	info.m_vecBoxMax = maxs;
	info.m_vecBoxMin = mins;
#ifdef _X360
	if (opt_EnumerateLeavesFastAlgorithm.GetBool())
		return EnumerateLeafInBox_R( host_state.worldbrush->nodes, &info );
	else
		return EnumerateLeafInBox_R( host_state.worldbrush->nodes, info );
#else
	return EnumerateLeafInBox_R( host_state.worldbrush->nodes, info );
#endif
}


bool CEngineBSPTree::EnumerateLeavesInSphere( const Vector& center, float radius, 
									ISpatialLeafEnumerator* pEnum, int context )
{
	EnumLeafSphereInfo_t info;
	info.m_vecCenter = center;
	info.m_flRadius = radius;
	info.m_pIterator = pEnum;
	info.m_nContext = context;
	info.m_vecBoxCenter = center;
	info.m_vecBoxHalfDiagonal.Init( radius, radius, radius );

	return EnumerateLeafInSphere_R( host_state.worldbrush->nodes, info, ENUM_SPHERE_TEST_ALL );
}


bool CEngineBSPTree::EnumerateLeavesAlongRay( Ray_t const& ray, ISpatialLeafEnumerator* pEnum, int context )
{
	if (!ray.m_IsSwept)
	{
		Vector mins, maxs;
		VectorAdd( ray.m_Start, ray.m_Extents, maxs );
		VectorSubtract( ray.m_Start, ray.m_Extents, mins );

		return EnumerateLeavesInBox( mins, maxs, pEnum, context );
	}

	Vector end;
	VectorAdd( ray.m_Start, ray.m_Delta, end );

	if ( ray.m_IsRay )
	{
		return EnumerateLeavesAlongRay_R( host_state.worldbrush->nodes, ray, 0.0f, 1.0f, pEnum, context );
	}
	else
	{
		return EnumerateLeavesAlongExtrudedRay_R( host_state.worldbrush->nodes, ray, 0.0f, 1.0f, pEnum, context );
	}
}