1HEADmaster

1 files changed, 3774 insertions, 0 deletions

diff --git a/engine/shadowmgr.cpp b/engine/shadowmgr.cpp
new file mode 100644
index 0000000..d60f953
--- /dev/null
+++ b/engine/shadowmgr.cpp
@@ -0,0 +1,3774 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+
+#include "render_pch.h"
+#include "shadowmgr.h"
+#include "utllinkedlist.h"
+#include "utlvector.h"
+#include "interface.h"
+#include "mathlib/vmatrix.h"
+#include "bsptreedata.h"
+#include "materialsystem/itexture.h"
+#include "filesystem.h"
+#include "utlbidirectionalset.h"
+#include "l_studio.h"
+#include "istudiorender.h"
+#include "engine/ivmodelrender.h"
+#include "collisionutils.h"
+#include "debugoverlay.h"
+#include "tier0/vprof.h"
+#include "disp.h"
+#include "gl_rmain.h"
+#include "MaterialBuckets.h"
+#include "r_decal.h"
+#include "cmodel_engine.h"
+#include "iclientrenderable.h"
+#include "cdll_engine_int.h"
+#include "sys_dll.h"
+#include "render.h"
+
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Shadow-related functionality exported by the engine
+//
+// We have two shadow-related caches in this system
+//	1) A surface cache. We keep track of which surfaces the shadows can 
+//		potentially hit. The computation of the surface cache should be
+//		as fast as possible
+//	2) A surface vertex cache. Once we know what surfaces the shadow
+//		hits, we caompute the actual polygons using a clip. This is only
+//		useful for shadows that we know don't change too frequently, so
+//		we pass in a flag when making the shadow to indicate whether the
+//		vertex cache should be used or not. The assumption is that the client
+//		of this system should know whether the shadows are always changing or not
+//
+//	The first cache is generated when the shadow is initially projected, and
+//  the second cache is generated when the surfaces are actually being rendered.
+//
+// For rendering, I assign a sort order ID to all materials used by shadow
+// decals. The sort order serves the identical purpose to the material's EnumID
+// but I remap those IDs so I can keep a small list of decals to render with
+// that enum ID (the other option would be to allocate an array with a number
+// of elements == to the number of material enumeration IDs, which is pretty large).
+//-----------------------------------------------------------------------------
+
+
+//-----------------------------------------------------------------------------
+// forward decarations
+//-----------------------------------------------------------------------------
+extern int r_surfacevisframe;
+extern IStudioRender *g_pStudioRender;
+
+
+#define BACKFACE_EPSILON	0.01f
+
+
+// Max number of vertices per shadow decal
+enum
+{
+	SHADOW_VERTEX_SMALL_CACHE_COUNT = 8,
+	SHADOW_VERTEX_LARGE_CACHE_COUNT = 32,
+	SHADOW_VERTEX_TEMP_COUNT = 48,
+	MAX_CLIP_PLANE_COUNT = 4,
+	SURFACE_BOUNDS_CACHE_COUNT = 1024,
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] Cache size for the shadow decals. This used to be on the stack.
+	//=============================================================================
+	SHADOW_DECAL_CACHE_COUNT = 16*1024,
+	MAX_SHADOW_DECAL_CACHE_COUNT = 64*1024,
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+};
+
+//-----------------------------------------------------------------------------
+// Used to clip the shadow decals
+//-----------------------------------------------------------------------------
+struct ShadowClipState_t
+{
+	int m_CurrVert;
+	int	m_TempCount;
+	int	m_ClipCount;
+	ShadowVertex_t	m_pTempVertices[SHADOW_VERTEX_TEMP_COUNT];
+	ShadowVertex_t*	RESTRICT m_ppClipVertices[2][SHADOW_VERTEX_TEMP_COUNT];
+};
+
+
+//-----------------------------------------------------------------------------
+// ConVars (must be defined before CShadowMgr is instanced!)
+//-----------------------------------------------------------------------------
+ConVar r_shadows("r_shadows", "1");
+ConVar r_shadows_gamecontrol("r_shadows_gamecontrol", "-1", FCVAR_CHEAT );	// Shadow override controlled by game entities (shadow_controller)
+static ConVar r_shadowwireframe("r_shadowwireframe", "0", FCVAR_CHEAT );
+static ConVar r_shadowids("r_shadowids", "0", FCVAR_CHEAT );
+static ConVar r_flashlightdrawsweptbbox( "r_flashlightdrawsweptbbox", "0" );
+static ConVar r_flashlightdrawfrustumbbox( "r_flashlightdrawfrustumbbox", "0" );
+static ConVar r_flashlightnodraw( "r_flashlightnodraw", "0" );
+
+static ConVar r_flashlightupdatedepth( "r_flashlightupdatedepth", "1" );
+static ConVar r_flashlightdrawdepth( "r_flashlightdrawdepth", "0" );
+static ConVar r_flashlightrenderworld(  "r_flashlightrenderworld", "1" );
+static ConVar r_flashlightrendermodels(  "r_flashlightrendermodels", "1" );
+static ConVar r_flashlightrender( "r_flashlightrender", "1" );
+static ConVar r_flashlightculldepth( "r_flashlightculldepth", "1" );
+ConVar r_flashlight_version2( "r_flashlight_version2", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+
+
+//-----------------------------------------------------------------------------
+// Implementation of IShadowMgr
+//-----------------------------------------------------------------------------
+class CShadowMgr : public IShadowMgrInternal, ISpatialLeafEnumerator
+{
+public:
+	// constructor
+	CShadowMgr();
+
+	// Methods inherited from IShadowMgr
+	virtual ShadowHandle_t CreateShadow( IMaterial* pMaterial, IMaterial* pModelMaterial, void* pBindProxy, int creationFlags );
+	virtual ShadowHandle_t CreateShadowEx( IMaterial* pMaterial, IMaterial* pModelMaterial, void* pBindProxy, int creationFlags );
+	virtual void DestroyShadow( ShadowHandle_t handle );
+	virtual void SetShadowMaterial( ShadowHandle_t handle, IMaterial* pMaterial, IMaterial* pModelMaterial, void* pBindProxy );
+	virtual void EnableShadow( ShadowHandle_t handle, bool bEnable );
+	virtual void ProjectFlashlight( ShadowHandle_t handle, const VMatrix& worldToShadow, int nLeafCount, const int *pLeafList );
+	virtual void ProjectShadow( ShadowHandle_t handle, const Vector &origin,
+		const Vector& projectionDir, const VMatrix& worldToShadow, const Vector2D& size,
+		int nLeafCount, const int *pLeafList,
+		float maxHeight, float falloffOffset, float falloffAmount, const Vector &vecCasterOrigin );
+	virtual const Frustum_t &GetFlashlightFrustum( ShadowHandle_t handle );
+	virtual const FlashlightState_t &GetFlashlightState( ShadowHandle_t handle );
+	virtual int ProjectAndClipVertices( ShadowHandle_t handle, int count, 
+		Vector** ppPosition, ShadowVertex_t*** ppOutVertex );
+	virtual void AddShadowToBrushModel( ShadowHandle_t handle, model_t* pModel, 	
+										const Vector& origin, const QAngle& angles );
+	virtual void RemoveAllShadowsFromBrushModel( model_t* pModel );
+	virtual void AddShadowToModel( ShadowHandle_t shadow, ModelInstanceHandle_t handle );
+	virtual void RemoveAllShadowsFromModel( ModelInstanceHandle_t handle );
+ 	virtual const ShadowInfo_t& GetInfo( ShadowHandle_t handle );
+	virtual void SetFlashlightRenderState( ShadowHandle_t handle );
+
+	// Methods inherited from IShadowMgrInternal
+	virtual void LevelInit( int nSurfCount );
+	virtual void LevelShutdown();
+	virtual void AddShadowsOnSurfaceToRenderList( ShadowDecalHandle_t decalHandle );
+	virtual void ClearShadowRenderList();
+	virtual void ComputeRenderInfo( ShadowDecalRenderInfo_t* pInfo, ShadowHandle_t handle ) const;
+	virtual void SetModelShadowState( ModelInstanceHandle_t instance );
+	virtual unsigned short InvalidShadowIndex( );
+
+	// Methods of ISpatialLeafEnumerator
+	virtual bool EnumerateLeaf( int leaf, int context );
+
+	// Sets the texture coordinate range for a shadow...
+	virtual void SetShadowTexCoord( ShadowHandle_t handle, float x, float y, float w, float h );
+
+	// Set extra clip planes related to shadows...
+	// These are used to prevent pokethru and back-casting
+	virtual void ClearExtraClipPlanes( ShadowHandle_t shadow );
+	virtual void AddExtraClipPlane( ShadowHandle_t shadow, const Vector& normal, float dist );
+
+	// Gets the first model associated with a shadow
+	unsigned short& FirstModelInShadow( ShadowHandle_t h ) { return m_Shadows[h].m_FirstModel; }
+	
+	// Set the darkness falloff bias
+	virtual void SetFalloffBias( ShadowHandle_t shadow, unsigned char ucBias );
+
+	// Set the number of world material buckets.  This should happen exactly once per level load.
+	virtual void SetNumWorldMaterialBuckets( int numMaterialSortBins );
+
+	// Update the state for a flashlight.
+	virtual void UpdateFlashlightState( ShadowHandle_t shadowHandle, const FlashlightState_t &lightState );
+
+	virtual void DrawFlashlightDecals( int sortGroup, bool bDoMasking );
+	virtual void DrawFlashlightDecalsOnSingleSurface( SurfaceHandle_t surfID, bool bDoMasking );
+
+	virtual void DrawFlashlightOverlays( int sortGroup, bool bDoMasking );
+
+	virtual void DrawFlashlightDepthTexture( );
+	virtual void SetFlashlightDepthTexture( ShadowHandle_t shadowHandle, ITexture *pFlashlightDepthTexture, unsigned char ucShadowStencilBit );
+
+	virtual void AddFlashlightRenderable( ShadowHandle_t shadow, IClientRenderable *pRenderable );
+	virtual void DrawFlashlightDecalsOnDisplacements( int sortGroup, CDispInfo **visibleDisps, int nVisibleDisps, bool bDoMasking );
+	virtual bool ModelHasShadows( ModelInstanceHandle_t instance );
+
+private:
+	enum
+	{
+		SHADOW_DISABLED = (SHADOW_LAST_FLAG << 1),
+	};
+
+	typedef CUtlFixedLinkedList< ShadowDecalHandle_t >::IndexType_t ShadowSurfaceIndex_t;
+
+	struct SurfaceBounds_t
+	{
+		fltx4 m_vecMins;
+		fltx4 m_vecMaxs;
+		Vector m_vecCenter;
+		float m_flRadius;
+		int m_nSurfaceIndex;
+	};
+
+	struct ShadowVertexSmallList_t
+	{
+		ShadowVertex_t	m_Verts[SHADOW_VERTEX_SMALL_CACHE_COUNT];
+	};
+
+	struct ShadowVertexLargeList_t
+	{
+		ShadowVertex_t	m_Verts[SHADOW_VERTEX_LARGE_CACHE_COUNT];
+	};
+
+	// A cache entries' worth of vertices....
+	struct ShadowVertexCache_t
+	{
+		unsigned short	m_Count;
+		ShadowHandle_t	m_Shadow;
+		unsigned short	m_CachedVerts;
+		ShadowVertex_t*	m_pVerts;
+	};
+
+	typedef unsigned short FlashlightHandle_t;
+
+	// Shadow state
+	struct Shadow_t : public ShadowInfo_t
+	{
+		Vector			m_ProjectionDir;
+		IMaterial*		m_pMaterial;		// material for rendering surfaces
+		IMaterial*		m_pModelMaterial;	// material for rendering models
+		void*			m_pBindProxy;
+		unsigned short	m_Flags;
+		unsigned short	m_SortOrder;
+		float			m_flSphereRadius;	// Radius of sphere surrounding the shadow
+		Ray_t			m_Ray;				// NOTE: Ray needs to be on 16-byte boundaries.
+		Vector			m_vecSphereCenter;	// Sphere surrounding the shadow
+
+		FlashlightHandle_t m_FlashlightHandle;
+		ITexture		  *m_pFlashlightDepthTexture;
+
+		// Extra clip planes
+		unsigned short	m_ClipPlaneCount;
+		Vector			m_ClipPlane[MAX_CLIP_PLANE_COUNT];
+		float			m_ClipDist[MAX_CLIP_PLANE_COUNT];
+		
+		// First shadow decal the shadow has
+		ShadowSurfaceIndex_t m_FirstDecal;
+
+		// First model the shadow is projected onto
+		unsigned short	m_FirstModel;
+		
+		// Stencil bit used to mask this shadow
+		unsigned char	m_ucShadowStencilBit;
+	};
+
+	// Each surface has one of these, they reference the main shadow
+	// projector and cached off shadow decals.
+	struct ShadowDecal_t
+	{
+		SurfaceHandle_t		m_SurfID;
+		ShadowSurfaceIndex_t m_ShadowListIndex;
+		ShadowHandle_t		m_Shadow;
+		DispShadowHandle_t	m_DispShadow;
+		unsigned short		m_ShadowVerts;
+
+		// This is a handle of the next shadow decal to be rendered
+		ShadowDecalHandle_t	m_NextRender;
+	};
+
+	// This structure is used when building new shadow information
+	struct ShadowBuildInfo_t
+	{
+		ShadowHandle_t	m_Shadow;
+		Vector			m_RayStart;
+		Vector			m_ProjectionDirection;
+		Vector			m_vecSphereCenter;	// Sphere surrounding the shadow
+		float			m_flSphereRadius;	// Radius of sphere surrounding the shadow
+		const byte		*m_pVis;				// Vis from the ray start
+	};
+
+	// This structure contains rendering information
+	struct ShadowRenderInfo_t
+	{
+		int		m_VertexCount;
+		int		m_IndexCount;
+		int		m_nMaxVertices;
+		int		m_nMaxIndices;
+		int		m_Count;
+		int*	m_pCache;
+		int		m_DispCount;
+		const VMatrix* m_pModelToWorld;
+		VMatrix m_WorldToModel;
+		DispShadowHandle_t*	m_pDispCache;
+	};
+
+	// Structures used to assign sort order handles
+	struct SortOrderInfo_t
+	{
+		int	m_MaterialEnum;
+		int	m_RefCount;
+	};
+
+	typedef void (*ShadowDebugFunc_t)( ShadowHandle_t shadowHandle, const Vector &vecCentroid );
+
+	// m_FlashlightWorldMaterialBuckets is where surfaces are stored per flashlight each frame.
+	typedef CUtlVector<FlashlightHandle_t> WorldMaterialBuckets_t;
+
+	struct FlashlightInfo_t
+	{
+		FlashlightState_t m_FlashlightState;
+		unsigned short m_Shadow;
+		Frustum_t m_Frustum;
+		CMaterialsBuckets<SurfaceHandle_t> m_MaterialBuckets;
+		CMaterialsBuckets<SurfaceHandle_t> m_OccluderBuckets;
+
+		CUtlVector< IClientRenderable *> m_Renderables;
+	};
+
+private:
+	// Applies a flashlight to all surfaces in the leaf
+	void ApplyFlashlightToLeaf( const Shadow_t &shadow, mleaf_t* pLeaf, ShadowBuildInfo_t* pBuild );
+
+	// Applies a shadow to all surfaces in the leaf
+	void ApplyShadowToLeaf( const Shadow_t &shadow, mleaf_t* RESTRICT pLeaf, ShadowBuildInfo_t* RESTRICT pBuild );
+
+	// These functions deal with creation of render sort ids
+	void SetMaterial( Shadow_t& shadow, IMaterial* pMaterial, IMaterial* pModelMaterial, void* pBindProxy );
+	void CleanupMaterial( Shadow_t& shadow );
+
+	// These functions add/remove shadow decals to surfaces
+	ShadowDecalHandle_t AddShadowDecalToSurface( SurfaceHandle_t surfID, ShadowHandle_t handle );
+	void RemoveShadowDecalFromSurface( SurfaceHandle_t surfID, ShadowDecalHandle_t decalHandle );
+
+	// Adds the surface to the list for this shadow
+	bool AddDecalToShadowList( ShadowHandle_t handle, ShadowDecalHandle_t decalHandle );
+
+	// Removes the shadow to the list of surfaces
+	void RemoveDecalFromShadowList( ShadowHandle_t handle, ShadowDecalHandle_t decalHandle );
+
+	// Actually projects + clips vertices
+	int ProjectAndClipVertices( const Shadow_t& shadow, const VMatrix& worldToShadow, 
+		const VMatrix *pWorldToModel, int count, Vector** ppPosition, ShadowVertex_t*** ppOutVertex );
+
+	// These functions hook/unhook shadows up to surfaces + vice versa
+	void AddSurfaceToShadow( ShadowHandle_t handle, SurfaceHandle_t surfID );
+	void RemoveSurfaceFromShadow( ShadowHandle_t handle, SurfaceHandle_t surfID );
+	void RemoveAllSurfacesFromShadow( ShadowHandle_t handle );
+	void RemoveAllShadowsFromSurface( SurfaceHandle_t surfID );
+
+	// Deals with model shadow management
+	void RemoveAllModelsFromShadow( ShadowHandle_t handle );
+
+	// Applies the shadow to a surface
+	void ApplyShadowToSurface( ShadowBuildInfo_t& build, SurfaceHandle_t surfID );
+
+	// Applies the shadow to a displacement
+	void ApplyShadowToDisplacement( ShadowBuildInfo_t& build, IDispInfo *pDispInfo, bool bIsFlashlight );
+
+	// Renders shadows that all share a material enumeration
+	void RenderShadowList( IMatRenderContext *pRenderContext, ShadowDecalHandle_t decalHandle, const VMatrix* pModelToWorld );
+
+	// Should we cache vertices?
+	bool ShouldCacheVertices( const ShadowDecal_t& decal );
+
+	// Generates a list displacement shadow vertices to render
+	bool GenerateDispShadowRenderInfo( IMatRenderContext *pRenderContext, ShadowDecal_t& decal, ShadowRenderInfo_t& info );
+
+	// Generates a list shadow vertices to render
+	bool GenerateNormalShadowRenderInfo( IMatRenderContext *pRenderContext, ShadowDecal_t& decal, ShadowRenderInfo_t& info );
+
+	// Adds normal shadows to the mesh builder
+	int AddNormalShadowsToMeshBuilder( CMeshBuilder& meshBuilder, ShadowRenderInfo_t& info );
+
+	// Adds displacement shadows to the mesh builder
+	int AddDisplacementShadowsToMeshBuilder( CMeshBuilder& meshBuilder, 
+									ShadowRenderInfo_t& info, int baseIndex );
+
+	// Does the actual work of computing shadow vertices
+	bool ComputeShadowVertices( ShadowDecal_t& decal, const VMatrix* pModelToWorld, const VMatrix* pWorldToModel, ShadowVertexCache_t* pVertexCache );
+
+	// Project vertices into shadow space
+	bool ProjectVerticesIntoShadowSpace( const VMatrix& modelToShadow, 
+		float maxDist, int count, Vector** RESTRICT ppPosition, ShadowClipState_t& clip );
+
+	// Copies vertex info from the clipped vertices
+	void CopyClippedVertices( int count, ShadowVertex_t** ppSrcVert, ShadowVertex_t* pDstVert, const Vector &vToAdd );
+
+	// Allocate, free vertices
+	ShadowVertex_t* AllocateVertices( ShadowVertexCache_t& cache, int count );
+	void FreeVertices( ShadowVertexCache_t& cache );
+
+	// Gets at cache entry...
+	ShadowVertex_t* GetCachedVerts( const ShadowVertexCache_t& cache );
+
+	// Clears out vertices in the temporary cache
+	void ClearTempCache( );
+
+	// Renders debugging information
+	void RenderDebuggingInfo( const ShadowRenderInfo_t &info, ShadowDebugFunc_t func );
+
+	// Methods for dealing with world material buckets for flashlights.
+	void ClearAllFlashlightMaterialBuckets( void );
+	void AddSurfaceToFlashlightMaterialBuckets( ShadowHandle_t handle, SurfaceHandle_t surfID );
+	void AllocFlashlightMaterialBuckets( FlashlightHandle_t flashlightID );
+
+	// Render all projected textures (including shadows and flashlights)
+	void RenderProjectedTextures( const VMatrix* pModelToWorld );
+
+	void RenderFlashlights( bool bDoMasking, const VMatrix* pModelToWorld );
+
+	void SetFlashlightStencilMasks( bool bDoMasking );
+
+	void SetStencilAndScissor( IMatRenderContext *pRenderContext, FlashlightInfo_t &flashlightInfo, bool bUseStencil );
+
+	void EnableStencilAndScissorMasking( IMatRenderContext *pRenderContext, const FlashlightInfo_t &flashlightInfo, bool bDoMasking );
+
+	void DisableStencilAndScissorMasking( IMatRenderContext *pRenderContext );
+
+	void RenderShadows( const VMatrix* pModelToWorld );
+
+	// Generates a list shadow vertices to render
+	void GenerateShadowRenderInfo( IMatRenderContext *pRenderContext, ShadowDecalHandle_t decalHandle, ShadowRenderInfo_t& info );
+
+	// Methods related to the surface bounds cache
+	void ComputeSurfaceBounds( SurfaceBounds_t* pBounds, SurfaceHandle_t nSurfID );
+	const SurfaceBounds_t* GetSurfaceBounds( SurfaceHandle_t nSurfID );
+	bool IsShadowNearSurface( ShadowHandle_t h, SurfaceHandle_t nSurfID, const VMatrix* pModelToWorld, const VMatrix* pWorldToModel );
+
+private:
+	// List of all shadows (one per cast shadow)
+	// Align it so the Ray in the Shadow_t is aligned
+	CUtlLinkedList< Shadow_t, ShadowHandle_t, false, int, CUtlMemoryAligned< UtlLinkedListElem_t< Shadow_t, ShadowHandle_t >, 16 > > m_Shadows;
+	
+	// List of all shadow decals (one per surface hit by a shadow)
+	CUtlLinkedList< ShadowDecal_t, ShadowDecalHandle_t, true, int > m_ShadowDecals;
+
+	// List of all shadow decals associated with a particular shadow
+	CUtlFixedLinkedList< ShadowDecalHandle_t > m_ShadowSurfaces;
+
+	// List of queued decals waiting to be rendered....
+	CUtlVector<ShadowDecalHandle_t>	m_RenderQueue;
+
+	// Used to assign sort order handles
+	CUtlLinkedList<SortOrderInfo_t, unsigned short>	m_SortOrderIds;
+
+	// A cache of shadow vertex data...
+	CUtlLinkedList<ShadowVertexCache_t, unsigned short>	m_VertexCache;
+
+	// This is temporary, not saved off....
+	CUtlVector<ShadowVertexCache_t>	m_TempVertexCache;
+
+	// Vertex data
+	CUtlLinkedList<ShadowVertexSmallList_t, unsigned short>	m_SmallVertexList;
+	CUtlLinkedList<ShadowVertexLargeList_t, unsigned short>	m_LargeVertexList;
+
+	// Model-shadow association
+	CBidirectionalSet< ModelInstanceHandle_t, ShadowHandle_t, unsigned short >	m_ShadowsOnModels;
+
+	// Cache of information for surface bounds
+	typedef CUtlLinkedList< SurfaceBounds_t, unsigned short, false, int, CUtlMemoryFixed< UtlLinkedListElem_t< SurfaceBounds_t, unsigned short >, SURFACE_BOUNDS_CACHE_COUNT, 16 > > SurfaceBoundsCache_t;
+	typedef SurfaceBoundsCache_t::IndexType_t SurfaceBoundsCacheIndex_t;
+	SurfaceBoundsCache_t m_SurfaceBoundsCache;
+	SurfaceBoundsCacheIndex_t *m_pSurfaceBounds;
+
+	// The number of decals we're gonna need to render
+	int	m_DecalsToRender;
+
+	CUtlLinkedList<FlashlightInfo_t> m_FlashlightStates;
+	int m_NumWorldMaterialBuckets;
+	bool m_bInitialized;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] These used to be dynamically allocated on the stack.
+	//=============================================================================
+	CUtlMemory<int> m_ShadowDecalCache;
+	CUtlMemory<DispShadowHandle_t> m_DispShadowDecalCache;
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+};
+
+
+//-----------------------------------------------------------------------------
+// Singleton
+//-----------------------------------------------------------------------------
+static CShadowMgr s_ShadowMgr;
+IShadowMgrInternal* g_pShadowMgr = &s_ShadowMgr;
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CShadowMgr, IShadowMgr, 
+			ENGINE_SHADOWMGR_INTERFACE_VERSION, s_ShadowMgr);
+
+
+//-----------------------------------------------------------------------------
+// Shadows on model instances
+//-----------------------------------------------------------------------------
+unsigned short& FirstShadowOnModel( ModelInstanceHandle_t h )
+{
+	// See l_studio.cpp
+	return FirstShadowOnModelInstance( h );
+}
+
+unsigned short& FirstModelInShadow( ShadowHandle_t h )
+{
+	return s_ShadowMgr.FirstModelInShadow(h); 
+}
+
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor
+//-----------------------------------------------------------------------------
+CShadowMgr::CShadowMgr()
+{
+	m_ShadowSurfaces.SetGrowSize( 4096 );
+	m_ShadowDecals.SetGrowSize( 4096 );
+
+	m_ShadowsOnModels.Init( ::FirstShadowOnModel, ::FirstModelInShadow );
+	m_NumWorldMaterialBuckets = 0;
+	m_pSurfaceBounds = NULL;
+	m_bInitialized = false;
+	ClearShadowRenderList();
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] Initialize the shadow decal caches. These used to be dynamically
+	// allocated on the stack, but we were getting stack overflows.
+	//=============================================================================
+
+	m_ShadowDecalCache.SetGrowSize( 4096 );
+	m_DispShadowDecalCache.SetGrowSize( 4096 );
+
+	m_ShadowDecalCache.Grow( SHADOW_DECAL_CACHE_COUNT );
+	m_DispShadowDecalCache.Grow( SHADOW_DECAL_CACHE_COUNT );
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+
+//-----------------------------------------------------------------------------
+// Level init, shutdown
+//-----------------------------------------------------------------------------
+void CShadowMgr::LevelInit( int nSurfCount )
+{
+	if ( m_bInitialized )
+		return;
+	m_bInitialized = true;
+
+	m_pSurfaceBounds = new SurfaceBoundsCacheIndex_t[nSurfCount];
+
+	// NOTE: Need to memset to 0 if we switch to integer SurfaceBoundsCacheIndex_t here
+	COMPILE_TIME_ASSERT( sizeof(SurfaceBoundsCacheIndex_t) == 2 );
+	memset( m_pSurfaceBounds, 0xFF, nSurfCount * sizeof(SurfaceBoundsCacheIndex_t) );
+}
+
+void CShadowMgr::LevelShutdown()
+{
+	if ( !m_bInitialized )
+		return;
+
+	if ( m_pSurfaceBounds )
+	{
+		delete[] m_pSurfaceBounds;
+		m_pSurfaceBounds = NULL;
+	}
+
+	m_SurfaceBoundsCache.RemoveAll();
+	m_bInitialized = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Create, destroy material sort order ids...
+//-----------------------------------------------------------------------------
+void CShadowMgr::SetMaterial( Shadow_t& shadow, IMaterial* pMaterial, IMaterial* pModelMaterial, void *pBindProxy )
+{
+	shadow.m_pMaterial = pMaterial;
+	shadow.m_pModelMaterial = pModelMaterial;
+	shadow.m_pBindProxy = pBindProxy;
+
+	// We're holding onto this material
+	if ( pMaterial )
+	{
+		pMaterial->IncrementReferenceCount();
+	}
+	if ( pModelMaterial )
+	{
+		pModelMaterial->IncrementReferenceCount();
+	}
+
+	// Search the sort order handles for an enumeration id match
+	int materialEnum = (int)pMaterial;
+	for (unsigned short i = m_SortOrderIds.Head(); i != m_SortOrderIds.InvalidIndex();
+		i = m_SortOrderIds.Next(i) )
+	{
+		// Found a match, lets increment the refcount of this sort order id
+		if (m_SortOrderIds[i].m_MaterialEnum == materialEnum)
+		{
+			++m_SortOrderIds[i].m_RefCount;
+			shadow.m_SortOrder = i;
+			return;
+		}
+	}
+
+	// Didn't find it, lets assign a new sort order ID, with a refcount of 1
+	shadow.m_SortOrder = m_SortOrderIds.AddToTail();
+	m_SortOrderIds[shadow.m_SortOrder].m_MaterialEnum  = materialEnum;
+	m_SortOrderIds[shadow.m_SortOrder].m_RefCount = 1;
+
+	// Make sure the render queue has as many entries as the max sort order id.
+	int count = m_RenderQueue.Count();
+	while( count < m_SortOrderIds.MaxElementIndex() )
+	{
+		MEM_ALLOC_CREDIT();
+		m_RenderQueue.AddToTail( SHADOW_DECAL_HANDLE_INVALID );
+		++count;
+	}
+}
+
+void CShadowMgr::CleanupMaterial( Shadow_t& shadow )
+{
+	// Decrease the sort order reference count
+	if (--m_SortOrderIds[shadow.m_SortOrder].m_RefCount <= 0)
+	{
+		// No one referencing the sort order number?
+		// Then lets clean up the sort order id
+		m_SortOrderIds.Remove(shadow.m_SortOrder);
+	}
+
+	// We're done with this material
+	if ( shadow.m_pMaterial )
+	{
+		shadow.m_pMaterial->DecrementReferenceCount();
+	}
+	if ( shadow.m_pModelMaterial )
+	{
+		shadow.m_pModelMaterial->DecrementReferenceCount();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// For the model shadow list
+//-----------------------------------------------------------------------------
+unsigned short CShadowMgr::InvalidShadowIndex( )
+{
+	return m_ShadowsOnModels.InvalidIndex();
+}
+
+//-----------------------------------------------------------------------------
+// Create, destroy shadows
+//-----------------------------------------------------------------------------
+ShadowHandle_t CShadowMgr::CreateShadow( IMaterial* pMaterial, IMaterial* pModelMaterial, void* pBindProxy, int creationFlags )
+{
+	return CreateShadowEx( pMaterial, pModelMaterial, pBindProxy, creationFlags );
+}
+
+
+ShadowHandle_t CShadowMgr::CreateShadowEx( IMaterial* pMaterial, IMaterial* pModelMaterial, void* pBindProxy, int creationFlags )
+{
+#ifndef SWDS
+	ShadowHandle_t h = m_Shadows.AddToTail();
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] Check for overflow.
+	//=============================================================================
+	if ( h == m_Shadows.InvalidIndex() )
+	{
+		ExecuteNTimes( 10, Warning( "CShadowMgr::CreateShadowEx - overflowed m_Shadows linked list!\n" ) );
+		return h;
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	Shadow_t& shadow = m_Shadows[h];
+	SetMaterial( shadow, pMaterial, pModelMaterial, pBindProxy );
+	shadow.m_Flags = creationFlags;
+	shadow.m_FirstDecal = m_ShadowSurfaces.InvalidIndex();
+	shadow.m_FirstModel = m_ShadowsOnModels.InvalidIndex(); 
+	shadow.m_ProjectionDir.Init( 0, 0, 1 );
+	shadow.m_TexOrigin.Init( 0, 0 );
+	shadow.m_TexSize.Init( 1, 1 );
+	shadow.m_ClipPlaneCount = 0;
+	shadow.m_FalloffBias = 0;
+	shadow.m_pFlashlightDepthTexture = NULL;
+	shadow.m_FlashlightHandle = m_FlashlightStates.InvalidIndex();
+
+	if ( ( creationFlags & SHADOW_FLASHLIGHT ) != 0 )
+	{
+		shadow.m_FlashlightHandle = m_FlashlightStates.AddToTail();
+		m_FlashlightStates[shadow.m_FlashlightHandle].m_Shadow = h;
+		if ( !IsX360() && !r_flashlight_version2.GetInt() )
+		{
+			AllocFlashlightMaterialBuckets( shadow.m_FlashlightHandle );
+		}
+	}
+
+	MatrixSetIdentity( shadow.m_WorldToShadow );
+	return h;
+#endif
+}
+
+void CShadowMgr::DestroyShadow( ShadowHandle_t handle )
+{
+	CleanupMaterial( m_Shadows[handle] );
+	RemoveAllSurfacesFromShadow( handle );
+	RemoveAllModelsFromShadow( handle );
+	if( m_Shadows[handle].m_FlashlightHandle != m_FlashlightStates.InvalidIndex() )
+	{
+		m_FlashlightStates.Remove( m_Shadows[handle].m_FlashlightHandle );
+	}
+
+	m_Shadows.Remove(handle);
+}
+
+
+//-----------------------------------------------------------------------------
+// Resets the shadow material (useful for shadow LOD.. doing blobby at distance) 
+//-----------------------------------------------------------------------------
+void CShadowMgr::SetShadowMaterial( ShadowHandle_t handle, IMaterial* pMaterial, IMaterial* pModelMaterial, void* pBindProxy )
+{
+	Shadow_t& shadow = m_Shadows[handle];
+	if ( (shadow.m_pMaterial != pMaterial) || (shadow.m_pModelMaterial != pModelMaterial) || (shadow.m_pBindProxy != pBindProxy) )
+	{
+		CleanupMaterial( shadow );
+		SetMaterial( shadow, pMaterial, pModelMaterial, pBindProxy );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets the texture coordinate range for a shadow...
+//-----------------------------------------------------------------------------
+void CShadowMgr::SetShadowTexCoord( ShadowHandle_t handle, float x, float y, float w, float h )
+{
+	Shadow_t& shadow = m_Shadows[handle];
+	shadow.m_TexOrigin.Init( x, y );
+	shadow.m_TexSize.Init( w, h );
+}
+
+
+//-----------------------------------------------------------------------------
+// Set extra clip planes related to shadows...
+//-----------------------------------------------------------------------------
+void CShadowMgr::ClearExtraClipPlanes( ShadowHandle_t h )
+{
+	m_Shadows[h].m_ClipPlaneCount = 0;
+}
+
+void CShadowMgr::AddExtraClipPlane( ShadowHandle_t h, const Vector& normal, float dist )
+{
+	Shadow_t& shadow = m_Shadows[h];
+	Assert( shadow.m_ClipPlaneCount < MAX_CLIP_PLANE_COUNT );
+
+	VectorCopy( normal, shadow.m_ClipPlane[shadow.m_ClipPlaneCount] );
+	shadow.m_ClipDist[shadow.m_ClipPlaneCount] = dist;
+	++shadow.m_ClipPlaneCount;
+}
+
+
+//-----------------------------------------------------------------------------
+// Gets at information about a particular shadow
+//-----------------------------------------------------------------------------
+const ShadowInfo_t& CShadowMgr::GetInfo( ShadowHandle_t handle )
+{
+	return m_Shadows[handle];
+}
+
+
+//-----------------------------------------------------------------------------
+// Gets at cache entry...
+//-----------------------------------------------------------------------------
+ShadowVertex_t* CShadowMgr::GetCachedVerts( const ShadowVertexCache_t& cache )
+{
+	if (cache.m_Count == 0)
+		return 0 ;
+
+	if (cache.m_pVerts)
+		return cache.m_pVerts;
+
+	if (cache.m_Count <= SHADOW_VERTEX_SMALL_CACHE_COUNT)
+		return m_SmallVertexList[cache.m_CachedVerts].m_Verts;
+
+	return m_LargeVertexList[cache.m_CachedVerts].m_Verts;
+}
+
+//-----------------------------------------------------------------------------
+// Allocates, cleans up vertex cache vertices
+//-----------------------------------------------------------------------------
+inline ShadowVertex_t* CShadowMgr::AllocateVertices( ShadowVertexCache_t& cache, int count )
+{
+	cache.m_pVerts = 0;
+	if (count <= SHADOW_VERTEX_SMALL_CACHE_COUNT)
+	{
+		cache.m_Count = count;
+		cache.m_CachedVerts = m_SmallVertexList.AddToTail( );
+		return m_SmallVertexList[cache.m_CachedVerts].m_Verts;
+	}
+	else if (count <= SHADOW_VERTEX_LARGE_CACHE_COUNT)
+	{
+		cache.m_Count = count;
+		cache.m_CachedVerts = m_LargeVertexList.AddToTail( );
+		return m_LargeVertexList[cache.m_CachedVerts].m_Verts;
+	}
+
+	cache.m_Count = count;
+	if (count > 0)
+	{
+		cache.m_pVerts = new ShadowVertex_t[count];
+	}
+	cache.m_CachedVerts = m_LargeVertexList.InvalidIndex();
+	return cache.m_pVerts;
+}
+
+inline void CShadowMgr::FreeVertices( ShadowVertexCache_t& cache )
+{
+	if (cache.m_Count == 0)
+		return;
+
+	if (cache.m_pVerts)
+	{
+		delete[] cache.m_pVerts;
+	}
+	else if (cache.m_Count <= SHADOW_VERTEX_SMALL_CACHE_COUNT)
+	{
+		m_SmallVertexList.Remove( cache.m_CachedVerts );
+	}
+	else
+	{
+		m_LargeVertexList.Remove( cache.m_CachedVerts );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Clears out vertices in the temporary cache
+//-----------------------------------------------------------------------------
+void CShadowMgr::ClearTempCache( )
+{
+	// Clear out the vertices
+	for (int i = m_TempVertexCache.Count(); --i >= 0; ) 
+	{
+		FreeVertices( m_TempVertexCache[i] );
+	}
+
+	m_TempVertexCache.RemoveAll();
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds the surface to the list for this shadow
+//-----------------------------------------------------------------------------
+bool CShadowMgr::AddDecalToShadowList( ShadowHandle_t handle, ShadowDecalHandle_t decalHandle )
+{
+	// Add the shadow to the list of surfaces affected by this shadow
+	ShadowSurfaceIndex_t idx = m_ShadowSurfaces.Alloc( true );
+	if ( idx == m_ShadowSurfaces.InvalidIndex() )
+	{
+		ExecuteNTimes( 10, Warning( "CShadowMgr::AddDecalToShadowList - overflowed m_ShadowSurfaces linked list!\n" ) );
+		return false;
+	}
+
+	m_ShadowSurfaces[idx] = decalHandle;
+	if ( m_Shadows[handle].m_FirstDecal != m_ShadowSurfaces.InvalidIndex() )
+	{
+		m_ShadowSurfaces.LinkBefore( m_Shadows[handle].m_FirstDecal, idx );
+	}
+	m_Shadows[handle].m_FirstDecal = idx;
+	m_ShadowDecals[decalHandle].m_ShadowListIndex = idx;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Removes the shadow to the list of surfaces
+//-----------------------------------------------------------------------------
+void CShadowMgr::RemoveDecalFromShadowList( ShadowHandle_t handle, ShadowDecalHandle_t decalHandle )
+{
+	ShadowSurfaceIndex_t idx = m_ShadowDecals[decalHandle].m_ShadowListIndex;
+
+	// Make sure the list of shadow decals for a single shadow is ok
+	if ( m_Shadows[handle].m_FirstDecal == idx )
+	{
+		m_Shadows[handle].m_FirstDecal = m_ShadowSurfaces.Next(idx);
+	}
+
+	// Remove it from the shadow surfaces list
+	m_ShadowSurfaces.Free(idx);
+
+	// Blat out the decal index
+	m_ShadowDecals[decalHandle].m_ShadowListIndex = m_ShadowSurfaces.InvalidIndex();
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes spherical bounds for a surface
+//-----------------------------------------------------------------------------
+void CShadowMgr::ComputeSurfaceBounds( SurfaceBounds_t* pBounds, SurfaceHandle_t nSurfID )
+{
+	pBounds->m_vecCenter.Init();
+	pBounds->m_vecMins = ReplicateX4( FLT_MAX );
+	pBounds->m_vecMaxs = ReplicateX4( -FLT_MAX );
+	int nCount = MSurf_VertCount( nSurfID );
+	for ( int i = 0; i < nCount; ++i )
+	{
+		int nVertIndex = host_state.worldbrush->vertindices[ MSurf_FirstVertIndex( nSurfID ) + i ];
+		const Vector &position = host_state.worldbrush->vertexes[ nVertIndex ].position;
+		pBounds->m_vecCenter += position;
+
+		fltx4 pos4 = LoadUnaligned3SIMD( position.Base() );
+		pBounds->m_vecMins = MinSIMD( pos4, pBounds->m_vecMins );
+		pBounds->m_vecMaxs = MaxSIMD( pos4, pBounds->m_vecMaxs );
+	}
+
+	fltx4 eps = ReplicateX4( 1e-3 );
+	pBounds->m_vecMins = SetWToZeroSIMD( SubSIMD( pBounds->m_vecMins, eps ) );
+	pBounds->m_vecMaxs = SetWToZeroSIMD( AddSIMD( pBounds->m_vecMaxs, eps ) );
+	pBounds->m_vecCenter /= nCount;
+
+	pBounds->m_flRadius = 0.0f;
+	for ( int i = 0; i < nCount; ++i )
+	{
+		int nVertIndex = host_state.worldbrush->vertindices[ MSurf_FirstVertIndex( nSurfID ) + i ];
+		const Vector &position = host_state.worldbrush->vertexes[ nVertIndex ].position;
+		float flDistSq = position.DistToSqr( pBounds->m_vecCenter );
+		if ( flDistSq > pBounds->m_flRadius )
+		{
+			pBounds->m_flRadius = flDistSq;
+		}
+	}
+	pBounds->m_flRadius = sqrt( pBounds->m_flRadius );
+}
+
+
+//-----------------------------------------------------------------------------
+// Get spherical bounds for a surface
+//-----------------------------------------------------------------------------
+const CShadowMgr::SurfaceBounds_t* CShadowMgr::GetSurfaceBounds( SurfaceHandle_t surfID )
+{
+	int nSurfaceIndex = MSurf_Index( surfID );
+
+	// NOTE: We're not bumping the surface index to the front of the LRU
+	// here, but I think if we did the cost doing that would exceed the cost
+	// of anything else in this path.
+	// If this turns out to not be true, then we should make this a true LRU
+	if ( m_pSurfaceBounds[nSurfaceIndex] != m_SurfaceBoundsCache.InvalidIndex() )
+		return &m_SurfaceBoundsCache[ m_pSurfaceBounds[nSurfaceIndex] ];
+
+	SurfaceBoundsCacheIndex_t nIndex;
+	if ( m_SurfaceBoundsCache.Count() >= SURFACE_BOUNDS_CACHE_COUNT )
+	{
+		// Retire existing cache entry if we're out of space,
+		// move it to the head of the LRU cache
+		nIndex = m_SurfaceBoundsCache.Tail( );
+		m_SurfaceBoundsCache.Unlink( nIndex );
+		m_SurfaceBoundsCache.LinkToHead( nIndex );
+		m_pSurfaceBounds[ m_SurfaceBoundsCache[nIndex].m_nSurfaceIndex ] = m_SurfaceBoundsCache.InvalidIndex();
+	}
+	else
+	{
+		// Allocate new cache entry if we have more room
+		nIndex = m_SurfaceBoundsCache.AddToHead( );
+	}
+	m_pSurfaceBounds[ nSurfaceIndex ] = nIndex;
+
+	// Computes the surface bounds
+	SurfaceBounds_t &bounds = m_SurfaceBoundsCache[nIndex];
+	bounds.m_nSurfaceIndex = nSurfaceIndex;
+	ComputeSurfaceBounds( &bounds, surfID );
+	return &bounds;
+}
+
+
+//-----------------------------------------------------------------------------
+// Is the shadow near the surface?
+//-----------------------------------------------------------------------------
+bool CShadowMgr::IsShadowNearSurface( ShadowHandle_t h, SurfaceHandle_t nSurfID, 
+	const VMatrix* pModelToWorld, const VMatrix* pWorldToModel )
+{
+	const Shadow_t &shadow = m_Shadows[h];
+	const SurfaceBounds_t* pBounds = GetSurfaceBounds( nSurfID );
+	Vector vecSurfCenter;
+	if ( !pModelToWorld )
+	{
+		vecSurfCenter = pBounds->m_vecCenter;
+	}
+	else
+	{
+		Vector3DMultiplyPosition( *pModelToWorld, pBounds->m_vecCenter, vecSurfCenter );
+	}
+
+	// Sphere check
+	Vector vecDelta;
+	VectorSubtract( shadow.m_vecSphereCenter, vecSurfCenter, vecDelta );
+	float flDistSqr = vecDelta.LengthSqr();
+	float flMinDistSqr = pBounds->m_flRadius + shadow.m_flSphereRadius;
+	flMinDistSqr *= flMinDistSqr;
+	if ( flDistSqr >= flMinDistSqr )
+		return false;
+
+	if ( !pModelToWorld )
+		return IsBoxIntersectingRay( pBounds->m_vecMins, pBounds->m_vecMaxs, shadow.m_Ray );
+
+	Ray_t transformedRay;
+	Vector3DMultiplyPosition( *pWorldToModel, shadow.m_Ray.m_Start, transformedRay.m_Start );
+	Vector3DMultiply( *pWorldToModel, shadow.m_Ray.m_Delta, transformedRay.m_Delta );
+	transformedRay.m_StartOffset = shadow.m_Ray.m_StartOffset;
+	transformedRay.m_Extents = shadow.m_Ray.m_Extents;
+	transformedRay.m_IsRay = shadow.m_Ray.m_IsRay;
+	transformedRay.m_IsSwept = shadow.m_Ray.m_IsSwept;
+	return IsBoxIntersectingRay( pBounds->m_vecMins, pBounds->m_vecMaxs, transformedRay );
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds the shadow decal reference to the surface
+//-----------------------------------------------------------------------------
+inline ShadowDecalHandle_t CShadowMgr::AddShadowDecalToSurface( SurfaceHandle_t surfID, ShadowHandle_t handle )
+{
+	ShadowDecalHandle_t decalHandle = m_ShadowDecals.Alloc( true );
+	if ( decalHandle == m_ShadowDecals.InvalidIndex() )
+	{
+		ExecuteNTimes( 10, Warning( "CShadowMgr::AddShadowDecalToSurface - overflowed m_ShadowDecals linked list!\n" ) );
+		return decalHandle;
+	}
+
+	ShadowDecal_t& decal = m_ShadowDecals[decalHandle];
+
+	decal.m_SurfID = surfID;
+	m_ShadowDecals.LinkBefore( MSurf_ShadowDecals( surfID ), decalHandle );
+	MSurf_ShadowDecals( surfID ) = decalHandle;
+
+	// Hook the shadow into the displacement system....
+	if ( !SurfaceHasDispInfo( surfID ) )
+	{
+		decal.m_DispShadow = DISP_SHADOW_HANDLE_INVALID;
+	}
+	else
+	{
+		decal.m_DispShadow = MSurf_DispInfo( surfID )->AddShadowDecal( handle );
+	}
+
+	decal.m_Shadow = handle;
+	decal.m_ShadowVerts = m_VertexCache.InvalidIndex();
+	decal.m_NextRender = SHADOW_DECAL_HANDLE_INVALID;
+	decal.m_ShadowListIndex = m_ShadowSurfaces.InvalidIndex();
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] Check the return value of AddDecalToShadowList and make sure 
+	// to delete the newly created shadow decal if there is a failure.
+	//=============================================================================
+	if ( !AddDecalToShadowList( handle, decalHandle ) )
+	{
+		m_ShadowDecals.Free( decalHandle );
+		decalHandle = m_ShadowDecals.InvalidIndex();
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	return decalHandle;
+}
+
+inline void CShadowMgr::RemoveShadowDecalFromSurface( SurfaceHandle_t surfID, ShadowDecalHandle_t decalHandle )
+{
+	// Clean up its shadow verts if it has any
+	ShadowDecal_t& decal = m_ShadowDecals[decalHandle];
+	if (decal.m_ShadowVerts != m_VertexCache.InvalidIndex())
+	{
+		FreeVertices( m_VertexCache[decal.m_ShadowVerts] );
+		m_VertexCache.Remove(decal.m_ShadowVerts);
+		decal.m_ShadowVerts = m_VertexCache.InvalidIndex();
+	}
+
+	// Clean up displacement...
+	if ( decal.m_DispShadow != DISP_SHADOW_HANDLE_INVALID )
+	{
+		MSurf_DispInfo( decal.m_SurfID )->RemoveShadowDecal( decal.m_DispShadow );
+	}
+
+	// Make sure the list of shadow decals on a surface is set up correctly
+	if ( MSurf_ShadowDecals( surfID ) == decalHandle )
+	{
+		MSurf_ShadowDecals( surfID ) = m_ShadowDecals.Next(decalHandle);
+	}
+
+	RemoveDecalFromShadowList( decal.m_Shadow, decalHandle );
+
+	// Kill the shadow decal
+	m_ShadowDecals.Free( decalHandle );
+}
+
+void CShadowMgr::AddSurfaceToFlashlightMaterialBuckets( ShadowHandle_t handle, SurfaceHandle_t surfID )
+{
+	// Make sure that this is a flashlight.
+	Assert( m_Shadows[handle].m_Flags & SHADOW_FLASHLIGHT );
+	
+	// Get the flashlight id for this particular shadow handle and make sure that it's valid.
+	FlashlightHandle_t flashlightID = m_Shadows[handle].m_FlashlightHandle;
+	Assert( flashlightID != m_FlashlightStates.InvalidIndex() );
+
+	m_FlashlightStates[flashlightID].m_MaterialBuckets.AddElement( MSurf_MaterialSortID( surfID ), surfID );
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds the shadow decal reference to the surface
+// This causes a shadow decal to be made
+//-----------------------------------------------------------------------------
+void CShadowMgr::AddSurfaceToShadow( ShadowHandle_t handle, SurfaceHandle_t surfID )
+{
+	// FIXME: We could make this work, but there's a perf cost...
+	// Basically, we'd need to have a separate rendering batch for
+	// each translucent material the shadow is projected onto. The
+	// material alpha would have to be taken into account, so that
+	// no multiplication occurs where the alpha == 0
+	// FLASHLIGHTFIXME: get rid of some of these checks for the ones that will work just fine with the flashlight.	
+	bool bIsFlashlight = ( ( m_Shadows[handle].m_Flags & SHADOW_FLASHLIGHT ) != 0 );
+	if ( !bIsFlashlight && MSurf_Flags(surfID) & (SURFDRAW_TRANS | SURFDRAW_ALPHATEST | SURFDRAW_NOSHADOWS) )
+		return;
+
+#ifdef _XBOX
+	// Don't let the flashlight get on water on XBox
+	if ( bIsFlashlight && ( MSurf_Flags(surfID) & SURFDRAW_WATERSURFACE ) )
+		return;
+#endif
+
+#if 0
+	// Make sure the surface has the shadow on it exactly once...
+	ShadowDecalHandle_t	dh = MSurf_ShadowDecals( surfID );
+	while (dh != m_ShadowDecals.InvalidIndex() )
+	{
+		Assert ( m_ShadowDecals[dh].m_Shadow != handle );
+		dh = m_ShadowDecals.Next(dh);
+	}
+#endif
+
+	// Create a shadow decal for this surface and add it to the surface
+	AddShadowDecalToSurface( surfID, handle );
+}
+
+void CShadowMgr::RemoveSurfaceFromShadow( ShadowHandle_t handle, SurfaceHandle_t surfID )
+{
+	// Find the decal associated with the handle that lies on the surface
+
+	// FIXME: Linear search; bleah.
+	// Luckily the search is probably over only a couple items at most
+	// Linear searching over the shadow surfaces so we can remove the entry
+	// in the shadow surface list if we find a match
+	ASSERT_SURF_VALID( surfID );
+	ShadowSurfaceIndex_t i = m_Shadows[handle].m_FirstDecal;
+	while ( i != m_ShadowSurfaces.InvalidIndex() )
+	{
+		ShadowDecalHandle_t decalHandle = m_ShadowSurfaces[i];
+		if ( m_ShadowDecals[decalHandle].m_SurfID == surfID )
+		{
+			// Found a match! There should be at most one shadow decal
+			// associated with a particular shadow per surface
+			RemoveShadowDecalFromSurface( surfID, decalHandle );
+
+			// FIXME: Could check the shadow doesn't appear again in the list
+			return;			
+		}
+
+		i = m_ShadowSurfaces.Next(i);
+	}
+
+#ifdef _DEBUG
+	// Here, the shadow didn't have the surface in its list
+	// let's make sure the surface doesn't think it's got the shadow in its list
+	ShadowDecalHandle_t	dh = MSurf_ShadowDecals( surfID );
+	while (dh != m_ShadowDecals.InvalidIndex() )
+	{
+		Assert ( m_ShadowDecals[dh].m_Shadow != handle );
+		dh = m_ShadowDecals.Next(dh);
+	}
+
+#endif
+}
+
+void CShadowMgr::RemoveAllSurfacesFromShadow( ShadowHandle_t handle )
+{
+	// Iterate over all the decals associated with a particular shadow
+	// Remove the decals from the surfaces they are associated with
+	ShadowSurfaceIndex_t i = m_Shadows[handle].m_FirstDecal;
+	ShadowSurfaceIndex_t next;
+	while ( i != m_ShadowSurfaces.InvalidIndex() )
+	{
+		ShadowDecalHandle_t decalHandle = m_ShadowSurfaces[i];
+
+		next = m_ShadowSurfaces.Next(i);
+
+		RemoveShadowDecalFromSurface( m_ShadowDecals[decalHandle].m_SurfID, decalHandle );
+
+		i = next;
+	}
+
+	m_Shadows[handle].m_FirstDecal = m_ShadowSurfaces.InvalidIndex();
+}
+
+void CShadowMgr::RemoveAllShadowsFromSurface( SurfaceHandle_t surfID )
+{
+	// Iterate over all the decals associated with a particular shadow
+	// Remove the decals from the surfaces they are associated with
+	ShadowDecalHandle_t	dh = MSurf_ShadowDecals( surfID );
+	while (dh != m_ShadowDecals.InvalidIndex() )
+	{
+		// Remove this shadow from the surface 
+		ShadowDecalHandle_t next = m_ShadowDecals.Next(dh);
+
+		// Remove the surface from the shadow
+		RemoveShadowDecalFromSurface( m_ShadowDecals[dh].m_SurfID, dh );
+
+		dh = next;
+	}
+
+	MSurf_ShadowDecals( surfID ) = m_ShadowDecals.InvalidIndex();
+}
+
+
+//-----------------------------------------------------------------------------
+// Shadow/model association
+//-----------------------------------------------------------------------------
+void CShadowMgr::AddShadowToModel( ShadowHandle_t handle, ModelInstanceHandle_t model )
+{
+	// FIXME: Add culling here based on the model bbox
+	// and the shadow bbox
+	// FIXME:
+	/*
+	// Trivial bbox reject.
+	Vector bbMin, bbMax;
+	pDisp->GetBoundingBox( bbMin, bbMax );
+	if( decalinfo->m_Position.x - decalinfo->m_Size < bbMax.x && decalinfo->m_Position.x + decalinfo->m_Size > bbMin.x && 
+		decalinfo->m_Position.y - decalinfo->m_Size < bbMax.y && decalinfo->m_Position.y + decalinfo->m_Size > bbMin.y && 
+		decalinfo->m_Position.z - decalinfo->m_Size < bbMax.z && decalinfo->m_Position.z + decalinfo->m_Size > bbMin.z )
+	*/
+
+	if ( model == MODEL_INSTANCE_INVALID )
+	{
+		// async data not loaded yet
+		return;
+	}
+
+	if( r_flashlightrender.GetBool()==false )
+		return;
+
+	m_ShadowsOnModels.AddElementToBucket( model, handle );
+
+
+}
+
+void CShadowMgr::RemoveAllShadowsFromModel( ModelInstanceHandle_t model )
+{
+	if( model != MODEL_INSTANCE_INVALID )
+	{
+		m_ShadowsOnModels.RemoveBucket( model );
+
+		FOR_EACH_LL( m_FlashlightStates, i )
+		{
+			FlashlightInfo_t &info = m_FlashlightStates[i];
+
+			for( int j=0;j<info.m_Renderables.Count();j++ )
+			{
+				if( info.m_Renderables[j]->GetModelInstance() == model )
+				{
+					info.m_Renderables.Remove( j );
+					break;
+				}
+			}
+		}
+	}
+}
+
+void CShadowMgr::RemoveAllModelsFromShadow( ShadowHandle_t handle )
+{
+	m_ShadowsOnModels.RemoveElement( handle );
+
+	FOR_EACH_LL( m_FlashlightStates, i )
+	{
+		FlashlightInfo_t &info = m_FlashlightStates[i];
+
+		if( info.m_Shadow==handle )
+		{
+			info.m_Renderables.RemoveAll();
+		}
+	}
+}						   
+
+
+//-----------------------------------------------------------------------------
+// Shadow state...
+//-----------------------------------------------------------------------------
+void CShadowMgr::SetModelShadowState( ModelInstanceHandle_t instance )
+{
+#ifndef SWDS
+	g_pStudioRender->ClearAllShadows();
+	if (instance != MODEL_INSTANCE_INVALID && r_shadows.GetInt() )
+	{
+		bool bWireframe = r_shadowwireframe.GetBool();
+		unsigned short i = m_ShadowsOnModels.FirstElement( instance );
+		while ( i != m_ShadowsOnModels.InvalidIndex() )
+		{
+			Shadow_t& shadow = m_Shadows[m_ShadowsOnModels.Element(i)];
+
+			if( !bWireframe )
+			{
+				if( shadow.m_Flags & SHADOW_FLASHLIGHT )
+				{
+					// NULL means that the models material should be used.
+					// This is what we want in the case of the flashlight
+					// since we need to render the models material again with different lighting.
+					// Need to add something here to specify which flashlight.
+					g_pStudioRender->AddShadow( NULL, NULL, &m_FlashlightStates[shadow.m_FlashlightHandle].m_FlashlightState, &shadow.m_WorldToShadow, shadow.m_pFlashlightDepthTexture );
+				}
+				else if( r_shadows_gamecontrol.GetInt() != 0 )
+				{
+					g_pStudioRender->AddShadow( shadow.m_pModelMaterial, shadow.m_pBindProxy );
+				}
+			}
+			else if( ( shadow.m_Flags & SHADOW_FLASHLIGHT ) || r_shadows_gamecontrol.GetInt() != 0 )
+			{
+				g_pStudioRender->AddShadow( g_pMaterialMRMWireframe, NULL );
+			}
+
+			i = m_ShadowsOnModels.NextElement(i);
+		}
+	}
+#endif
+}
+
+bool CShadowMgr::ModelHasShadows( ModelInstanceHandle_t instance )
+{
+	if ( instance != MODEL_INSTANCE_INVALID )
+	{
+		if ( m_ShadowsOnModels.FirstElement(instance) != m_ShadowsOnModels.InvalidIndex() )
+			return true;
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Applies the shadow to a surface
+//-----------------------------------------------------------------------------
+void CShadowMgr::ApplyShadowToSurface( ShadowBuildInfo_t& build, SurfaceHandle_t surfID )
+{
+	// We've found a potential surface to add to the shadow
+	// At this point, we want to do fast culling to see whether we actually
+	// should apply the shadow or not before actually adding it to any lists
+
+	// FIXME: implement
+	// Put the texture extents into shadow space; see if there's an intersection
+	// If not, we can early out
+
+
+	// To do this, we're gonna want to project the surface into the space of the decal
+	// Therefore, we want to produce a surface->world transformation, and a
+	// world->shadow/light space transformation
+	// Then we transform the surface points into shadow space and apply the projection
+	// in shadow space.
+
+	/*
+	// Get the texture associated with this surface
+	mtexinfo_t* tex = pSurface->texinfo;
+
+	Vector4D &textureU = tex->textureVecsTexelsPerWorldUnits[0];
+	Vector4D &textureV = tex->textureVecsTexelsPerWorldUnits[1];
+
+	// project decal center into the texture space of the surface
+	float s = DotProduct( decalinfo->m_Position, textureU.AsVector3D() ) + 
+		textureU.w - surf->textureMins[0];
+	float t = DotProduct( decalinfo->m_Position, textureV.AsVector3D() ) + 
+		textureV.w - surf->textureMins[1];
+	*/
+
+	// Don't do any more computation at the moment, only do it if
+	// we end up rendering the surface later on
+	AddSurfaceToShadow( build.m_Shadow, surfID );
+}
+
+
+//-----------------------------------------------------------------------------
+// Applies the shadow to a displacement
+//-----------------------------------------------------------------------------
+void CShadowMgr::ApplyShadowToDisplacement( ShadowBuildInfo_t& build, IDispInfo *pDispInfo, bool bIsFlashlight )
+{
+	// Avoid noshadow displacements
+	if ( !bIsFlashlight && ( MSurf_Flags( pDispInfo->GetParent() ) & SURFDRAW_NOSHADOWS ) )
+		return;
+
+	// Trivial bbox reject.
+	Vector bbMin, bbMax;
+	pDispInfo->GetBoundingBox( bbMin, bbMax );
+	if ( !bIsFlashlight )
+	{
+		if ( !IsBoxIntersectingSphere( bbMin, bbMax, build.m_vecSphereCenter, build.m_flSphereRadius ) )
+			return;
+	}
+	else
+	{
+		if( R_CullBox( bbMin, bbMax, GetFlashlightFrustum( build.m_Shadow ) ) )
+			return;
+	}
+
+	SurfaceHandle_t surfID = pDispInfo->GetParent();
+
+	if ( surfID->m_bDynamicShadowsEnabled == false && !bIsFlashlight )
+		return;
+
+	AddSurfaceToShadow( build.m_Shadow, surfID );
+}
+
+
+//-----------------------------------------------------------------------------
+// Allows us to disable particular shadows
+//-----------------------------------------------------------------------------
+void CShadowMgr::EnableShadow( ShadowHandle_t handle, bool bEnable )
+{
+	if (!bEnable)
+	{
+		// We need to remove the shadow from all surfaces it may currently be in
+		RemoveAllSurfacesFromShadow( handle );
+		RemoveAllModelsFromShadow( handle );
+
+		m_Shadows[handle].m_Flags |= SHADOW_DISABLED;
+	}
+	else
+	{
+		// FIXME: Could make this recompute the cache...
+		m_Shadows[handle].m_Flags &= ~SHADOW_DISABLED;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the darkness falloff bias
+// Input  : shadow - 
+//			ucBias - 
+//-----------------------------------------------------------------------------
+void CShadowMgr::SetFalloffBias( ShadowHandle_t shadow, unsigned char ucBias )
+{
+	m_Shadows[shadow].m_FalloffBias = ucBias;
+}
+
+//-----------------------------------------------------------------------------
+// Recursive routine to find surface to apply a decal to.  World coordinates of 
+// the decal are passed in r_recalpos like the rest of the engine.  This should 
+// be called through R_DecalShoot()
+//-----------------------------------------------------------------------------
+void CShadowMgr::ProjectShadow( ShadowHandle_t handle, const Vector &origin,
+	const Vector& projectionDir, const VMatrix& worldToShadow, const Vector2D& size,
+	int nLeafCount, const int *pLeafList,
+	float maxHeight, float falloffOffset, float falloffAmount, const Vector &vecCasterOrigin )
+{
+	VPROF_BUDGET( "CShadowMgr::ProjectShadow", VPROF_BUDGETGROUP_SHADOW_RENDERING );
+
+	// First, we need to remove the shadow from all surfaces it may
+	// currently be in; in other words we're invalidating the shadow surface cache
+	RemoveAllSurfacesFromShadow( handle );
+	RemoveAllModelsFromShadow( handle );
+
+	// Don't bother with this shadow if it's disabled
+	Shadow_t &shadow = m_Shadows[handle];
+	if ( shadow.m_Flags & SHADOW_DISABLED )
+		return;
+
+	// Don't compute the surface cache if shadows are off..
+	if ( !r_shadows.GetInt() )
+		return;
+
+	// Set the falloff coefficient
+	shadow.m_FalloffOffset = falloffOffset;
+	VectorCopy( projectionDir, shadow.m_ProjectionDir );
+
+	// We need to know about surfaces in leaves hit by the ray...
+	// We'd like to stop iterating as soon as the entire swept volume
+	// enters a solid leaf; that may be hard to determine. Instead,
+	// we should stop iterating when the ray center enters a solid leaf?
+	AssertFloatEquals( projectionDir.LengthSqr(), 1.0f, 1e-3 );
+
+	// The maximum ray distance is equal to the distance it takes the
+	// falloff to get to 15%.
+	shadow.m_MaxDist = maxHeight; //sqrt( coeff / 0.10f ) + falloffOffset;
+	shadow.m_FalloffAmount = falloffAmount;
+	MatrixCopy( worldToShadow, shadow.m_WorldToShadow );
+
+	// Compute a rough bounding sphere for the ray
+	float flRadius = sqrt( size.x * size.x + size.y * size.y ) * 0.5f;
+	VectorMA( origin, 0.5f * maxHeight, projectionDir, shadow.m_vecSphereCenter );
+	shadow.m_flSphereRadius = 0.5f * maxHeight + flRadius;
+
+	Vector vecEndPoint;
+	Vector vecMins(	-flRadius, -flRadius, -flRadius );
+	Vector vecMaxs(	 flRadius,  flRadius,  flRadius );
+	VectorMA( origin, maxHeight, projectionDir, vecEndPoint );
+	shadow.m_Ray.Init( origin, vecEndPoint, vecMins, vecMaxs );
+
+	// No more work necessary if it hits no leaves
+	if ( nLeafCount == 0 )
+		return;
+
+	// We're hijacking the surface vis frame to make sure we enumerate
+	// surfaces only once; 
+	++r_surfacevisframe;
+
+	// Clear out the displacement tags also
+	DispInfo_ClearAllTags( host_state.worldbrush->hDispInfos );
+
+	ShadowBuildInfo_t build;
+	build.m_Shadow = handle;
+	build.m_RayStart = origin;
+	build.m_pVis = NULL;
+	build.m_vecSphereCenter = shadow.m_vecSphereCenter;
+	build.m_flSphereRadius = shadow.m_flSphereRadius;
+	VectorCopy( projectionDir, build.m_ProjectionDirection );
+
+	// Enumerate leaves
+	for ( int i  = 0; i < nLeafCount; ++i )
+	{
+		// NOTE: Scope specifier eliminates virtual function call
+		CShadowMgr::EnumerateLeaf( pLeafList[i], (int)&build );
+	}
+}
+
+void DrawFrustum( Frustum_t &frustum )
+{
+	const int maxPoints = 8;
+	int i;
+	for( i = 0; i < FRUSTUM_NUMPLANES; i++ )
+	{
+		Vector points[maxPoints];
+		Vector points2[maxPoints];
+		int numPoints = PolyFromPlane( points, frustum.GetPlane( i )->normal, frustum.GetPlane( i )->dist );
+		Assert( numPoints <= maxPoints );
+		Vector *in, *out;
+		in = points;
+		out = points2;
+		int j;
+		for( j = 0; j < FRUSTUM_NUMPLANES; j++ )
+		{
+			if( i == j )
+			{
+				continue;
+			}
+			numPoints = ClipPolyToPlane( in, numPoints, out, frustum.GetPlane( j )->normal, frustum.GetPlane( j )->dist );
+			Assert( numPoints <= maxPoints );
+			V_swap( in, out );
+		}
+		int c;
+		for( c = 0; c < numPoints; c++ )
+		{
+			CDebugOverlay::AddLineOverlay( in[c], in[(c+1)%numPoints], 0, 255, 0, 255, true, 0.0f );
+		}
+	}
+}
+
+//static void LineDrawHelper( const Vector &startShadowSpace, const Vector &endShadowSpace, 
+//						   const VMatrix &shadowToWorld, unsigned char r, unsigned char g, 
+//						   unsigned char b, bool ignoreZ )
+//{
+//	Vector startWorldSpace, endWorldSpace;
+//	Vector3DMultiplyPositionProjective( shadowToWorld, startShadowSpace, startWorldSpace );
+//	Vector3DMultiplyPositionProjective( shadowToWorld, endShadowSpace, endWorldSpace );
+//
+//	CDebugOverlay::AddLineOverlay( startWorldSpace, 
+//		endWorldSpace, 
+//		r, g, b, ignoreZ
+//		, 0.0 );
+//}
+
+void CShadowMgr::ProjectFlashlight( ShadowHandle_t handle, const VMatrix& worldToShadow, int nLeafCount, const int *pLeafList )
+{
+	VPROF_BUDGET( "CShadowMgr::ProjectFlashlight", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
+
+	Shadow_t& shadow = m_Shadows[handle];
+
+	if ( !IsX360() && !r_flashlight_version2.GetInt() )
+	{
+		// First, we need to remove the shadow from all surfaces it may
+		// currently be in; in other words we're invalidating the shadow surface cache
+		RemoveAllSurfacesFromShadow( handle );
+		RemoveAllModelsFromShadow( handle );
+
+		m_FlashlightStates[ shadow.m_FlashlightHandle ].m_OccluderBuckets.Flush();
+	}
+
+	// Don't bother with this shadow if it's disabled
+	if ( m_Shadows[handle].m_Flags & SHADOW_DISABLED )
+		return;
+
+	// Don't compute the surface cache if shadows are off..
+	if ( !r_shadows.GetInt() )
+		return;
+
+	MatrixCopy( worldToShadow, shadow.m_WorldToShadow );
+
+	// We need this for our various bounding computations
+	VMatrix shadowToWorld;
+	MatrixInverseGeneral( shadow.m_WorldToShadow, shadowToWorld );
+
+	// Set up the frustum for the flashlight so that we can cull each leaf against it.
+	Assert( shadow.m_Flags & SHADOW_FLASHLIGHT );
+	Frustum_t &frustum = m_FlashlightStates[shadow.m_FlashlightHandle].m_Frustum;
+	FrustumPlanesFromMatrix( shadowToWorld, frustum );
+	CalculateSphereFromProjectionMatrixInverse( shadowToWorld, &shadow.m_vecSphereCenter, &shadow.m_flSphereRadius );
+
+	if ( nLeafCount == 0 )
+		return;
+
+	// We're hijacking the surface vis frame to make sure we enumerate
+	// surfaces only once; 
+	++r_surfacevisframe;
+
+	// Clear out the displacement tags also
+	DispInfo_ClearAllTags( host_state.worldbrush->hDispInfos );
+
+	ShadowBuildInfo_t build;
+	build.m_Shadow = handle;
+	build.m_RayStart = m_FlashlightStates[shadow.m_FlashlightHandle].m_FlashlightState.m_vecLightOrigin;
+	build.m_pVis = NULL;
+	build.m_vecSphereCenter = shadow.m_vecSphereCenter;
+	build.m_flSphereRadius = shadow.m_flSphereRadius;
+
+	if( r_flashlightdrawfrustumbbox.GetBool() )
+	{
+		Vector mins, maxs;
+		CalculateAABBFromProjectionMatrixInverse( shadowToWorld, &mins, &maxs );
+		CDebugOverlay::AddBoxOverlay( Vector( 0.0f, 0.0f, 0.0f ), mins, maxs, QAngle( 0, 0, 0 ), 
+			0, 0, 255, 100, 0.0f );
+	}
+	
+	for ( int i = 0; i < nLeafCount; ++i )
+	{
+		// NOTE: Scope specifier eliminates virtual function call
+		CShadowMgr::EnumerateLeaf( pLeafList[i], (int)&build );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Applies the flashlight to all surfaces in the leaf
+//-----------------------------------------------------------------------------
+void CShadowMgr::ApplyFlashlightToLeaf( const Shadow_t &shadow, mleaf_t* pLeaf, ShadowBuildInfo_t* pBuild )
+{
+	// Get the bounds of the leaf so that we can test it against the flashlight frustum.
+	Vector leafMins, leafMaxs;
+	VectorAdd( pLeaf->m_vecCenter, pLeaf->m_vecHalfDiagonal, leafMaxs );
+	VectorSubtract( pLeaf->m_vecCenter, pLeaf->m_vecHalfDiagonal, leafMins );
+
+	// The flashlight frustum didn't intersect the bounding box for this leaf!  Get outta here!
+	if( R_CullBox( leafMins, leafMaxs, GetFlashlightFrustum( pBuild->m_Shadow ) ) )
+		return;
+
+	// Iterate over all surfaces in the leaf, check for backfacing
+	// and apply the shadow to the surface if it's not backfaced.
+	// Note that this really only indicates that the shadow may potentially
+	// sit on the surface; when we render, we'll actually do the clipping
+	// computation and at that point we'll remove surfaces that don't
+	// actually hit the surface
+
+	bool bCullDepth = r_flashlightculldepth.GetBool();
+
+	SurfaceHandle_t *pHandle = &host_state.worldbrush->marksurfaces[pLeaf->firstmarksurface];
+	for ( int i = 0; i < pLeaf->nummarksurfaces; i++ )
+	{
+		SurfaceHandle_t surfID = pHandle[i];
+		
+		// only process each surface once;
+		if( MSurf_VisFrame( surfID ) == r_surfacevisframe )
+			continue;
+		
+		MSurf_VisFrame( surfID ) = r_surfacevisframe;
+		Assert( !MSurf_DispInfo( surfID ) );
+		
+		// perspective projection
+
+		// world-space vertex
+		int vertIndex = host_state.worldbrush->vertindices[MSurf_FirstVertIndex( surfID )];
+		Vector& worldPos = host_state.worldbrush->vertexes[vertIndex].position;
+
+		// Get the lookdir
+		Vector lookdir;
+		VectorSubtract( worldPos, pBuild->m_RayStart, lookdir );
+		VectorNormalize( lookdir );
+
+		const cplane_t &surfPlane = MSurf_Plane( surfID );
+
+		// Now apply the spherical cull
+		float flDist = DotProduct( surfPlane.normal, pBuild->m_vecSphereCenter ) - surfPlane.dist;
+		if ( fabs(flDist) >= pBuild->m_flSphereRadius )
+			continue;
+
+		ApplyShadowToSurface( *pBuild, surfID );
+
+		// Backface cull
+
+		if( bCullDepth )
+		{
+			if ( (MSurf_Flags( surfID ) & SURFDRAW_NOCULL) == 0 )
+			{
+				if ( DotProduct(surfPlane.normal, lookdir) < BACKFACE_EPSILON )
+					continue;
+			}
+			else
+			{
+				// Avoid edge-on shadows regardless.
+				float dot = DotProduct(surfPlane.normal, lookdir);
+				if (fabs(dot) < BACKFACE_EPSILON)
+				continue;
+			}
+		}
+
+		FlashlightInfo_t &flashlightInfo = m_FlashlightStates[ shadow.m_FlashlightHandle ];
+  		flashlightInfo.m_OccluderBuckets.AddElement( MSurf_MaterialSortID( surfID ), surfID );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Applies a shadow to all surfaces in the leaf
+//-----------------------------------------------------------------------------
+void CShadowMgr::ApplyShadowToLeaf( const Shadow_t &shadow, mleaf_t* RESTRICT pLeaf, ShadowBuildInfo_t* RESTRICT pBuild )
+{
+	// Iterate over all surfaces in the leaf, check for backfacing
+	// and apply the shadow to the surface if it's not backfaced.
+	// Note that this really only indicates that the shadow may potentially
+	// sit on the surface; when we render, we'll actually do the clipping
+	// computation and at that point we'll remove surfaces that don't
+	// actually hit the surface
+	SurfaceHandle_t *pHandle = &host_state.worldbrush->marksurfaces[pLeaf->firstmarksurface];
+	for ( int i = 0; i < pLeaf->nummarksurfaces; i++ )
+	{
+		SurfaceHandleRestrict_t surfID = pHandle[i];
+		
+		// only process each surface once;
+		if( MSurf_VisFrame( surfID ) == r_surfacevisframe )
+			continue;
+		
+		MSurf_VisFrame( surfID ) = r_surfacevisframe;
+		Assert( !MSurf_DispInfo( surfID ) );
+
+		// If this surface has specifically had dynamic shadows disabled on it, then get out!
+		if ( !MSurf_AreDynamicShadowsEnabled( surfID ) )
+			continue;
+		
+		// Backface cull
+		const cplane_t * RESTRICT pSurfPlane = &MSurf_Plane( surfID );
+		bool bInFront;
+		if ( (MSurf_Flags( surfID ) & SURFDRAW_NOCULL) == 0 )
+		{
+			if ( DotProduct( pSurfPlane->normal, pBuild->m_ProjectionDirection) > -BACKFACE_EPSILON )
+				continue;
+			
+			bInFront = true;
+		}
+		else
+		{
+			// Avoid edge-on shadows regardless.
+			float dot = DotProduct( pSurfPlane->normal, pBuild->m_ProjectionDirection );
+			if (fabs(dot) < BACKFACE_EPSILON)
+				continue;
+			
+			bInFront = (dot < 0); 
+		}
+		
+		// Here, it's front facing...
+		// Discard stuff on the wrong side of the ray start
+		if (bInFront)
+		{
+			if ( DotProduct( pSurfPlane->normal, pBuild->m_RayStart) < pSurfPlane->dist )
+				continue;
+		}
+		else
+		{
+			if ( DotProduct( pSurfPlane->normal, pBuild->m_RayStart) > pSurfPlane->dist )
+				continue;
+		}
+
+		// Now apply the spherical cull
+		float flDist = DotProduct( pSurfPlane->normal, pBuild->m_vecSphereCenter ) - pSurfPlane->dist;
+		if ( fabs(flDist) >= pBuild->m_flSphereRadius )
+			continue;
+
+		ApplyShadowToSurface( *pBuild, surfID );
+	}
+}
+
+
+#define BIT_SET( a, b ) ((a)[(b)>>3] & (1<<((b)&7)))
+
+//-----------------------------------------------------------------------------
+// Applies a projected texture to all surfaces in the leaf
+//-----------------------------------------------------------------------------
+bool CShadowMgr::EnumerateLeaf( int leaf, int context )
+{
+	VPROF( "CShadowMgr::EnumerateLeaf" );
+	ShadowBuildInfo_t* pBuild = (ShadowBuildInfo_t*)context;
+
+	// Skip this leaf if it's not visible from the shadow caster
+	if ( pBuild->m_pVis )
+	{
+		int cluster = CM_LeafCluster( leaf );
+		if ( !BIT_SET( pBuild->m_pVis, cluster ) )
+			return true;
+	}
+
+	const Shadow_t &shadow = m_Shadows[pBuild->m_Shadow];
+	
+	mleaf_t* pLeaf = &host_state.worldbrush->leafs[leaf];
+
+	bool bIsFlashlight;
+	if( shadow.m_Flags & SHADOW_FLASHLIGHT )
+	{
+		bIsFlashlight = true;
+		ApplyFlashlightToLeaf( shadow, pLeaf, pBuild );
+	}
+	else
+	{
+		bIsFlashlight = false;
+		ApplyShadowToLeaf( shadow, pLeaf, pBuild );
+	}
+
+	// Add the decal to each displacement in the leaf it touches.
+	for ( int i = 0; i < pLeaf->dispCount; i++ )
+	{
+		IDispInfo *pDispInfo = MLeaf_Disaplcement( pLeaf, i );
+		
+		// Make sure the decal hasn't already been added to it.
+		if( pDispInfo->GetTag() )
+			continue;
+
+		pDispInfo->SetTag();
+		
+		ApplyShadowToDisplacement( *pBuild, pDispInfo, bIsFlashlight );
+	}
+	
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a shadow to a brush model
+//-----------------------------------------------------------------------------
+void CShadowMgr::AddShadowToBrushModel( ShadowHandle_t handle, model_t* pModel, 	
+									const Vector& origin, const QAngle& angles )
+{
+	// Don't compute the surface cache if shadows are off..
+	if ( !r_shadows.GetInt() )
+		return;
+
+	const Shadow_t * RESTRICT pShadow = &m_Shadows[handle];
+
+	// Transform the shadow ray direction into model space
+	Vector shadowDirInModelSpace;
+	bool bIsFlashlight = ( pShadow->m_Flags & SHADOW_FLASHLIGHT ) != 0;
+	if( !bIsFlashlight )
+	{
+		// FLASHLIGHTFIXME: should do backface culling for projective light sources.
+		matrix3x4_t worldToModel;
+		AngleIMatrix( angles, worldToModel );
+		VectorRotate( pShadow->m_ProjectionDir, worldToModel, shadowDirInModelSpace );
+	}
+
+	// Just add all non-backfacing brush surfaces to the list of potential
+	// surfaces that we may be casting a shadow onto.
+	SurfaceHandleRestrict_t surfID = SurfaceHandleFromIndex( pModel->brush.firstmodelsurface, pModel->brush.pShared );
+	for (int i=0; i<pModel->brush.nummodelsurfaces; ++i, ++surfID)
+	{
+		// Don't bother with nodraw surfaces
+		int nFlags = MSurf_Flags( surfID );
+		if ( nFlags & SURFDRAW_NODRAW )
+			continue;
+			
+		if( !bIsFlashlight )
+		{
+			// FLASHLIGHTFIXME: should do backface culling for projective light sources.
+			// Don't bother with backfacing surfaces
+			if ( (nFlags & SURFDRAW_NOCULL) == 0 )
+			{
+				const cplane_t * RESTRICT pSurfPlane = &MSurf_Plane( surfID );
+				float dot = DotProduct( shadowDirInModelSpace, pSurfPlane->normal );
+				if ( dot > 0 )
+					continue;
+			}
+		}
+
+		// FIXME: We may want to do some more high-level per-surface culling
+		// If so, it'll be added to ApplyShadowToSurface. Call it instead.
+		AddSurfaceToShadow( handle, surfID );
+	}
+}
+
+				 
+//-----------------------------------------------------------------------------
+// Removes all shadows from a brush model
+//-----------------------------------------------------------------------------
+void CShadowMgr::RemoveAllShadowsFromBrushModel( model_t* pModel )
+{
+	SurfaceHandle_t surfID = SurfaceHandleFromIndex( pModel->brush.firstmodelsurface, pModel->brush.pShared );
+	for (int i=0; i<pModel->brush.nummodelsurfaces; ++i, ++surfID)
+	{
+		RemoveAllShadowsFromSurface( surfID );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds the shadow decals on the surface to a queue of things to render
+//-----------------------------------------------------------------------------
+void CShadowMgr::AddShadowsOnSurfaceToRenderList( ShadowDecalHandle_t decalHandle )
+{
+	// Don't compute the surface cache if shadows are off..
+	if (!r_shadows.GetInt() )
+		return;
+
+	// Add all surface decals into the appropriate render lists
+	while( decalHandle != m_ShadowDecals.InvalidIndex() )
+	{
+		ShadowDecal_t& shadowDecal = m_ShadowDecals[decalHandle];
+		if( m_Shadows[shadowDecal.m_Shadow].m_Flags & SHADOW_FLASHLIGHT )
+		{
+			AddSurfaceToFlashlightMaterialBuckets( shadowDecal.m_Shadow, shadowDecal.m_SurfID );
+
+			// We've got one more decal to render
+			++m_DecalsToRender;
+		}
+		else if( r_shadows_gamecontrol.GetInt() != 0 )
+		{
+			// For shadow rendering, hook the decal into the render list based on the shadow material, not the surface material.
+			int sortOrder = m_Shadows[shadowDecal.m_Shadow].m_SortOrder;
+			m_ShadowDecals[decalHandle].m_NextRender = m_RenderQueue[sortOrder];
+			m_RenderQueue[sortOrder] = decalHandle;
+
+			// We've got one more decal to render
+			++m_DecalsToRender;
+		}
+		decalHandle = m_ShadowDecals.Next(decalHandle);
+	}
+}
+
+void CShadowMgr::ClearShadowRenderList()
+{
+	COMPILE_TIME_ASSERT( sizeof(ShadowDecalHandle_t) == 2 );
+
+	// Clear out the render list
+	if (m_RenderQueue.Count() > 0)
+	{
+		memset( m_RenderQueue.Base(), 0xFF, m_RenderQueue.Count() * sizeof(ShadowDecalHandle_t) );
+	}
+	m_DecalsToRender = 0;
+	// Clear all lists pertaining to flashlight decals that need to be rendered.
+	ClearAllFlashlightMaterialBuckets();
+}
+
+void CShadowMgr::RenderShadows( const VMatrix* pModelToWorld )
+{
+	VPROF_BUDGET( "CShadowMgr::RenderShadows", VPROF_BUDGETGROUP_SHADOW_RENDERING );
+	// Iterate through all sort ids and render for regular shadows, which get their materials from the shadow material.
+	CMatRenderContextPtr pRenderContext( materials );
+	int i;
+	for( i = 0; i < m_RenderQueue.Count(); ++i )
+	{
+		if (m_RenderQueue[i] != m_ShadowDecals.InvalidIndex())
+		{
+			RenderShadowList(pRenderContext, m_RenderQueue[i], pModelToWorld );
+		}
+	}
+}
+
+void CShadowMgr::RenderProjectedTextures( const VMatrix* pModelToWorld )
+{
+	VPROF_BUDGET( "CShadowMgr::RenderProjectedTextures", VPROF_BUDGETGROUP_SHADOW_RENDERING );
+
+	RenderFlashlights( true, pModelToWorld );
+	RenderShadows( pModelToWorld );
+
+	// Clear out the render list, we've rendered it now
+	ClearShadowRenderList();
+}
+
+
+//-----------------------------------------------------------------------------
+// A 2D sutherland-hodgman clipper
+//-----------------------------------------------------------------------------
+class CClipTop
+{
+public:
+	static inline bool Inside( ShadowVertex_t const& vert )				{ return vert.m_ShadowSpaceTexCoord.y < 1;}
+	static inline float Clip( const Vector& one, const Vector& two )	{ return (1 - one.y) / (two.y - one.y);}
+	static inline bool IsPlane()	{return false;}
+	static inline bool IsAbove()	{return false;}
+};
+
+class CClipLeft
+{
+public:
+	static inline bool Inside( ShadowVertex_t const& vert )				{ return vert.m_ShadowSpaceTexCoord.x > 0;}
+	static inline float Clip( const Vector& one, const Vector& two )	{ return one.x / (one.x - two.x);}
+	static inline bool IsPlane()	{return false;}
+	static inline bool IsAbove()	{return false;}
+};
+
+class CClipRight
+{
+public:
+	static inline bool Inside( ShadowVertex_t const& vert )				{return vert.m_ShadowSpaceTexCoord.x < 1;}
+	static inline float Clip( const Vector& one, const Vector& two )	{return (1 - one.x) / (two.x - one.x);}
+	static inline bool IsPlane()	{return false;}
+	static inline bool IsAbove()	{return false;}
+};
+
+class CClipBottom
+{
+public:
+	static inline bool Inside( ShadowVertex_t const& vert )				{return vert.m_ShadowSpaceTexCoord.y > 0;}
+	static inline float Clip( const Vector& one, const Vector& two )	{return one.y / (one.y - two.y);}
+	static inline bool IsPlane()	{return false;}
+	static inline bool IsAbove()	{return false;}
+};
+
+class CClipAbove
+{
+public:
+	static inline bool Inside( ShadowVertex_t const& vert )				{return vert.m_ShadowSpaceTexCoord.z > 0;}
+	static inline float Clip( const Vector& one, const Vector& two )	{return one.z / (one.z - two.z);}
+	static inline bool IsPlane()	{return false;}
+	static inline bool IsAbove()	{return true;}
+};
+
+class CClipPlane
+{
+public:
+	static inline bool Inside( ShadowVertex_t const& vert )						
+	{
+		return DotProduct( vert.m_Position, *m_pNormal ) < m_Dist;
+	}
+
+	static inline float Clip( const Vector& one, const Vector& two )	
+	{
+		Vector dir;
+		VectorSubtract( two, one, dir );
+		return IntersectRayWithPlane( one, dir, *m_pNormal, m_Dist );
+	}
+
+	static inline bool IsAbove()	{return false;}
+	static inline bool IsPlane()	{return true;}
+
+	static void SetPlane( const Vector& normal, float dist )
+	{
+		m_pNormal = &normal;
+		m_Dist = dist;
+	}
+
+
+private:
+	static const Vector *m_pNormal;
+	static float  m_Dist;
+};
+
+const Vector *CClipPlane::m_pNormal;
+float  CClipPlane::m_Dist;
+
+static inline void ClampTexCoord( ShadowVertex_t *pInVertex, ShadowVertex_t *pOutVertex )
+{
+	if ( fabs(pInVertex->m_ShadowSpaceTexCoord[0]) < 1e-3 )
+		pOutVertex->m_ShadowSpaceTexCoord[0] = 0.0f;
+	else if ( fabs(pInVertex->m_ShadowSpaceTexCoord[0] - 1.0f) < 1e-3 )
+		pOutVertex->m_ShadowSpaceTexCoord[0] = 1.0f;
+
+	if ( fabs(pInVertex->m_ShadowSpaceTexCoord[1]) < 1e-3 )
+		pOutVertex->m_ShadowSpaceTexCoord[1] = 0.0f;
+	else if ( fabs(pInVertex->m_ShadowSpaceTexCoord[1] - 1.0f) < 1e-3 )
+		pOutVertex->m_ShadowSpaceTexCoord[1] = 1.0f;
+}
+template <class Clipper>
+static inline void Intersect( ShadowVertex_t* pStart, ShadowVertex_t* pEnd, ShadowVertex_t* pOut, bool startInside, Clipper& clipper )
+{
+	// Clip the edge to the clip plane
+	float t;
+	if (!Clipper::IsPlane())
+	{
+		if (!Clipper::IsAbove())
+		{
+			// This is the path the we always take for perspective light volumes.
+			t = Clipper::Clip( pStart->m_ShadowSpaceTexCoord, pEnd->m_ShadowSpaceTexCoord );
+
+			VectorLerp( pStart->m_ShadowSpaceTexCoord, pEnd->m_ShadowSpaceTexCoord, t, pOut->m_ShadowSpaceTexCoord );
+		}
+		else
+		{
+			t = Clipper::Clip( pStart->m_ShadowSpaceTexCoord, pEnd->m_ShadowSpaceTexCoord );
+			VectorLerp( pStart->m_ShadowSpaceTexCoord, pEnd->m_ShadowSpaceTexCoord, t, pOut->m_ShadowSpaceTexCoord );
+
+			// This is a special thing we do here to avoid hard-edged shadows
+			if (startInside)
+				ClampTexCoord( pEnd, pOut );
+			else
+				ClampTexCoord( pStart, pOut );
+		}
+	}
+	else
+	{
+		t = Clipper::Clip( pStart->m_Position, pEnd->m_Position );
+		VectorLerp( pStart->m_ShadowSpaceTexCoord, pEnd->m_ShadowSpaceTexCoord, t, pOut->m_ShadowSpaceTexCoord );
+	}
+
+	VectorLerp( pStart->m_Position, pEnd->m_Position, t, pOut->m_Position );
+}
+
+template <class Clipper>
+static void ShadowClip( ShadowClipState_t& clip, Clipper& clipper )
+{
+	if ( clip.m_ClipCount == 0 )
+		return;
+
+	// Ye Olde Sutherland-Hodgman clipping algorithm
+	int numOutVerts = 0;
+	ShadowVertex_t** pSrcVert = clip.m_ppClipVertices[clip.m_CurrVert];
+	ShadowVertex_t** pDestVert = clip.m_ppClipVertices[!clip.m_CurrVert];
+
+	int numVerts = clip.m_ClipCount;
+	ShadowVertex_t* pStart = pSrcVert[numVerts-1];
+	bool startInside = Clipper::Inside( *pStart );
+	for (int i = 0; i < numVerts; ++i)
+	{
+		ShadowVertex_t* pEnd = pSrcVert[i];
+		bool endInside = Clipper::Inside( *pEnd );
+		if (endInside)
+		{
+			if (!startInside)
+			{
+				// Started outside, ended inside, need to clip the edge
+				if ( clip.m_TempCount >= SHADOW_VERTEX_TEMP_COUNT )
+					return;
+				
+				// Allocate a new clipped vertex 
+				pDestVert[numOutVerts] = &clip.m_pTempVertices[clip.m_TempCount++];
+
+				// Clip the edge to the clip plane
+				Intersect( pStart, pEnd, pDestVert[numOutVerts], startInside, clipper ); 
+				++numOutVerts;
+			}
+			pDestVert[numOutVerts++] = pEnd;
+		}
+		else
+		{
+			if (startInside)
+			{
+				// Started inside, ended outside, need to clip the edge
+				if ( clip.m_TempCount >= SHADOW_VERTEX_TEMP_COUNT )
+					return;
+
+				// Allocate a new clipped vertex 
+				pDestVert[numOutVerts] = &clip.m_pTempVertices[clip.m_TempCount++];
+
+				// Clip the edge to the clip plane
+				Intersect( pStart, pEnd, pDestVert[numOutVerts], startInside, clipper ); 
+				++numOutVerts;
+			}
+		}
+		pStart = pEnd;
+		startInside = endInside;
+	}
+
+	// Switch source lists
+	clip.m_CurrVert = 1 - clip.m_CurrVert;
+	clip.m_ClipCount = numOutVerts;
+	Assert( clip.m_ClipCount <= SHADOW_VERTEX_TEMP_COUNT ); 
+}
+
+
+//-----------------------------------------------------------------------------
+// Project vertices into shadow space
+//-----------------------------------------------------------------------------
+bool CShadowMgr::ProjectVerticesIntoShadowSpace( const VMatrix& modelToShadow, 
+	float maxDist, int count, Vector** RESTRICT ppPosition, ShadowClipState_t& clip )
+{
+	bool insideVolume = false;
+
+	// Create vertices to clip to...
+	for (int i = 0; i < count; ++i )
+	{
+		Assert( ppPosition[i] );
+
+		VectorCopy( *ppPosition[i], clip.m_pTempVertices[i].m_Position );
+
+		// Project the points into shadow texture space
+		Vector3DMultiplyPosition( modelToShadow, *ppPosition[i], clip.m_pTempVertices[i].m_ShadowSpaceTexCoord );
+
+		// Set up clipping coords...
+		clip.m_ppClipVertices[0][i] = &clip.m_pTempVertices[i];
+
+		if (clip.m_pTempVertices[i].m_ShadowSpaceTexCoord[2] < maxDist )
+		{
+			insideVolume = true;
+		}
+	}
+
+	clip.m_TempCount = clip.m_ClipCount = count;
+	clip.m_CurrVert = 0;
+
+	return insideVolume;
+}
+
+
+//-----------------------------------------------------------------------------
+// Projects + clips shadows
+//-----------------------------------------------------------------------------
+int CShadowMgr::ProjectAndClipVertices( const Shadow_t& shadow, const VMatrix& worldToShadow,
+	const VMatrix *pWorldToModel, int count, Vector** ppPosition, ShadowVertex_t*** ppOutVertex )
+{
+	VPROF( "ProjectAndClipVertices" );
+	static ShadowClipState_t clip;
+	if ( !ProjectVerticesIntoShadowSpace( worldToShadow, shadow.m_MaxDist, count, ppPosition, clip ) )
+		return 0;
+
+	// Clippers...
+	CClipTop top;
+	CClipBottom bottom;
+	CClipLeft left;
+	CClipRight right;
+	CClipAbove above;
+	CClipPlane plane;
+
+	// Sutherland-hodgman clip
+	ShadowClip( clip, top );
+	ShadowClip( clip, bottom );
+	ShadowClip( clip, left );
+	ShadowClip( clip, right );
+	ShadowClip( clip, above );
+
+	// Planes to suppress back-casting
+	for (int i = 0; i < shadow.m_ClipPlaneCount; ++i)
+	{
+		if ( pWorldToModel )
+		{
+			cplane_t worldPlane, modelPlane;
+			worldPlane.normal = shadow.m_ClipPlane[i];
+			worldPlane.dist = shadow.m_ClipDist[i]; 
+			MatrixTransformPlane( *pWorldToModel, worldPlane, modelPlane );
+			plane.SetPlane( modelPlane.normal, modelPlane.dist );
+		}
+		else
+		{
+			plane.SetPlane( shadow.m_ClipPlane[i], shadow.m_ClipDist[i] );
+		}
+		ShadowClip( clip, plane );
+	}
+
+	if (clip.m_ClipCount < 3)
+		return 0;
+
+	// Return a pointer to the array of clipped vertices...
+	Assert(ppOutVertex);
+	*ppOutVertex = clip.m_ppClipVertices[clip.m_CurrVert];
+	return clip.m_ClipCount;
+}
+
+
+//-----------------------------------------------------------------------------
+// Accessor for use by the displacements
+//-----------------------------------------------------------------------------
+int CShadowMgr::ProjectAndClipVertices( ShadowHandle_t handle, int count, 
+	Vector** ppPosition, ShadowVertex_t*** ppOutVertex )
+{
+	return ProjectAndClipVertices( m_Shadows[handle], 
+		m_Shadows[handle].m_WorldToShadow, NULL, count, ppPosition, ppOutVertex );
+}
+
+
+//-----------------------------------------------------------------------------
+// Copies vertex info from the clipped vertices
+//-----------------------------------------------------------------------------
+// This version treats texcoords as Vector
+inline void CShadowMgr::CopyClippedVertices( int count, ShadowVertex_t** ppSrcVert, ShadowVertex_t* pDstVert, const Vector &vToAdd )
+{
+	for (int i = 0; i < count; ++i)
+	{
+		pDstVert[i].m_Position = ppSrcVert[i]->m_Position + vToAdd;
+		pDstVert[i].m_ShadowSpaceTexCoord = ppSrcVert[i]->m_ShadowSpaceTexCoord;
+
+		// Make sure it's been clipped
+		Assert( ppSrcVert[i]->m_ShadowSpaceTexCoord[0] >= -1e-3f );
+		Assert( ppSrcVert[i]->m_ShadowSpaceTexCoord[0] - 1.0f <= 1e-3f );
+		Assert( ppSrcVert[i]->m_ShadowSpaceTexCoord[1] >= -1e-3f );
+		Assert( ppSrcVert[i]->m_ShadowSpaceTexCoord[1] - 1.0f <= 1e-3f );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Does the actual work of computing shadow vertices
+//-----------------------------------------------------------------------------
+bool CShadowMgr::ComputeShadowVertices( ShadowDecal_t& decal, 
+	const VMatrix* pModelToWorld, const VMatrix *pWorldToModel, ShadowVertexCache_t* pVertexCache )
+{
+	VPROF( "CShadowMgr::ComputeShadowVertices" );
+	// Prepare for the clipping
+	Vector **ppVec = (Vector**)stackalloc( MSurf_VertCount( decal.m_SurfID ) * sizeof(Vector*) );
+	for (int i = 0; i < MSurf_VertCount( decal.m_SurfID ); ++i )
+	{
+		int vertIndex = host_state.worldbrush->vertindices[MSurf_FirstVertIndex( decal.m_SurfID )+i];
+		ppVec[i] = &host_state.worldbrush->vertexes[vertIndex].position;
+	}
+
+	// Compute the modelToShadow transform.
+	// In the case of the world, just use worldToShadow...
+	VMatrix* pModelToShadow = &m_Shadows[decal.m_Shadow].m_WorldToShadow;
+
+	VMatrix temp;
+	if ( pModelToWorld )
+	{
+		MatrixMultiply( *pModelToShadow, *pModelToWorld, temp );
+		pModelToShadow = &temp;
+	}
+	else
+	{
+		pWorldToModel = NULL;
+	}
+
+	// Create vertices to clip to...
+	ShadowVertex_t** ppSrcVert;
+	int clipCount = ProjectAndClipVertices( m_Shadows[decal.m_Shadow], *pModelToShadow, pWorldToModel, 
+		MSurf_VertCount( decal.m_SurfID ), ppVec, &ppSrcVert );
+	if (clipCount == 0)
+	{
+		pVertexCache->m_Count = 0;
+		return false;
+	}
+	
+	// Allocate the vertices we're going to use for the decal
+	ShadowVertex_t* pDstVert = AllocateVertices( *pVertexCache, clipCount );
+	Assert( pDstVert );
+
+	// Copy the clipped vertices into the cache
+	const Vector &vNormal = MSurf_Plane( decal.m_SurfID ).normal;
+	CopyClippedVertices( clipCount, ppSrcVert, pDstVert, vNormal * OVERLAY_AVOID_FLICKER_NORMAL_OFFSET );
+
+	// Indicate which shadow this is related to
+	pVertexCache->m_Shadow = decal.m_Shadow;
+
+	return true;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Should we cache vertices?
+//-----------------------------------------------------------------------------
+inline bool CShadowMgr::ShouldCacheVertices( const ShadowDecal_t& decal )
+{
+	return (m_Shadows[decal.m_Shadow].m_Flags & SHADOW_CACHE_VERTS) != 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Generates a list displacement shadow vertices to render
+//-----------------------------------------------------------------------------
+inline bool CShadowMgr::GenerateDispShadowRenderInfo( IMatRenderContext *pRenderContext, ShadowDecal_t& decal, ShadowRenderInfo_t& info )
+{
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] Added an overflow condition for the max disp decal cache.
+	//=============================================================================
+	if ( info.m_DispCount >= MAX_SHADOW_DECAL_CACHE_COUNT )
+	{
+		info.m_DispCount = MAX_SHADOW_DECAL_CACHE_COUNT;
+		return true;
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	int v, i;
+	if ( !MSurf_DispInfo( decal.m_SurfID )->ComputeShadowFragments( decal.m_DispShadow, v, i ) )
+		return false;
+
+	// Catch overflows....
+	if ( ( info.m_VertexCount + v >= info.m_nMaxVertices ) || ( info.m_IndexCount + i >= info.m_nMaxIndices ) )
+		return true;
+
+	info.m_VertexCount += v;
+	info.m_IndexCount += i;
+	info.m_pDispCache[info.m_DispCount++] = decal.m_DispShadow;
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Generates a list shadow vertices to render
+//-----------------------------------------------------------------------------
+inline bool CShadowMgr::GenerateNormalShadowRenderInfo( IMatRenderContext *pRenderContext, ShadowDecal_t& decal, ShadowRenderInfo_t& info )
+{
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] Check for cache overflow.
+	//=============================================================================
+	if ( info.m_Count >= MAX_SHADOW_DECAL_CACHE_COUNT )
+	{
+		info.m_Count = MAX_SHADOW_DECAL_CACHE_COUNT;
+		return true;
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	// Look for a cache hit
+	ShadowVertexCache_t* pVertexCache;
+	if (decal.m_ShadowVerts != m_VertexCache.InvalidIndex())
+	{
+		// Ok, we've already computed the data, lets use it
+		info.m_pCache[info.m_Count] = decal.m_ShadowVerts;
+		pVertexCache = &m_VertexCache[decal.m_ShadowVerts];
+	}
+	else
+	{
+		// Attempt to cull the surface
+		bool bIsNear = IsShadowNearSurface( decal.m_Shadow, decal.m_SurfID, info.m_pModelToWorld, &info.m_WorldToModel );
+		if ( !bIsNear )
+			return false;
+
+		// In this case, we gotta recompute the shadow decal vertices
+		// and maybe even store it into the cache....
+		bool shouldCacheVerts = ShouldCacheVertices( decal );
+		if (shouldCacheVerts)
+		{
+			decal.m_ShadowVerts = m_VertexCache.AddToTail();
+			info.m_pCache[info.m_Count] = decal.m_ShadowVerts;
+			pVertexCache = &m_VertexCache[decal.m_ShadowVerts];
+		}
+		else
+		{
+			int i = m_TempVertexCache.AddToTail();
+			info.m_pCache[info.m_Count] = -i-1;
+			pVertexCache = &m_TempVertexCache[i];
+			Assert( info.m_pCache[info.m_Count] < 0 );
+		}
+
+		// Compute the shadow vertices
+		// If no vertices were created, indicate this surface should be removed from the cache
+		if ( !ComputeShadowVertices( decal, info.m_pModelToWorld, &info.m_WorldToModel, pVertexCache ) )
+			return false;
+	}
+
+	// Catch overflows....
+	int nAdditionalIndices = 3 * (pVertexCache->m_Count - 2);
+	if ( ( info.m_VertexCount + pVertexCache->m_Count >= info.m_nMaxVertices ) || 
+		( info.m_IndexCount + nAdditionalIndices >= info.m_nMaxIndices ) )
+	{
+		return true;
+	}
+
+	// Update vertex, index, and decal counts
+	info.m_VertexCount += pVertexCache->m_Count;
+	info.m_IndexCount += nAdditionalIndices;
+	++info.m_Count;
+	
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Generates a list shadow vertices to render
+//-----------------------------------------------------------------------------
+void CShadowMgr::GenerateShadowRenderInfo( IMatRenderContext *pRenderContext, ShadowDecalHandle_t decalHandle, ShadowRenderInfo_t& info )
+{
+	info.m_VertexCount = 0;
+	info.m_IndexCount = 0;
+	info.m_Count = 0;
+	info.m_DispCount = 0;
+
+	// Keep the lists only full of valid decals; that way we can preserve
+	// the render lists in the case that we discover a shadow isn't needed.
+	ShadowDecalHandle_t next;
+	for ( ; decalHandle != m_ShadowDecals.InvalidIndex(); decalHandle = next )
+	{
+		ShadowDecal_t& decal = m_ShadowDecals[decalHandle];
+		next = m_ShadowDecals[decalHandle].m_NextRender;
+					 
+		// Skip translucent shadows [ don't add their verts + indices to the render lists ]
+		Shadow_t &shadow = m_Shadows[ decal.m_Shadow ];
+		if ( shadow.m_FalloffBias == 255 )
+			continue;
+
+		bool keepShadow;
+		if ( decal.m_DispShadow != DISP_SHADOW_HANDLE_INVALID )
+		{
+			// Handle shadows on displacements...
+			keepShadow = GenerateDispShadowRenderInfo( pRenderContext, decal, info );
+		}
+		else
+		{
+			// Handle shadows on normal surfaces
+			keepShadow = GenerateNormalShadowRenderInfo( pRenderContext, decal, info );
+		}
+		
+		// Retire the surface if the shadow didn't actually hit it
+		if ( !keepShadow && ShouldCacheVertices( decal ) )
+		{
+			// If no triangles were generated
+			// (the decal was completely clipped off)
+			// In this case, remove the decal from the surface cache
+			// so next time it'll be faster (for cached decals)
+			RemoveShadowDecalFromSurface( decal.m_SurfID, decalHandle );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes information for rendering
+//-----------------------------------------------------------------------------
+void CShadowMgr::ComputeRenderInfo( ShadowDecalRenderInfo_t* pInfo, ShadowHandle_t handle ) const
+{
+	const ShadowInfo_t& i = m_Shadows[handle];
+	pInfo->m_vTexOrigin = i.m_TexOrigin;
+	pInfo->m_vTexSize = i.m_TexSize;
+	pInfo->m_flFalloffOffset = i.m_FalloffOffset;
+	pInfo->m_flFalloffAmount = i.m_FalloffAmount;
+	pInfo->m_flFalloffBias = i.m_FalloffBias;
+
+	float flFalloffDist = i.m_MaxDist - i.m_FalloffOffset;
+	pInfo->m_flOOZFalloffDist = ( flFalloffDist > 0.0f ) ? 1.0f / flFalloffDist : 1.0f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds normal shadows to the mesh builder
+//-----------------------------------------------------------------------------
+int CShadowMgr::AddNormalShadowsToMeshBuilder( CMeshBuilder& meshBuilder, ShadowRenderInfo_t& info )
+{
+	// Step through the cache and add all shadows on normal surfaces
+	ShadowDecalRenderInfo_t shadow;
+	int baseIndex = 0;
+	for (int i = 0; i < info.m_Count; ++i)
+	{
+		// Two loops here, basically to minimize the # of if statements we need
+		ShadowVertexCache_t* pVertexCache;
+		if (info.m_pCache[i] < 0)
+		{
+			pVertexCache = &m_TempVertexCache[-info.m_pCache[i]-1];
+		}
+		else
+		{
+			pVertexCache = &m_VertexCache[info.m_pCache[i]];
+		}
+
+		ShadowVertex_t* pVerts = GetCachedVerts( *pVertexCache );
+		g_pShadowMgr->ComputeRenderInfo( &shadow, pVertexCache->m_Shadow );
+
+		int j;
+		unsigned char c;
+		Vector2D texCoord;
+		int vCount = pVertexCache->m_Count - 2;
+		if ( vCount <= 0 )
+			continue;
+
+		for ( j = 0; j < vCount; ++j, ++pVerts )
+		{
+			// Transform + offset the texture coords
+			Vector2DMultiply( pVerts->m_ShadowSpaceTexCoord.AsVector2D(), shadow.m_vTexSize, texCoord );
+			texCoord += shadow.m_vTexOrigin;
+			c = ComputeDarkness( pVerts->m_ShadowSpaceTexCoord.z, shadow );
+
+			meshBuilder.Position3fv( pVerts->m_Position.Base() );
+			meshBuilder.Color4ub( c, c, c, c );
+			meshBuilder.TexCoord2fv( 0, texCoord.Base() );
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.FastIndex( baseIndex );
+			meshBuilder.FastIndex( j + baseIndex + 1 );
+			meshBuilder.FastIndex( j + baseIndex + 2 );
+		}
+
+		Vector2DMultiply( pVerts->m_ShadowSpaceTexCoord.AsVector2D(), shadow.m_vTexSize, texCoord );
+		texCoord += shadow.m_vTexOrigin;
+		c = ComputeDarkness( pVerts->m_ShadowSpaceTexCoord.z, shadow );
+		meshBuilder.Position3fv( pVerts->m_Position.Base() );
+		meshBuilder.Color4ub( c, c, c, c );
+		meshBuilder.TexCoord2fv( 0, texCoord.Base() );
+		meshBuilder.AdvanceVertex();
+		++pVerts;
+
+		Vector2DMultiply( pVerts->m_ShadowSpaceTexCoord.AsVector2D(), shadow.m_vTexSize, texCoord );
+		texCoord += shadow.m_vTexOrigin;
+		c = ComputeDarkness( pVerts->m_ShadowSpaceTexCoord.z, shadow );
+		meshBuilder.Position3fv( pVerts->m_Position.Base() );
+		meshBuilder.Color4ub( c, c, c, c );
+		meshBuilder.TexCoord2fv( 0, texCoord.Base() );
+		meshBuilder.AdvanceVertex();
+
+		// Update the base index
+		baseIndex += vCount + 2; 
+	}
+	
+	return baseIndex;
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds displacement shadows to the mesh builder
+//-----------------------------------------------------------------------------
+int CShadowMgr::AddDisplacementShadowsToMeshBuilder( CMeshBuilder& meshBuilder, 
+								ShadowRenderInfo_t& info, int baseIndex )
+{
+	if ( !r_DrawDisp.GetBool() )
+		return baseIndex;
+
+	// Step through the cache and add all shadows on displacement surfaces
+	for (int i = 0; i < info.m_DispCount; ++i)
+	{
+		baseIndex = DispInfo_AddShadowsToMeshBuilder( meshBuilder, info.m_pDispCache[i], baseIndex );
+	}
+
+	return baseIndex;
+}
+
+
+//-----------------------------------------------------------------------------
+// The following methods will display debugging info in the middle of each shadow decal
+//-----------------------------------------------------------------------------
+static void DrawShadowID( ShadowHandle_t shadowHandle, const Vector &vecCentroid )
+{
+#ifndef SWDS
+	char buf[32];
+	Q_snprintf(buf, sizeof( buf ), "%d", shadowHandle );
+	CDebugOverlay::AddTextOverlay( vecCentroid, 0, buf );
+#endif
+}
+
+void CShadowMgr::RenderDebuggingInfo( const ShadowRenderInfo_t &info, ShadowDebugFunc_t func )
+{
+	// Step through the cache and add all shadows on normal surfaces
+	for (int i = 0; i < info.m_Count; ++i)
+	{
+		ShadowVertexCache_t* pVertexCache;
+		if (info.m_pCache[i] < 0)
+		{
+			pVertexCache = &m_TempVertexCache[-info.m_pCache[i]-1];
+		}
+		else
+		{
+			pVertexCache = &m_VertexCache[info.m_pCache[i]];
+		}
+
+		ShadowVertex_t* pVerts = GetCachedVerts( *pVertexCache );
+
+		Vector vecNormal;
+		float flTotalArea = 0.0f;
+		Vector vecCentroid(0,0,0);
+		Vector vecApex = pVerts[0].m_Position;
+		int vCount = pVertexCache->m_Count;
+
+		for ( int j = 0; j < vCount - 2; ++j )
+		{
+			Vector v1 = pVerts[j + 1].m_Position;
+			Vector v2 = pVerts[j + 2].m_Position;
+			CrossProduct( v2 - v1, v1 - vecApex, vecNormal );
+			float flArea = vecNormal.Length();
+			flTotalArea += flArea;
+			vecCentroid += (vecApex + v1 + v2) * flArea / 3.0f;
+		}
+
+		if (flTotalArea)
+		{
+			vecCentroid /= flTotalArea;
+		}
+
+		func( pVertexCache->m_Shadow, vecCentroid );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Renders shadows that all share a material enumeration
+//-----------------------------------------------------------------------------
+void CShadowMgr::RenderShadowList( IMatRenderContext *pRenderContext, ShadowDecalHandle_t decalHandle, const VMatrix* pModelToWorld )
+{
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] Make sure we don't overflow our caches.
+	//=============================================================================
+
+	if ( m_DecalsToRender > m_ShadowDecalCache.Count() )
+	{
+		// Don't grow past the MAX_SHADOW_DECAL_CACHE_COUNT cap.
+		int diff = min( m_DecalsToRender, (int)MAX_SHADOW_DECAL_CACHE_COUNT ) - m_ShadowDecalCache.Count();
+		if ( diff > 0 )
+		{
+			// Grow the cache.
+			m_ShadowDecalCache.Grow( diff );
+			DevMsg( "[CShadowMgr::RenderShadowList] growing shadow decal cache (decals: %d, cache: %d, diff: %d).\n", m_DecalsToRender, m_ShadowDecalCache.Count(), diff );
+		}
+	}
+
+	if ( m_DecalsToRender > m_DispShadowDecalCache.Count() )
+	{
+		// Don't grow past the MAX_SHADOW_DECAL_CACHE_COUNT cap.
+		int diff = min( m_DecalsToRender, (int)MAX_SHADOW_DECAL_CACHE_COUNT ) - m_DispShadowDecalCache.Count();
+		if ( diff > 0 )
+		{
+			// Grow the cache.
+			m_DispShadowDecalCache.Grow( diff );
+			DevMsg( "[CShadowMgr::RenderShadowList] growing disp shadow decal cache (decals: %d, cache: %d, diff: %d).\n", m_DecalsToRender, m_DispShadowDecalCache.Count(), diff );
+		}
+	}
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	// Set the render state...
+	Shadow_t& shadow = m_Shadows[m_ShadowDecals[decalHandle].m_Shadow];
+
+	if ( r_shadowwireframe.GetInt() == 0 )
+	{
+		pRenderContext->Bind( shadow.m_pMaterial, shadow.m_pBindProxy );
+	}
+	else
+	{
+		pRenderContext->Bind( g_materialWorldWireframe );
+	}
+
+	// Blow away the temporary vertex cache (for normal surfaces)
+	ClearTempCache();
+
+	// Set up rendering info structure
+	ShadowRenderInfo_t info;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] This code used to create the cache dynamically on the stack.
+	//=============================================================================
+	info.m_pCache = m_ShadowDecalCache.Base();
+	info.m_pDispCache = m_DispShadowDecalCache.Base();
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	info.m_pModelToWorld = pModelToWorld;
+	if ( pModelToWorld )
+	{
+		MatrixInverseTR( *pModelToWorld, info.m_WorldToModel );
+	}
+	info.m_nMaxIndices = pRenderContext->GetMaxIndicesToRender();
+	info.m_nMaxVertices = pRenderContext->GetMaxVerticesToRender( shadow.m_pMaterial );
+
+	// Iterate over all decals in the decal list and generate polygon lists
+	// Creating them from scratch if their shadow poly cache is invalid
+	GenerateShadowRenderInfo(pRenderContext, decalHandle, info);
+	Assert( info.m_Count <= m_DecalsToRender );
+	Assert( info.m_DispCount <= m_DecalsToRender );
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] Also check against the max.
+	//=============================================================================
+	Assert( info.m_Count <= m_ShadowDecalCache.Count() &&
+			info.m_Count <= MAX_SHADOW_DECAL_CACHE_COUNT );
+	Assert( info.m_DispCount <= m_DispShadowDecalCache.Count() &&
+			info.m_DispCount <= MAX_SHADOW_DECAL_CACHE_COUNT );
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	// Now that the vertex lists are created, render them
+	IMesh* pMesh = pRenderContext->GetDynamicMesh();
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, info.m_VertexCount, info.m_IndexCount );
+
+	// Add in shadows from both normal surfaces + displacement surfaces
+	int baseIndex = AddNormalShadowsToMeshBuilder( meshBuilder, info );
+	AddDisplacementShadowsToMeshBuilder( meshBuilder, info, baseIndex );
+
+	meshBuilder.End();
+	pMesh->Draw();
+
+	if (r_shadowids.GetInt() != 0)
+	{
+		RenderDebuggingInfo( info, DrawShadowID );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Set the number of world material buckets.  This should get called on level load.
+//-----------------------------------------------------------------------------
+void CShadowMgr::SetNumWorldMaterialBuckets( int numMaterialSortBins )
+{
+	m_NumWorldMaterialBuckets = numMaterialSortBins;
+	FlashlightHandle_t flashlightID;
+	for( flashlightID = m_FlashlightStates.Head(); 
+	     flashlightID != m_FlashlightStates.InvalidIndex(); 
+		 flashlightID = m_FlashlightStates.Next( flashlightID ) )
+	{
+		m_FlashlightStates[flashlightID].m_MaterialBuckets.SetNumMaterialSortIDs( numMaterialSortBins );
+		m_FlashlightStates[flashlightID].m_OccluderBuckets.SetNumMaterialSortIDs( numMaterialSortBins );
+	}	
+	ClearAllFlashlightMaterialBuckets();
+}
+
+//-----------------------------------------------------------------------------
+// Per frame call to clear all of the flashlight world material buckets.
+//-----------------------------------------------------------------------------
+void CShadowMgr::ClearAllFlashlightMaterialBuckets( void )
+{
+	if ( IsX360() || r_flashlight_version2.GetInt() )
+		return;
+
+	FlashlightHandle_t flashlightID;
+	for( flashlightID = m_FlashlightStates.Head(); 
+	     flashlightID != m_FlashlightStates.InvalidIndex(); 
+		 flashlightID = m_FlashlightStates.Next( flashlightID ) )
+	{
+		m_FlashlightStates[flashlightID].m_MaterialBuckets.Flush();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Allocate world material buckets for a particular flashlight.  This should get called on flashlight creation.
+//-----------------------------------------------------------------------------
+void CShadowMgr::AllocFlashlightMaterialBuckets( FlashlightHandle_t flashlightID )
+{
+	Assert( m_FlashlightStates.MaxElementIndex() >= flashlightID );
+	m_FlashlightStates[flashlightID].m_MaterialBuckets.SetNumMaterialSortIDs( m_NumWorldMaterialBuckets );
+	m_FlashlightStates[flashlightID].m_OccluderBuckets.SetNumMaterialSortIDs( m_NumWorldMaterialBuckets );
+}
+
+//-----------------------------------------------------------------------------
+// Update a particular flashlight's state.
+//-----------------------------------------------------------------------------
+void CShadowMgr::UpdateFlashlightState( ShadowHandle_t shadowHandle, const FlashlightState_t &lightState )
+{
+	m_FlashlightStates[m_Shadows[shadowHandle].m_FlashlightHandle].m_FlashlightState = lightState;
+}
+
+void CShadowMgr::SetFlashlightDepthTexture( ShadowHandle_t shadowHandle, ITexture *pFlashlightDepthTexture, unsigned char ucShadowStencilBit )
+{
+	m_Shadows[shadowHandle].m_pFlashlightDepthTexture = pFlashlightDepthTexture;
+	m_Shadows[shadowHandle].m_ucShadowStencilBit = ucShadowStencilBit;
+}
+
+bool ScreenSpaceRectFromPoints( IMatRenderContext *pRenderContext, Vector vClippedPolygons[8][10], int *pNumPoints, int nNumPolygons, int *nLeft, int *nTop, int *nRight, int *nBottom )
+{
+	if( nNumPolygons == 0 )
+		return false;
+
+	VMatrix matView, matProj, matViewProj;
+	pRenderContext->GetMatrix( MATERIAL_VIEW, &matView );
+	pRenderContext->GetMatrix( MATERIAL_PROJECTION, &matProj );
+	MatrixMultiply( matProj, matView, matViewProj );
+
+	float fMinX, fMaxX, fMinY, fMaxY;								// Init bounding rect
+	fMinX = fMinY =  FLT_MAX;
+	fMaxX = fMaxY = -FLT_MAX;
+
+	for ( int i=0; i<nNumPolygons; i++ )
+	{
+		for ( int j=0; j<pNumPoints[i]; j++ )
+		{
+			Vector vScreenSpacePoint;
+			matViewProj.V3Mul( vClippedPolygons[i][j], vScreenSpacePoint );	// Transform from World to screen space
+
+			fMinX = fpmin( fMinX, vScreenSpacePoint.x );				// Update mins/maxes
+			fMaxX = fpmax( fMaxX, vScreenSpacePoint.x );				//
+			fMinY = fpmin( fMinY, -vScreenSpacePoint.y );				// These are in -1 to +1 range
+			fMaxY = fpmax( fMaxY, -vScreenSpacePoint.y );				//
+		}
+	}
+
+	int nWidth, nHeight;
+	g_pMaterialSystem->GetBackBufferDimensions( nWidth, nHeight );	// Get render target dimensions
+
+	*nLeft	 = ((fMinX * 0.5f + 0.5f) * (float) nWidth ) - 1;		// Convert to render target pixel units
+	*nTop    = ((fMinY * 0.5f + 0.5f) * (float) nHeight) - 1; 
+	*nRight  = ((fMaxX * 0.5f + 0.5f) * (float) nWidth ) + 1;
+	*nBottom = ((fMaxY * 0.5f + 0.5f) * (float) nHeight) + 1;  
+
+	*nLeft   = clamp( *nLeft,   0, nWidth  );						// Clamp to render target dimensions
+	*nTop    = clamp( *nTop,    0, nHeight );
+	*nRight  = clamp( *nRight,  0, nWidth  );
+	*nBottom = clamp( *nBottom, 0, nHeight );
+
+	Assert( (*nLeft <= *nRight) && (*nTop <= *nBottom) );
+
+	// Do we have an actual subrect of the whole screen?
+	bool bWithinBounds = ((*nLeft > 0 ) || (*nTop > 0) || (*nRight < nWidth) || (*nBottom < nHeight));	
+
+	// Compute valid area
+	nWidth  = (*nRight - *nLeft);
+	nHeight = (*nBottom - *nTop);
+	int nArea = ( nWidth > 0 ) && ( nHeight > 0 ) ? nWidth * nHeight : 0;
+
+	// Valid rect?
+	return bWithinBounds && (nArea > 0);
+}
+
+// Turn this optimization off by default
+static ConVar r_flashlightclip("r_flashlightclip", "0", FCVAR_CHEAT );
+static ConVar r_flashlightdrawclip("r_flashlightdrawclip", "0", FCVAR_CHEAT );
+static ConVar r_flashlightscissor( "r_flashlightscissor", "1", 0 );
+
+void ExtractFrustumPlanes( Frustum frustumPlanes, float flPlaneEpsilon )
+{
+	const CViewSetup &view = g_EngineRenderer->ViewGetCurrent();
+
+	float flFOVy = CalcFovY( view.fov, view.m_flAspectRatio );
+
+	Frustum_t frustum;
+
+	Vector vForward, vRight, vUp;
+	AngleVectors( view.angles, &vForward, &vRight, &vUp );
+
+	GeneratePerspectiveFrustum( view.origin, vForward, vRight, vUp,
+								view.zNear + flPlaneEpsilon, view.zFar - flPlaneEpsilon,	// Apply epsilon to near and far
+								view.fov, flFOVy, frustum );
+
+	// Copy out to the planes that the engine renderer uses.
+	for( int i=0; i < FRUSTUM_NUMPLANES; i++ )
+	{
+		frustumPlanes[i].m_Normal = frustum.GetPlane(i)->normal;
+		frustumPlanes[i].m_Dist = frustum.GetPlane(i)->dist;
+	}
+}
+
+void ConstructNearAndFarPolygons( Vector *pVecNearPlane, Vector *pVecFarPlane, float flPlaneEpsilon )
+{
+	const CViewSetup &view = g_EngineRenderer->ViewGetCurrent();
+
+	float fovY = CalcFovY( view.fov, view.m_flAspectRatio );
+
+	// Compute near and far plane half-width and half-height
+	float flTanHalfAngleRadians = tan( view.fov * ( 0.5f * M_PI / 180.0f ) );
+	float flHalfNearWidth = flTanHalfAngleRadians * ( view.zNear + flPlaneEpsilon );
+	float flHalfFarWidth  = flTanHalfAngleRadians * ( view.zFar  - flPlaneEpsilon );
+	flTanHalfAngleRadians = tan( fovY * ( 0.5f * M_PI / 180.0f ) );
+	float flHalfNearHeight = flTanHalfAngleRadians * ( view.zNear + flPlaneEpsilon );
+	float flHalfFarHeight  = flTanHalfAngleRadians * ( view.zFar  - flPlaneEpsilon );
+
+	// World-space orientation of viewer
+	Vector vForward, vRight, vUp;
+	AngleVectors( view.angles, &vForward, &vRight, &vUp );
+	vForward.NormalizeInPlace();
+	vRight.NormalizeInPlace();
+	vUp.NormalizeInPlace();
+
+	// Center of near and far planes in world space
+	Vector vCenterNear = view.origin + vForward * ( view.zNear + flPlaneEpsilon );
+	Vector vCenterFar  = view.origin + vForward * ( view.zFar  - flPlaneEpsilon );
+
+	pVecNearPlane[0] = vCenterNear - ( vRight * flHalfNearWidth ) - ( vUp * flHalfNearHeight );
+	pVecNearPlane[1] = vCenterNear - ( vRight * flHalfNearWidth ) + ( vUp * flHalfNearHeight );
+	pVecNearPlane[2] = vCenterNear + ( vRight * flHalfNearWidth ) + ( vUp * flHalfNearHeight );
+	pVecNearPlane[3] = vCenterNear + ( vRight * flHalfNearWidth ) - ( vUp * flHalfNearHeight );
+
+	pVecFarPlane[0]  = vCenterNear - ( vRight * flHalfFarWidth )  - ( vUp * flHalfFarHeight );
+	pVecFarPlane[1]  = vCenterNear + ( vRight * flHalfFarWidth )  - ( vUp * flHalfFarHeight );
+	pVecFarPlane[2]  = vCenterNear + ( vRight * flHalfFarWidth )  + ( vUp * flHalfFarHeight );
+	pVecFarPlane[3]  = vCenterNear - ( vRight * flHalfFarWidth )  + ( vUp * flHalfFarHeight );
+}
+
+void DrawDebugPolygon( int nNumVerts, Vector *pVecPoints, bool bFrontFacing, bool bNearPlane )
+{
+	int r=0, g=0, b=0;
+	if ( bFrontFacing )
+		b = 255;
+	else
+		r = 255; 
+
+	if ( bNearPlane )	// Draw near plane green for visualization
+	{
+		r = b = 0;
+		g = 255;
+	}
+
+	// Draw triangles fanned out from vertex zero
+	for (int i=1; i<(nNumVerts-1); i++)
+	{
+		Vector v0 = pVecPoints[0];
+		Vector v1 = pVecPoints[bFrontFacing ? i : i+1];
+		Vector v2 = pVecPoints[bFrontFacing ? i+1 : i];
+
+		CDebugOverlay::AddTriangleOverlay(v0, v1, v2, r, g, b, 20, true, 0 );
+	}
+
+	// Draw solid lines around the polygon
+	for (int i=0; i<nNumVerts; i++)
+	{
+		Vector v0 = pVecPoints[i];
+		Vector v1 = pVecPoints[ (i+1) % nNumVerts];
+
+		CDebugOverlay::AddLineOverlay( v0, v1, 255, 255, 255, 255, false, 0);
+	}
+}
+
+void DrawPolygonToStencil( IMatRenderContext *pRenderContext, int nNumVerts, Vector *pVecPoints, bool bFrontFacing, bool bNearPlane )
+{
+	IMaterial *pMaterial = materials->FindMaterial( "engine/writestencil", TEXTURE_GROUP_OTHER, true );
+
+	pRenderContext->Bind( pMaterial );
+	IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
+
+	pRenderContext->MatrixMode( MATERIAL_MODEL );
+	pRenderContext->PushMatrix();
+	pRenderContext->LoadIdentity();
+
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nNumVerts-2 );
+
+	// Fan out from vertex zero
+	for (int i=1; i<(nNumVerts-1); i++)
+	{
+		meshBuilder.Position3f( pVecPoints[0].x, pVecPoints[0].y, pVecPoints[0].z );
+		meshBuilder.AdvanceVertex();
+
+		int index = bFrontFacing ? i : i+1;
+		meshBuilder.Position3f( pVecPoints[index].x, pVecPoints[index].y, pVecPoints[index].z );
+		meshBuilder.AdvanceVertex();
+
+		index = bFrontFacing ? i+1 : i;
+		meshBuilder.Position3f( pVecPoints[index].x, pVecPoints[index].y, pVecPoints[index].z );
+		meshBuilder.AdvanceVertex();
+	}
+
+	meshBuilder.End( false, true );
+
+	pRenderContext->MatrixMode( MATERIAL_MODEL );
+	pRenderContext->PopMatrix();
+}
+
+// Determine if two Vectors are sufficiently close (Manhattan-ish distance, not Euclidean)
+bool SufficientlyClose( Vector v1, Vector v2, float flEpsilon )
+{
+	if ( fabs( v1.x - v2.x ) > flEpsilon )			// Bail if x components are sufficiently different
+		return false;
+
+	if ( fabs( v1.y - v2.y ) > flEpsilon )			// Bail if y components are sufficiently different
+		return false;
+
+	if ( fabs( v1.z - v2.z ) > flEpsilon )			// Bail if z components are sufficiently different
+		return false;
+
+	return true;
+}
+
+
+int ClipPlaneToFrustum( Vector *pInPoints, Vector *pOutPoints, Vector *pVecWorldFrustumPoints )
+{
+	Vector vClipPing[10];			// Vector lists to ping-pong between while clipping
+	Vector vClipPong[10];			//
+	bool bPing = true;				// Ping holds the latest polygon
+
+	vClipPing[0] = pInPoints[0];	// Copy into Ping
+	vClipPing[1] = pInPoints[1];
+	vClipPing[2] = pInPoints[2];
+	vClipPing[3] = pInPoints[3];
+
+	int nNumPoints = 4;
+
+	for ( int i=0; i < 6; i++ )
+	{
+		Vector vNormal;
+		float flDist;
+		
+		if ( nNumPoints < 3 )	// If we're already clipped away, bail out entirely
+			break;
+
+		Vector *pClipPolygon = pVecWorldFrustumPoints+(4*i);										// Polygon defining clip plane
+		ComputeTrianglePlane( pClipPolygon[0], pClipPolygon[1], pClipPolygon[2], vNormal, flDist );	// Compute plane normal and dist
+
+		if ( bPing )
+			nNumPoints = ClipPolyToPlane( vClipPing, nNumPoints, vClipPong, vNormal, flDist ); // Clip Ping into Pong
+		else
+			nNumPoints = ClipPolyToPlane( vClipPong, nNumPoints, vClipPing, vNormal, flDist ); // Clip Pong into Ping
+
+		bPing = !bPing;	// Flip buffers
+	}
+
+	if ( nNumPoints < 3)
+		return 0;
+
+	if ( bPing )
+		memcpy( pOutPoints, vClipPing, nNumPoints * sizeof(Vector) );
+	else
+		memcpy( pOutPoints, vClipPong, nNumPoints * sizeof(Vector) );
+
+	return nNumPoints;
+}
+
+
+
+void CShadowMgr::SetStencilAndScissor( IMatRenderContext *pRenderContext, FlashlightInfo_t &flashlightInfo, bool bUseStencil )
+{
+	VMatrix matFlashlightToWorld;
+	MatrixInverseGeneral( m_Shadows[flashlightInfo.m_Shadow].m_WorldToShadow, matFlashlightToWorld );
+
+	// Eight points defining the frustum in Flashlight space
+	Vector vFrustumPoints[24] = { Vector(0.0f, 0.0f, 0.0f), Vector(1.0f, 0.0f, 0.0f), Vector(1.0f, 1.0f, 0.0f), Vector(0.0f, 1.0f, 0.0f),	// Near
+								  Vector(0.0f, 0.0f, 1.0f), Vector(0.0f, 1.0f, 1.0f), Vector(1.0f, 1.0f, 1.0f), Vector(1.0f, 0.0f, 1.0f),	// Far
+								  Vector(1.0f, 0.0f, 0.0f), Vector(1.0f, 0.0f, 1.0f), Vector(1.0f, 1.0f, 1.0f), Vector(1.0f, 1.0f, 0.0f),	// Right
+								  Vector(0.0f, 0.0f, 0.0f), Vector(0.0f, 1.0f, 0.0f), Vector(0.0f, 1.0f, 1.0f), Vector(0.0f, 0.0f, 1.0f),	// Left
+								  Vector(0.0f, 1.0f, 0.0f), Vector(1.0f, 1.0f, 0.0f), Vector(1.0f, 1.0f, 1.0f), Vector(0.0f, 1.0f, 1.0f),	// Bottom
+								  Vector(0.0f, 0.0f, 0.0f), Vector(0.0f, 0.0f, 1.0f), Vector(1.0f, 0.0f, 1.0f), Vector(1.0f, 0.0f, 0.0f)};	// Top
+
+	// Transform points to world space
+	Vector vWorldFrustumPoints[24];
+	for ( int i=0; i < 24; i++ )
+	{
+		matFlashlightToWorld.V3Mul( vFrustumPoints[i], vWorldFrustumPoints[i] );
+	}
+
+	// Express near and far planes of View frustum in world space
+	Frustum frustumPlanes;
+	const float flPlaneEpsilon = 0.4f;
+	ExtractFrustumPlanes( frustumPlanes, flPlaneEpsilon );
+	Vector vNearNormal = frustumPlanes[FRUSTUM_NEARZ].m_Normal;
+	Vector vFarNormal  = frustumPlanes[FRUSTUM_FARZ].m_Normal;
+	float flNearDist   = frustumPlanes[FRUSTUM_NEARZ].m_Dist;
+	float flFarDist    = frustumPlanes[FRUSTUM_FARZ].m_Dist;
+
+	Vector	vTempFace[5];
+	Vector	vClippedFace[6];
+	Vector	vClippedPolygons[8][10];	// Array of up to eight polygons (10 verts is more than enough for each)
+	int nNumVertices[8];				// Number vertices on each of the of clipped polygons
+	int nNumPolygons = 0;				// How many polygons have survived the clip
+
+	// Clip each face individually to near and far planes
+	for ( int i=0; i < 6; i++ )
+	{
+		Vector *inVerts   = vWorldFrustumPoints+(4*i);	// Series of quadrilateral inputs
+		Vector *tempVerts = vTempFace;
+		Vector *outVerts  = vClippedFace;
+
+		int nClipCount = ClipPolyToPlane( inVerts, 4, tempVerts, vNearNormal, flNearDist );			// need to set fOnPlaneEpsilon?
+
+		if ( nClipCount > 2 )	// If the polygon survived the near clip, try the far as well
+		{
+			nClipCount = ClipPolyToPlane( tempVerts, nClipCount, outVerts, vFarNormal, flFarDist );	// need to set fOnPlaneEpsilon?
+
+			if ( nClipCount > 2 )	// If we still have a poly after clipping to both planes, add it to the list
+			{
+				memcpy( vClippedPolygons[nNumPolygons], outVerts, nClipCount * sizeof (Vector) );
+				nNumVertices[nNumPolygons] = nClipCount;
+				nNumPolygons++;
+			}
+		}
+	}
+
+	// Construct polygons for near and far planes
+	Vector	vNearPlane[4], vFarPlane[4];
+	ConstructNearAndFarPolygons( vNearPlane, vFarPlane, flPlaneEpsilon );
+	bool bNearPlane = false;
+
+	// Clip near plane to flashlight frustum and tack on to list
+	int nClipCount = ClipPlaneToFrustum( vNearPlane, vClippedPolygons[nNumPolygons], vWorldFrustumPoints );
+	if ( nClipCount > 2 )		// If the near plane clipped and resulted in a polygon, take note in the polygon list
+	{
+		nNumVertices[nNumPolygons] = nClipCount;
+		nNumPolygons++;
+		bNearPlane = true;
+	}
+
+/*
+TODO: do we even need to do the far plane?
+
+		// Clip near plane to flashlight frustum and tack on to list
+		nClipCount = ClipPlaneToFrustum( vFarPlane, vClippedPolygons[nNumPolygons], vWorldFrustumPoints );
+		if ( nClipCount > 2 )		// If the near plane clipped and resulted in a polygon, take note in the polygon list
+		{
+			nNumVertices[nNumPolygons] = nClipCount;
+			nNumPolygons++;
+		}
+*/
+	// Fuse positions of any verts which are within epsilon
+	for (int i=0; i<nNumPolygons; i++)							// For each polygon
+	{
+		for (int j=0; j<nNumVertices[i]; j++)					// For each vertex
+		{
+			for (int k=i+1; k<nNumPolygons; k++)				// For each later polygon
+			{
+				for (int m=0; m<nNumVertices[k]; m++)			// For each vertex
+				{
+					if ( SufficientlyClose(vClippedPolygons[i][j], vClippedPolygons[k][m], 0.1f) )
+					{
+						vClippedPolygons[k][m] = vClippedPolygons[i][j];
+					}
+				}
+			}
+		}
+	}
+
+	// Calculate scissoring rect
+	flashlightInfo.m_FlashlightState.m_bScissor = false;
+	if ( r_flashlightscissor.GetBool() && (nNumPolygons > 0) )
+	{
+		int nLeft, nTop, nRight, nBottom;
+		flashlightInfo.m_FlashlightState.m_bScissor = ScreenSpaceRectFromPoints( pRenderContext, vClippedPolygons, nNumVertices, nNumPolygons, &nLeft, &nTop, &nRight, &nBottom );
+		if ( flashlightInfo.m_FlashlightState.m_bScissor )
+		{
+			flashlightInfo.m_FlashlightState.m_nLeft   = nLeft;
+			flashlightInfo.m_FlashlightState.m_nTop    = nTop;
+			flashlightInfo.m_FlashlightState.m_nRight  = nRight;
+			flashlightInfo.m_FlashlightState.m_nBottom = nBottom;
+		}
+	}
+
+	if ( r_flashlightdrawclip.GetBool() && r_flashlightclip.GetBool() && bUseStencil )
+	{
+		// Draw back facing debug polygons
+		for (int i=0; i<nNumPolygons; i++)
+		{
+			DrawDebugPolygon( nNumVertices[i], vClippedPolygons[i], false, false );
+		}
+/*
+		// Draw front facing debug polygons
+		for (int i=0; i<nNumPolygons; i++)
+		{
+			DrawDebugPolygon( nNumVertices[i], vClippedPolygons[i], true, bNearPlane && (i == nNumPolygons-1)  );
+		}
+*/
+	}
+
+	if ( r_flashlightclip.GetBool() && bUseStencil )
+	{
+/*
+		// The traditional settings...
+
+		// Set up to set stencil bit on front facing polygons
+		pRenderContext->SetStencilEnable( true );
+		pRenderContext->SetStencilFailOperation( STENCILOPERATION_KEEP );						// Stencil fails
+		pRenderContext->SetStencilZFailOperation( STENCILOPERATION_KEEP );						// Stencil passes but depth fails
+		pRenderContext->SetStencilPassOperation( STENCILOPERATION_REPLACE );					// Z and stencil both pass
+		pRenderContext->SetStencilCompareFunction( STENCILCOMPARISONFUNCTION_ALWAYS );			// Stencil always pass
+		pRenderContext->SetStencilReferenceValue( m_Shadows[flashlightInfo.m_Shadow].m_ucShadowStencilBit );
+		pRenderContext->SetStencilTestMask( m_Shadows[flashlightInfo.m_Shadow].m_ucShadowStencilBit );
+		pRenderContext->SetStencilWriteMask( m_Shadows[flashlightInfo.m_Shadow].m_ucShadowStencilBit );		// Bit mask which is specific to this shadow
+*/
+
+		// Just blast front faces into the stencil buffer no matter what...
+		pRenderContext->SetStencilEnable( true );
+		pRenderContext->SetStencilFailOperation( STENCILOPERATION_REPLACE );					// Stencil fails
+		pRenderContext->SetStencilZFailOperation( STENCILOPERATION_REPLACE );					// Stencil passes but depth fails
+		pRenderContext->SetStencilPassOperation( STENCILOPERATION_REPLACE );					// Z and stencil both pass
+		pRenderContext->SetStencilCompareFunction( STENCILCOMPARISONFUNCTION_ALWAYS );			// Stencil always pass
+		pRenderContext->SetStencilReferenceValue( m_Shadows[flashlightInfo.m_Shadow].m_ucShadowStencilBit );
+		pRenderContext->SetStencilTestMask( m_Shadows[flashlightInfo.m_Shadow].m_ucShadowStencilBit );
+		pRenderContext->SetStencilWriteMask( m_Shadows[flashlightInfo.m_Shadow].m_ucShadowStencilBit );		// Bit mask which is specific to this shadow
+
+		for ( int i=0; i<nNumPolygons; i++ )													// Set the stencil bit on front facing
+		{
+			DrawPolygonToStencil( pRenderContext, nNumVertices[i], vClippedPolygons[i], true, false );
+		}
+
+/*
+		pRenderContext->SetStencilReferenceValue( 0x00000000 );									// All bits cleared
+
+		for (int i=0; i<nNumPolygons; i++)														// Clear the stencil bit on back facing
+		{
+			DrawPolygonToStencil( nNumVertices[i], vClippedPolygons[i], false, false );
+		}
+*/
+
+		pRenderContext->SetStencilEnable( false );
+	}
+}
+
+//---------------------------------------------------------------------------------------
+// Set masking stencil bits for all flashlights
+//---------------------------------------------------------------------------------------
+void CShadowMgr::SetFlashlightStencilMasks( bool bDoMasking )
+{
+	VPROF_BUDGET( "CShadowMgr::RenderFlashlights", VPROF_BUDGETGROUP_SHADOW_RENDERING );
+
+	if ( IsX360() || r_flashlight_version2.GetInt() )
+		return;
+
+	// Bail out if we're not doing any of these optimizations
+	if ( !( r_flashlightclip.GetBool() || r_flashlightscissor.GetBool()) )
+		return;
+
+	FlashlightHandle_t flashlightID = m_FlashlightStates.Head();
+	if ( flashlightID == m_FlashlightStates.InvalidIndex() )
+		return;
+
+	CMatRenderContextPtr pRenderContext( materials );
+
+	for( ; 
+		 flashlightID != m_FlashlightStates.InvalidIndex(); 
+		 flashlightID = m_FlashlightStates.Next( flashlightID ) )
+	{
+		FlashlightInfo_t &flashlightInfo = m_FlashlightStates[flashlightID];
+
+		SetStencilAndScissor( pRenderContext, flashlightInfo, m_Shadows[flashlightInfo.m_Shadow].m_pFlashlightDepthTexture != NULL );
+	}
+}
+
+
+void CShadowMgr::DisableStencilAndScissorMasking( IMatRenderContext *pRenderContext )
+{
+	if ( r_flashlightclip.GetBool() )
+	{
+		pRenderContext->SetStencilEnable( false );
+	}
+
+	// Scissor even if we're not shadow depth mapping
+	if ( r_flashlightscissor.GetBool() )
+	{
+		pRenderContext->SetScissorRect( -1, -1, -1, -1, false );
+	}
+}
+
+
+//---------------------------------------------------------------------------------------
+// Enable/Disable masking based on stencil bit
+//---------------------------------------------------------------------------------------
+void CShadowMgr::EnableStencilAndScissorMasking( IMatRenderContext *pRenderContext, const FlashlightInfo_t &flashlightInfo, bool bDoMasking )
+{
+	// Bail out if we're not doing any of these optimizations
+	if ( !( r_flashlightclip.GetBool() || r_flashlightscissor.GetBool()) || !bDoMasking )
+		return;
+
+	// Only turn on scissor when rendering to the back buffer
+	if ( pRenderContext->GetRenderTarget() == NULL )
+	{
+		// Only do the stencil optimization when shadow depth mapping
+		if ( r_flashlightclip.GetBool() && m_Shadows[flashlightInfo.m_Shadow].m_pFlashlightDepthTexture != NULL )
+		{
+			unsigned char ucShadowStencilBit = m_Shadows[flashlightInfo.m_Shadow].m_ucShadowStencilBit;
+
+			pRenderContext->SetStencilEnable( true );
+			pRenderContext->SetStencilFailOperation( STENCILOPERATION_KEEP );				// Stencil fails
+			pRenderContext->SetStencilZFailOperation( STENCILOPERATION_KEEP );				// Stencil passes but depth fails
+			pRenderContext->SetStencilPassOperation( STENCILOPERATION_KEEP );				// Z and stencil both pass
+
+			pRenderContext->SetStencilCompareFunction( STENCILCOMPARISONFUNCTION_EQUAL );	// Bit must be set
+			pRenderContext->SetStencilReferenceValue( ucShadowStencilBit );					// Specific bit
+			pRenderContext->SetStencilTestMask( ucShadowStencilBit );						// Specific bit
+			pRenderContext->SetStencilWriteMask( 0x00000000 );
+		}
+
+		// Scissor even if we're not shadow depth mapping
+		if ( r_flashlightscissor.GetBool() && flashlightInfo.m_FlashlightState.m_bScissor )
+		{
+			pRenderContext->SetScissorRect( flashlightInfo.m_FlashlightState.m_nLeft, flashlightInfo.m_FlashlightState.m_nTop,
+											flashlightInfo.m_FlashlightState.m_nRight, flashlightInfo.m_FlashlightState.m_nBottom, true );
+		}
+	}
+	else // disable
+	{
+		DisableStencilAndScissorMasking( pRenderContext );
+	}
+}
+
+
+//---------------------------------------------------------------------------------------
+// Sets the render states necessary to render a flashlight
+//---------------------------------------------------------------------------------------
+void CShadowMgr::SetFlashlightRenderState( ShadowHandle_t handle )
+{
+	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
+	if ( handle == SHADOW_HANDLE_INVALID )
+	{
+		pRenderContext->SetFlashlightMode( false );
+		return;
+	}
+
+	const Shadow_t &shadow = m_Shadows[handle];
+	pRenderContext->SetFlashlightMode( true );
+	const FlashlightInfo_t &flashlightInfo = m_FlashlightStates[ shadow.m_FlashlightHandle ];
+	pRenderContext->SetFlashlightStateEx( flashlightInfo.m_FlashlightState, shadow.m_WorldToShadow, shadow.m_pFlashlightDepthTexture );
+}
+
+
+//---------------------------------------------------------------------------------------
+// Render all of the world and displacement surfaces that need to be drawn for flashlights
+//---------------------------------------------------------------------------------------
+void CShadowMgr::RenderFlashlights( bool bDoMasking, const VMatrix* pModelToWorld )
+{
+#ifndef SWDS
+	VPROF_BUDGET( "CShadowMgr::RenderFlashlights", VPROF_BUDGETGROUP_SHADOW_RENDERING );
+
+	if ( IsX360() || r_flashlight_version2.GetInt() )
+		return;
+
+	if( r_flashlightrender.GetBool()==false )
+		return;
+
+	// Draw the projective light sources, which get their material
+	// from the surface and not from the shadow.
+	// Tell the materialsystem that we are drawing additive flashlight lighting.
+	FlashlightHandle_t flashlightID = m_FlashlightStates.Head();
+	if ( flashlightID == m_FlashlightStates.InvalidIndex() )
+		return;
+
+	bool bWireframe = r_shadowwireframe.GetBool();
+
+	CMatRenderContextPtr pRenderContext( materials );
+	PIXEVENT( pRenderContext, "CShadowMgr::RenderFlashlights" );
+
+	pRenderContext->SetFlashlightMode( true );
+
+	for( ; 
+		 flashlightID != m_FlashlightStates.InvalidIndex(); 
+		 flashlightID = m_FlashlightStates.Next( flashlightID ) )
+	{
+		FlashlightInfo_t &flashlightInfo = m_FlashlightStates[flashlightID];
+		CMaterialsBuckets<SurfaceHandle_t> &materialBuckets = flashlightInfo.m_MaterialBuckets;
+		CMaterialsBuckets<SurfaceHandle_t>::SortIDHandle_t sortIDHandle = materialBuckets.GetFirstUsedSortID();
+		if ( sortIDHandle == materialBuckets.InvalidSortIDHandle() )
+			continue;
+
+		pRenderContext->SetFlashlightStateEx(flashlightInfo.m_FlashlightState, m_Shadows[flashlightInfo.m_Shadow].m_WorldToShadow, m_Shadows[flashlightInfo.m_Shadow].m_pFlashlightDepthTexture );
+		EnableStencilAndScissorMasking( pRenderContext, flashlightInfo, bDoMasking );
+
+		for( ; sortIDHandle != materialBuckets.InvalidSortIDHandle();
+			 sortIDHandle = materialBuckets.GetNextUsedSortID( sortIDHandle ) )
+		{
+			int sortID = materialBuckets.GetSortID( sortIDHandle );
+
+			if( bWireframe )
+			{
+				pRenderContext->Bind( g_materialWorldWireframe );
+			}
+			else
+			{
+				pRenderContext->Bind( materialSortInfoArray[sortID].material );
+				pRenderContext->BindLightmapPage( materialSortInfoArray[sortID].lightmapPageID );
+			}
+
+			CMaterialsBuckets<SurfaceHandle_t>::ElementHandle_t elemHandle;
+			// Figure out how many indices we have.
+			int numIndices = 0;
+			for( elemHandle = materialBuckets.GetElementListHead( sortID );
+			     elemHandle != materialBuckets.InvalidElementHandle();
+				 elemHandle = materialBuckets.GetElementListNext( elemHandle ) )
+			{
+				SurfaceHandle_t surfID = materialBuckets.GetElement( elemHandle );
+				if( !SurfaceHasDispInfo( surfID ) )
+				{
+					numIndices += 3 * ( MSurf_VertCount( surfID ) - 2 );
+				}
+			}
+
+			if( numIndices > 0 )
+			{
+				// NOTE: If we ever need to make this faster, we could get larger
+				// batches here.
+				// Draw this batch.
+#if NEWMESH
+				IIndexBuffer *pIndexBuffer = pRenderContext->GetDynamicIndexBuffer( MATERIAL_INDEX_FORMAT_16BIT );
+				CIndexBufferBuilder indexBufferBuilder;
+				indexBufferBuilder.Begin( pIndexBuffer, numIndices );
+#else
+				IMesh *pMesh = pRenderContext->GetDynamicMesh( false, g_WorldStaticMeshes[sortID], 0 );
+				CMeshBuilder meshBuilder;
+				meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, 0, numIndices );
+#endif				
+				for( elemHandle = materialBuckets.GetElementListHead( sortID );
+					 elemHandle != materialBuckets.InvalidElementHandle();
+					 elemHandle = materialBuckets.GetElementListNext( elemHandle ) )
+				{
+					SurfaceHandle_t surfID = materialBuckets.GetElement( elemHandle );
+					if( !SurfaceHasDispInfo( surfID ) )
+					{
+#if NEWMESH
+						BuildIndicesForWorldSurface( indexBufferBuilder, surfID, host_state.worldbrush );
+#else
+						BuildIndicesForWorldSurface( meshBuilder, surfID, host_state.worldbrush );
+#endif				
+					}
+				}
+				// close out the index buffer
+#if NEWMESH
+				indexBufferBuilder.End( false ); // haven't tested this one yet (flashlights)
+				// FIXME: IMaterial::GetVertexFormat() should do this stripping (add a separate 'SupportsCompression' accessor)
+				VertexFormat_t vertexFormat = materialSortInfoArray[sortID].material->GetVertexFormat() & ~VERTEX_FORMAT_COMPRESSED;
+				pRenderContext->BindVertexBuffer( 0, g_WorldStaticMeshes[sortID], 0, materialSortInfoArray[sortID].material->GetVertexFormat() );  // hack fixme. . . use currently bound material format instead of passing in?
+				pRenderContext->BindIndexBuffer( pIndexBuffer, 0 );
+				pRenderContext->Draw( MATERIAL_TRIANGLES, 0, numIndices );
+#else
+				meshBuilder.End( false, true );
+#endif				
+			}
+
+			// NOTE: If we ever need to make this faster, we could get larger batches here.
+			// Draw displacements
+			for( elemHandle = materialBuckets.GetElementListHead( sortID );
+			     elemHandle != materialBuckets.InvalidElementHandle();
+				 elemHandle = materialBuckets.GetElementListNext( elemHandle ) )
+			{
+				SurfaceHandle_t surfID = materialBuckets.GetElement( elemHandle );
+				if( SurfaceHasDispInfo( surfID ) )
+				{
+					CDispInfo *pDisp = ( CDispInfo * )MSurf_DispInfo( surfID );
+					Assert( pDisp );
+					if( bWireframe )
+					{
+						pDisp->SpecifyDynamicMesh();
+					}
+					else
+					{
+						Assert( pDisp && pDisp->m_pMesh && pDisp->m_pMesh->m_pMesh );
+						pDisp->m_pMesh->m_pMesh->Draw( pDisp->m_iIndexOffset, pDisp->m_nIndices );
+					}
+				}
+			}
+		 }
+	}
+
+	// Tell the materialsystem that we are finished drawing additive flashlight lighting.
+	pRenderContext->SetFlashlightMode( false );
+
+	// Turn off stencil masking
+	DisableStencilAndScissorMasking( pRenderContext );
+#endif
+}
+
+const Frustum_t &CShadowMgr::GetFlashlightFrustum( ShadowHandle_t handle )
+{
+	Assert( m_Shadows[handle].m_Flags & SHADOW_FLASHLIGHT );
+	Assert( m_Shadows[handle].m_FlashlightHandle != m_Shadows.InvalidIndex() );
+	return m_FlashlightStates[m_Shadows[handle].m_FlashlightHandle].m_Frustum;
+}
+
+const FlashlightState_t &CShadowMgr::GetFlashlightState( ShadowHandle_t handle )
+{
+	Assert( m_Shadows[handle].m_Flags & SHADOW_FLASHLIGHT );
+	Assert( m_Shadows[handle].m_FlashlightHandle != m_Shadows.InvalidIndex() );
+	return m_FlashlightStates[m_Shadows[handle].m_FlashlightHandle].m_FlashlightState;
+}
+
+void CShadowMgr::DrawFlashlightDecals( int sortGroup, bool bDoMasking )
+{
+	VPROF_BUDGET( "CShadowMgr::DrawFlashlightDecals", VPROF_BUDGETGROUP_SHADOW_RENDERING );
+
+	if ( IsX360() || r_flashlight_version2.GetInt() )
+		return;
+
+	FlashlightHandle_t flashlightID = m_FlashlightStates.Head();
+	if ( flashlightID == m_FlashlightStates.InvalidIndex() )
+		return;
+
+	CMatRenderContextPtr pRenderContext( materials );
+
+	pRenderContext->SetFlashlightMode( true );
+
+	for( ; 
+		 flashlightID != m_FlashlightStates.InvalidIndex(); 
+		 flashlightID = m_FlashlightStates.Next( flashlightID ) )
+	{
+		FlashlightInfo_t &flashlightInfo = m_FlashlightStates[flashlightID];
+		pRenderContext->SetFlashlightState(flashlightInfo.m_FlashlightState, m_Shadows[flashlightInfo.m_Shadow].m_WorldToShadow );
+
+		EnableStencilAndScissorMasking( pRenderContext, flashlightInfo, bDoMasking );
+
+		DecalSurfaceDraw( pRenderContext, sortGroup );
+	}
+	
+	// Tell the materialsystem that we are finished drawing additive flashlight lighting.
+	pRenderContext->SetFlashlightMode( false );
+
+	// Turn off stencil masking
+	DisableStencilAndScissorMasking( pRenderContext );
+}
+
+void CShadowMgr::DrawFlashlightDecalsOnDisplacements( int sortGroup, CDispInfo *visibleDisps[MAX_MAP_DISPINFO], int nVisibleDisps, bool bDoMasking )
+{
+	VPROF_BUDGET( "CShadowMgr::DrawFlashlightDecalsOnDisplacements", VPROF_BUDGETGROUP_SHADOW_RENDERING );
+
+	if ( IsX360() || r_flashlight_version2.GetInt() )
+		return;
+
+	FlashlightHandle_t flashlightID = m_FlashlightStates.Head();
+	if ( flashlightID == m_FlashlightStates.InvalidIndex() )
+		return;
+
+	CMatRenderContextPtr pRenderContext( materials );
+
+	pRenderContext->SetFlashlightMode( true );
+
+	DispInfo_BatchDecals( visibleDisps, nVisibleDisps );
+
+	for( ; 
+		flashlightID != m_FlashlightStates.InvalidIndex(); 
+		flashlightID = m_FlashlightStates.Next( flashlightID ) )
+	{
+		FlashlightInfo_t &flashlightInfo = m_FlashlightStates[flashlightID];
+		pRenderContext->SetFlashlightState(flashlightInfo.m_FlashlightState, m_Shadows[flashlightInfo.m_Shadow].m_WorldToShadow );
+
+		EnableStencilAndScissorMasking( pRenderContext, flashlightInfo, bDoMasking );
+
+		DispInfo_DrawDecals( visibleDisps, nVisibleDisps );
+	}
+
+	// Tell the materialsystem that we are finished drawing additive flashlight lighting.
+	pRenderContext->SetFlashlightMode( false );
+
+	// Turn off stencil masking
+	DisableStencilAndScissorMasking( pRenderContext );
+}
+
+void CShadowMgr::DrawFlashlightDecalsOnSingleSurface( SurfaceHandle_t surfID, bool bDoMasking )
+{
+	VPROF_BUDGET( "CShadowMgr::DrawFlashlightDecalsOnSingleSurface", VPROF_BUDGETGROUP_SHADOW_RENDERING );
+
+	if ( IsX360() || r_flashlight_version2.GetInt() )
+		return;
+
+	FlashlightHandle_t flashlightID = m_FlashlightStates.Head();
+	if ( flashlightID == m_FlashlightStates.InvalidIndex() )
+		return;
+
+	CMatRenderContextPtr pRenderContext( materials );
+
+	pRenderContext->SetFlashlightMode( true );
+
+	for( ; 
+		 flashlightID != m_FlashlightStates.InvalidIndex(); 
+		 flashlightID = m_FlashlightStates.Next( flashlightID ) )
+	{
+		FlashlightInfo_t &flashlightInfo = m_FlashlightStates[flashlightID];
+		pRenderContext->SetFlashlightState(flashlightInfo.m_FlashlightState, m_Shadows[flashlightInfo.m_Shadow].m_WorldToShadow );
+
+		EnableStencilAndScissorMasking( pRenderContext, flashlightInfo, bDoMasking );
+
+		DrawDecalsOnSingleSurface( pRenderContext, surfID );
+	}
+	
+	// Tell the materialsystem that we are finished drawing additive flashlight lighting.
+	pRenderContext->SetFlashlightMode( false );
+
+	// Turn off stencil masking
+	DisableStencilAndScissorMasking( pRenderContext );
+}
+
+void CShadowMgr::DrawFlashlightOverlays( int nSortGroup, bool bDoMasking )
+{
+	VPROF_BUDGET( "CShadowMgr::DrawFlashlightOverlays", VPROF_BUDGETGROUP_SHADOW_RENDERING );
+
+	if ( IsX360() || r_flashlight_version2.GetInt() )
+		return;
+
+	FlashlightHandle_t flashlightID = m_FlashlightStates.Head();
+	if ( flashlightID == m_FlashlightStates.InvalidIndex() )
+		return;
+
+	if ( r_flashlightrender.GetBool()==false )
+		return;
+
+	CMatRenderContextPtr pRenderContext( materials );
+
+	pRenderContext->SetFlashlightMode( true );
+
+	for( ; 
+		 flashlightID != m_FlashlightStates.InvalidIndex(); 
+		 flashlightID = m_FlashlightStates.Next( flashlightID ) )
+	{
+		FlashlightInfo_t &flashlightInfo = m_FlashlightStates[flashlightID];
+		pRenderContext->SetFlashlightState(flashlightInfo.m_FlashlightState, m_Shadows[flashlightInfo.m_Shadow].m_WorldToShadow );
+
+		EnableStencilAndScissorMasking( pRenderContext, flashlightInfo, bDoMasking );
+
+		OverlayMgr()->RenderOverlays( nSortGroup );
+	}
+	
+	// Tell the materialsystem that we are finished drawing additive flashlight lighting.
+	pRenderContext->SetFlashlightMode( false );
+
+	// Turn off stencil masking
+	DisableStencilAndScissorMasking( pRenderContext );
+}
+
+void CShadowMgr::DrawFlashlightDepthTexture( )
+{
+	int i = 0;
+	FlashlightHandle_t flashlightID = m_FlashlightStates.Head();
+	while ( flashlightID != m_FlashlightStates.InvalidIndex() )			// Count up the shadows
+	{
+		FlashlightInfo_t &flashlightInfo = m_FlashlightStates[ flashlightID ];
+
+		if( m_Shadows[ flashlightInfo.m_Shadow ].m_pFlashlightDepthTexture )
+		{
+			bool foundVar;
+			IMaterial *pMaterial = materials->FindMaterial( "debug/showz", TEXTURE_GROUP_OTHER, true );
+			IMaterialVar *BaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false );
+			if (!foundVar)
+				return;
+			IMaterialVar *FrameVar = pMaterial->FindVar( "$frame", &foundVar, false );
+			if (!foundVar)
+				return;
+
+			float w = 256.0f, h = 256.0f;
+			float wOffset = (i % 2) * 256.0f;	// Even|Odd go left|right
+			float hOffset = (i / 2) * 256.0f;	// Rows of two
+
+			BaseTextureVar->SetTextureValue( m_Shadows[ flashlightInfo.m_Shadow ].m_pFlashlightDepthTexture );
+			FrameVar->SetIntValue( 0 );
+
+			CMatRenderContextPtr pRenderContext( materials );
+
+			pRenderContext->Bind( pMaterial );
+			IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
+
+			CMeshBuilder meshBuilder;
+			meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
+
+			meshBuilder.Position3f( wOffset, hOffset, 0.0f );
+#ifdef DX_TO_GL_ABSTRACTION
+			meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );					// Posix is rotated due to render target origin differences
+#else
+			meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
+#endif
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.Position3f( wOffset + w, hOffset, 0.0f );
+#ifdef DX_TO_GL_ABSTRACTION
+			meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
+#else
+			meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
+#endif
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.Position3f( wOffset + w, hOffset + h, 0.0f );
+#ifdef DX_TO_GL_ABSTRACTION
+			meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
+#else
+			meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
+#endif
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.Position3f( wOffset, hOffset + h, 0.0f );
+#ifdef DX_TO_GL_ABSTRACTION
+			meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
+#else
+			meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
+#endif			
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.End();
+			pMesh->Draw();
+
+			i++;
+		}
+
+		flashlightID = m_FlashlightStates.Next( flashlightID );
+	}
+}
+
+void CShadowMgr::AddFlashlightRenderable( ShadowHandle_t shadowHandle, IClientRenderable *pRenderable )
+{
+	Shadow_t &shadow = m_Shadows[ shadowHandle ];
+	FlashlightInfo_t &flashlightInfo = m_FlashlightStates[ shadow.m_FlashlightHandle ];
+
+	if( pRenderable->GetModelInstance() != MODEL_INSTANCE_INVALID )
+	{
+ 		flashlightInfo.m_Renderables.AddToTail( pRenderable );
+	}
+}