Fix line endings. WHAMMY.

1 files changed, 1768 insertions, 1768 deletions

diff --git a/mp/src/game/client/clientleafsystem.cpp b/mp/src/game/client/clientleafsystem.cpp
index 38ee2ae3..0a4018f1 100644
--- a/mp/src/game/client/clientleafsystem.cpp
+++ b/mp/src/game/client/clientleafsystem.cpp
@@ -1,1768 +1,1768 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: 

-//

-// $Revision: $

-// $NoKeywords: $

-//

-// This file contains code to allow us to associate client data with bsp leaves.

-//===========================================================================//

-

-#include "cbase.h"

-#include "clientleafsystem.h"

-#include "utlbidirectionalset.h"

-#include "model_types.h"

-#include "ivrenderview.h"

-#include "tier0/vprof.h"

-#include "bsptreedata.h"

-#include "detailobjectsystem.h"

-#include "engine/IStaticPropMgr.h"

-#include "engine/ivdebugoverlay.h"

-#include "vstdlib/jobthread.h"

-#include "tier1/utllinkedlist.h"

-#include "datacache/imdlcache.h"

-#include "view.h"

-#include "viewrender.h"

-

-// memdbgon must be the last include file in a .cpp file!!!

-#include "tier0/memdbgon.h"

-

-class VMatrix;  // forward decl

-

-static ConVar cl_drawleaf("cl_drawleaf", "-1", FCVAR_CHEAT );

-static ConVar r_PortalTestEnts( "r_PortalTestEnts", "1", FCVAR_CHEAT, "Clip entities against portal frustums." );

-static ConVar r_portalsopenall( "r_portalsopenall", "0", FCVAR_CHEAT, "Open all portals" );

-static ConVar cl_threaded_client_leaf_system("cl_threaded_client_leaf_system", "0"  );

-

-

-DEFINE_FIXEDSIZE_ALLOCATOR( CClientRenderablesList, 1, CUtlMemoryPool::GROW_SLOW );

-

-//-----------------------------------------------------------------------------

-// Threading helpers

-//-----------------------------------------------------------------------------

-

-static void FrameLock()

-{

-	mdlcache->BeginLock();

-}

-

-static void FrameUnlock()

-{

-	mdlcache->EndLock();

-}

-

-static void CallComputeFXBlend( IClientRenderable *&pRenderable )

-{

-	pRenderable->ComputeFxBlend();

-}

-

-//-----------------------------------------------------------------------------

-// The client leaf system

-//-----------------------------------------------------------------------------

-class CClientLeafSystem : public IClientLeafSystem, public ISpatialLeafEnumerator

-{

-public:

-	virtual char const *Name() { return "CClientLeafSystem"; }

-

-	// constructor, destructor

-	CClientLeafSystem();

-	virtual ~CClientLeafSystem();

-

-	// Methods of IClientSystem

-	bool Init() { return true; }

-	void PostInit() {}

-	void Shutdown() {}

-

-	virtual bool IsPerFrame() { return true; }

-

-	void PreRender();

-	void PostRender() { }

-	void Update( float frametime ) { }

-

-	void LevelInitPreEntity();

-	void LevelInitPostEntity() {}

-	void LevelShutdownPreEntity();

-	void LevelShutdownPostEntity();

-

-	virtual void OnSave() {}

-	virtual void OnRestore() {}

-	virtual void SafeRemoveIfDesired() {}

-

-// Methods of IClientLeafSystem

-public:

-	

-	virtual void AddRenderable( IClientRenderable* pRenderable, RenderGroup_t group );

-	virtual bool IsRenderableInPVS( IClientRenderable *pRenderable );

-	virtual void CreateRenderableHandle( IClientRenderable* pRenderable, bool bIsStaticProp );

-	virtual void RemoveRenderable( ClientRenderHandle_t handle );

-

-

-	virtual void SetSubSystemDataInLeaf( int leaf, int nSubSystemIdx, CClientLeafSubSystemData *pData );

-	virtual CClientLeafSubSystemData *GetSubSystemDataInLeaf( int leaf, int nSubSystemIdx );

-

-	// FIXME: There's an incestuous relationship between DetailObjectSystem

-	// and the ClientLeafSystem. Maybe they should be the same system?

-	virtual void GetDetailObjectsInLeaf( int leaf, int& firstDetailObject, int& detailObjectCount );

- 	virtual void SetDetailObjectsInLeaf( int leaf, int firstDetailObject, int detailObjectCount );

-	virtual void DrawDetailObjectsInLeaf( int leaf, int frameNumber, int& nFirstDetailObject, int& nDetailObjectCount );

-	virtual bool ShouldDrawDetailObjectsInLeaf( int leaf, int frameNumber );

-	virtual void RenderableChanged( ClientRenderHandle_t handle );

-	virtual void SetRenderGroup( ClientRenderHandle_t handle, RenderGroup_t group );

-	virtual void ComputeTranslucentRenderLeaf( int count, const LeafIndex_t *pLeafList, const LeafFogVolume_t *pLeafFogVolumeList, int frameNumber, int viewID );

-	virtual void CollateViewModelRenderables( CUtlVector< IClientRenderable * >& opaque, CUtlVector< IClientRenderable * >& translucent );

-	virtual void BuildRenderablesList( const SetupRenderInfo_t &info );

-			void CollateRenderablesInLeaf( int leaf, int worldListLeafIndex, const SetupRenderInfo_t &info );

-	virtual void DrawStaticProps( bool enable );

-	virtual void DrawSmallEntities( bool enable );

-	virtual void EnableAlternateSorting( ClientRenderHandle_t handle, bool bEnable );

-

-	// Adds a renderable to a set of leaves

-	virtual void AddRenderableToLeaves( ClientRenderHandle_t handle, int nLeafCount, unsigned short *pLeaves );

-

-	// The following methods are related to shadows...

-	virtual ClientLeafShadowHandle_t AddShadow( ClientShadowHandle_t userId, unsigned short flags );

-	virtual void RemoveShadow( ClientLeafShadowHandle_t h );

-

-	virtual void ProjectShadow( ClientLeafShadowHandle_t handle, int nLeafCount, const int *pLeafList );

-	virtual void ProjectFlashlight( ClientLeafShadowHandle_t handle, int nLeafCount, const int *pLeafList );

-

-	// Find all shadow casters in a set of leaves

-	virtual void EnumerateShadowsInLeaves( int leafCount, LeafIndex_t* pLeaves, IClientLeafShadowEnum* pEnum );

-

-	// methods of ISpatialLeafEnumerator

-public:

-

-	bool EnumerateLeaf( int leaf, int context );

-

-	// Adds a shadow to a leaf

-	void AddShadowToLeaf( int leaf, ClientLeafShadowHandle_t handle );

-

-	// Fill in a list of the leaves this renderable is in.

-	// Returns -1 if the handle is invalid.

-	int GetRenderableLeaves( ClientRenderHandle_t handle, int leaves[128] );

-

-	// Get leaves this renderable is in

-	virtual bool GetRenderableLeaf ( ClientRenderHandle_t handle, int* pOutLeaf, const int* pInIterator = 0, int* pOutIterator = 0 );

-

-	// Singleton instance...

-	static CClientLeafSystem s_ClientLeafSystem;

-

-private:

-	// Creates a new renderable

-	void NewRenderable( IClientRenderable* pRenderable, RenderGroup_t type, int flags = 0 );

-

-	// Adds a renderable to the list of renderables

-	void AddRenderableToLeaf( int leaf, ClientRenderHandle_t handle );

-

-	void SortEntities(  const Vector &vecRenderOrigin, const Vector &vecRenderForward, CClientRenderablesList::CEntry *pEntities, int nEntities );

-

-	// Returns -1 if the renderable spans more than one area. If it's totally in one area, then this returns the leaf.

-	short GetRenderableArea( ClientRenderHandle_t handle );

-

-	// remove renderables from leaves

-	void InsertIntoTree( ClientRenderHandle_t &handle );

-	void RemoveFromTree( ClientRenderHandle_t handle );

-

-	// Returns if it's a view model render group

-	inline bool IsViewModelRenderGroup( RenderGroup_t group ) const;

-

-	// Adds, removes renderables from view model list

-	void AddToViewModelList( ClientRenderHandle_t handle );

-	void RemoveFromViewModelList( ClientRenderHandle_t handle );

-

-	// Insert translucent renderables into list of translucent objects

-	void InsertTranslucentRenderable( IClientRenderable* pRenderable,

-		int& count, IClientRenderable** pList, float* pDist );

-

-	// Used to change renderables from translucent to opaque

-	// Only really used by the static prop fading...

-	void ChangeRenderableRenderGroup( ClientRenderHandle_t handle, RenderGroup_t group );

-

-	// Adds a shadow to a leaf/removes shadow from renderable

-	void AddShadowToRenderable( ClientRenderHandle_t renderHandle, ClientLeafShadowHandle_t shadowHandle );

-	void RemoveShadowFromRenderables( ClientLeafShadowHandle_t handle );

-

-	// Adds a shadow to a leaf/removes shadow from renderable

-	bool ShouldRenderableReceiveShadow( ClientRenderHandle_t renderHandle, int nShadowFlags );

-

-	// Adds a shadow to a leaf/removes shadow from leaf

-	void RemoveShadowFromLeaves( ClientLeafShadowHandle_t handle );

-

-	// Methods associated with the various bi-directional sets

-	static unsigned short& FirstRenderableInLeaf( int leaf ) 

-	{ 

-		return s_ClientLeafSystem.m_Leaf[leaf].m_FirstElement;

-	}

-

-	static unsigned short& FirstLeafInRenderable( unsigned short renderable ) 

-	{ 

-		return s_ClientLeafSystem.m_Renderables[renderable].m_LeafList;

-	}

-

-	static unsigned short& FirstShadowInLeaf( int leaf ) 

-	{ 

-		return s_ClientLeafSystem.m_Leaf[leaf].m_FirstShadow;

-	}

-

-	static unsigned short& FirstLeafInShadow( ClientLeafShadowHandle_t shadow ) 

-	{ 

-		return s_ClientLeafSystem.m_Shadows[shadow].m_FirstLeaf;

-	}

-

-	static unsigned short& FirstShadowOnRenderable( unsigned short renderable ) 

-	{ 

-		return s_ClientLeafSystem.m_Renderables[renderable].m_FirstShadow;

-	}

-

-	static unsigned short& FirstRenderableInShadow( ClientLeafShadowHandle_t shadow ) 

-	{ 

-		return s_ClientLeafSystem.m_Shadows[shadow].m_FirstRenderable;

-	}

-

-	void FrameLock()

-	{

-		mdlcache->BeginLock();

-	}

-

-	void FrameUnlock()

-	{

-		mdlcache->EndLock();

-	}

-

-private:

-	enum

-	{

-		RENDER_FLAGS_TWOPASS		= 0x01,

-		RENDER_FLAGS_STATIC_PROP	= 0x02,

-		RENDER_FLAGS_BRUSH_MODEL	= 0x04,

-		RENDER_FLAGS_STUDIO_MODEL	= 0x08,

-		RENDER_FLAGS_HASCHANGED		= 0x10,

-		RENDER_FLAGS_ALTERNATE_SORTING = 0x20,

-	};

-

-	// All the information associated with a particular handle

-	struct RenderableInfo_t

-	{

-		IClientRenderable*	m_pRenderable;

-		int					m_RenderFrame;	// which frame did I render it in?

-		int					m_RenderFrame2;

-		int					m_EnumCount;	// Have I been added to a particular shadow yet?

-		int					m_TranslucencyCalculated;

-		unsigned short		m_LeafList;		// What leafs is it in?

-		unsigned short		m_RenderLeaf;	// What leaf do I render in?

-		unsigned char		m_Flags;		// rendering flags

-		unsigned char		m_RenderGroup;	// RenderGroup_t type

-		unsigned short		m_FirstShadow;	// The first shadow caster that cast on it

-		short m_Area;	// -1 if the renderable spans multiple areas.

-		signed char			m_TranslucencyCalculatedView;

-	};

-

-	// The leaf contains an index into a list of renderables

-	struct ClientLeaf_t

-	{

-		unsigned short	m_FirstElement;

-		unsigned short	m_FirstShadow;

-

-		unsigned short	m_FirstDetailProp;

-		unsigned short	m_DetailPropCount;

-		int				m_DetailPropRenderFrame;

-		CClientLeafSubSystemData *m_pSubSystemData[N_CLSUBSYSTEMS];

-

-	};

-

-	// Shadow information

-	struct ShadowInfo_t

-	{

-		unsigned short	m_FirstLeaf;

-		unsigned short	m_FirstRenderable;

-		int				m_EnumCount;

-		ClientShadowHandle_t	m_Shadow;

-		unsigned short	m_Flags;

-	};

-

-	struct EnumResult_t

-	{

-		int leaf;

-		EnumResult_t *pNext;

-	};

-

-	struct EnumResultList_t

-	{

-		EnumResult_t *pHead;

-		ClientRenderHandle_t handle;

-	};

-

-	// Stores data associated with each leaf.

-	CUtlVector< ClientLeaf_t >	m_Leaf;

-

-	// Stores all unique non-detail renderables

-	CUtlLinkedList< RenderableInfo_t, ClientRenderHandle_t, false, unsigned int >	m_Renderables;

-

-	// Information associated with shadows registered with the client leaf system

-	CUtlLinkedList< ShadowInfo_t, ClientLeafShadowHandle_t, false, unsigned int >	m_Shadows;

-

-	// Maintains the list of all renderables in a particular leaf

-	CBidirectionalSet< int, ClientRenderHandle_t, unsigned short, unsigned int >	m_RenderablesInLeaf;

-

-	// Maintains a list of all shadows in a particular leaf 

-	CBidirectionalSet< int, ClientLeafShadowHandle_t, unsigned short, unsigned int >	m_ShadowsInLeaf;

-

-	// Maintains a list of all shadows cast on a particular renderable

-	CBidirectionalSet< ClientRenderHandle_t, ClientLeafShadowHandle_t, unsigned short, unsigned int >	m_ShadowsOnRenderable;

-

-	// Dirty list of renderables

-	CUtlVector< ClientRenderHandle_t >	m_DirtyRenderables;

-

-	// List of renderables in view model render groups

-	CUtlVector< ClientRenderHandle_t >	m_ViewModels;

-

-	// Should I draw static props?

-	bool m_DrawStaticProps;

-	bool m_DrawSmallObjects;

-

-	// A little enumerator to help us when adding shadows to renderables

-	int	m_ShadowEnum;

-

-	CTSList<EnumResultList_t> m_DeferredInserts;

-};

-

-

-//-----------------------------------------------------------------------------

-// Expose IClientLeafSystem to the client dll.

-//-----------------------------------------------------------------------------

-CClientLeafSystem CClientLeafSystem::s_ClientLeafSystem;

-IClientLeafSystem *g_pClientLeafSystem = &CClientLeafSystem::s_ClientLeafSystem;

-EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CClientLeafSystem, IClientLeafSystem, CLIENTLEAFSYSTEM_INTERFACE_VERSION, CClientLeafSystem::s_ClientLeafSystem );

-

-void CalcRenderableWorldSpaceAABB_Fast( IClientRenderable *pRenderable, Vector &absMin, Vector &absMax );

-

-//-----------------------------------------------------------------------------

-// Helper functions.

-//-----------------------------------------------------------------------------

-void DefaultRenderBoundsWorldspace( IClientRenderable *pRenderable, Vector &absMins, Vector &absMaxs )

-{

-	// Tracker 37433:  This fixes a bug where if the stunstick is being wielded by a combine soldier, the fact that the stick was

-	//  attached to the soldier's hand would move it such that it would get frustum culled near the edge of the screen.

-	C_BaseEntity *pEnt = pRenderable->GetIClientUnknown()->GetBaseEntity();

-	if ( pEnt && pEnt->IsFollowingEntity() )

-	{

-		C_BaseEntity *pParent = pEnt->GetFollowedEntity();

-		if ( pParent )

-		{

-			// Get the parent's abs space world bounds.

-			CalcRenderableWorldSpaceAABB_Fast( pParent, absMins, absMaxs );

-

-			// Add the maximum of our local render bounds. This is making the assumption that we can be at any

-			// point and at any angle within the parent's world space bounds.

-			Vector vAddMins, vAddMaxs;

-			pEnt->GetRenderBounds( vAddMins, vAddMaxs );

-			// if our origin is actually farther away than that, expand again

-			float radius = pEnt->GetLocalOrigin().Length();

-

-			float flBloatSize = MAX( vAddMins.Length(), vAddMaxs.Length() );

-			flBloatSize = MAX(flBloatSize, radius);

-			absMins -= Vector( flBloatSize, flBloatSize, flBloatSize );

-			absMaxs += Vector( flBloatSize, flBloatSize, flBloatSize );

-			return;

-		}

-	}

-

-	Vector mins, maxs;

-	pRenderable->GetRenderBounds( mins, maxs );

-

-	// FIXME: Should I just use a sphere here?

-	// Another option is to pass the OBB down the tree; makes for a better fit

-	// Generate a world-aligned AABB

-	const QAngle& angles = pRenderable->GetRenderAngles();

-	const Vector& origin = pRenderable->GetRenderOrigin();

-	if (angles == vec3_angle)

-	{

-		VectorAdd( mins, origin, absMins );

-		VectorAdd( maxs, origin, absMaxs );

-	}

-	else

-	{

-		matrix3x4_t	boxToWorld;

-		AngleMatrix( angles, origin, boxToWorld );

-		TransformAABB( boxToWorld, mins, maxs, absMins, absMaxs );

-	}

-	Assert( absMins.IsValid() && absMaxs.IsValid() );

-}

-

-// Figure out a world space bounding box that encloses the entity's local render bounds in world space.

-inline void CalcRenderableWorldSpaceAABB( 

-	IClientRenderable *pRenderable, 

-	Vector &absMins,

-	Vector &absMaxs )

-{

-	pRenderable->GetRenderBoundsWorldspace( absMins, absMaxs );

-}

-

-

-// This gets an AABB for the renderable, but it doesn't cause a parent's bones to be setup.

-// This is used for placement in the leaves, but the more expensive version is used for culling.

-void CalcRenderableWorldSpaceAABB_Fast( IClientRenderable *pRenderable, Vector &absMin, Vector &absMax )

-{

-	C_BaseEntity *pEnt = pRenderable->GetIClientUnknown()->GetBaseEntity();

-	if ( pEnt && pEnt->IsFollowingEntity() )

-	{

-		C_BaseEntity *pParent = pEnt->GetMoveParent();

-		Assert( pParent );

-

-		// Get the parent's abs space world bounds.

-		CalcRenderableWorldSpaceAABB_Fast( pParent, absMin, absMax );

-

-		// Add the maximum of our local render bounds. This is making the assumption that we can be at any

-		// point and at any angle within the parent's world space bounds.

-		Vector vAddMins, vAddMaxs;

-		pEnt->GetRenderBounds( vAddMins, vAddMaxs );

-		// if our origin is actually farther away than that, expand again

-		float radius = pEnt->GetLocalOrigin().Length();

-

-		float flBloatSize = MAX( vAddMins.Length(), vAddMaxs.Length() );

-		flBloatSize = MAX(flBloatSize, radius);

-		absMin -= Vector( flBloatSize, flBloatSize, flBloatSize );

-		absMax += Vector( flBloatSize, flBloatSize, flBloatSize );

-	}

-	else

-	{

-		// Start out with our own render bounds. Since we don't have a parent, this won't incur any nasty 

-		CalcRenderableWorldSpaceAABB( pRenderable, absMin, absMax );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// constructor, destructor

-//-----------------------------------------------------------------------------

-CClientLeafSystem::CClientLeafSystem() : m_DrawStaticProps(true), m_DrawSmallObjects(true)

-{

-	// Set up the bi-directional lists...

-	m_RenderablesInLeaf.Init( FirstRenderableInLeaf, FirstLeafInRenderable );

-	m_ShadowsInLeaf.Init( FirstShadowInLeaf, FirstLeafInShadow ); 

-	m_ShadowsOnRenderable.Init( FirstShadowOnRenderable, FirstRenderableInShadow );

-}

-

-CClientLeafSystem::~CClientLeafSystem()

-{

-}

-

-//-----------------------------------------------------------------------------

-// Activate, deactivate static props

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::DrawStaticProps( bool enable )

-{

-	m_DrawStaticProps = enable;

-}

-

-void CClientLeafSystem::DrawSmallEntities( bool enable )

-{

-	m_DrawSmallObjects = enable;

-}

-

-

-//-----------------------------------------------------------------------------

-// Level init, shutdown

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::LevelInitPreEntity()

-{

-	MEM_ALLOC_CREDIT();

-

-	m_Renderables.EnsureCapacity( 1024 );

-	m_RenderablesInLeaf.EnsureCapacity( 1024 );

-	m_ShadowsInLeaf.EnsureCapacity( 256 );

-	m_ShadowsOnRenderable.EnsureCapacity( 256 );

-	m_DirtyRenderables.EnsureCapacity( 256 );

-

-	// Add all the leaves we'll need

-	int leafCount = engine->LevelLeafCount();

-	m_Leaf.EnsureCapacity( leafCount );

-

-	ClientLeaf_t newLeaf;

-	newLeaf.m_FirstElement = m_RenderablesInLeaf.InvalidIndex();

-	newLeaf.m_FirstShadow = m_ShadowsInLeaf.InvalidIndex();

-	memset( newLeaf.m_pSubSystemData, 0, sizeof( newLeaf.m_pSubSystemData ) );

-	newLeaf.m_FirstDetailProp = 0;

-	newLeaf.m_DetailPropCount = 0;

-	newLeaf.m_DetailPropRenderFrame = -1;

-	while ( --leafCount >= 0 )

-	{

-		m_Leaf.AddToTail( newLeaf );

-	}

-}

-

-void CClientLeafSystem::LevelShutdownPreEntity()

-{

-}

-

-void CClientLeafSystem::LevelShutdownPostEntity()

-{

-	m_ViewModels.Purge();

-	m_Renderables.Purge();

-	m_RenderablesInLeaf.Purge();

-	m_Shadows.Purge();

-

-	// delete subsystem data

-	for( int i = 0; i < m_Leaf.Count() ; i++ )

-	{

-		for( int j = 0 ; j < ARRAYSIZE( m_Leaf[i].m_pSubSystemData ) ; j++ )

-		{

-			if ( m_Leaf[i].m_pSubSystemData[j] )

-			{

-				delete m_Leaf[i].m_pSubSystemData[j];

-				m_Leaf[i].m_pSubSystemData[j] = NULL;

-			}

-		}

-	}

-	m_Leaf.Purge();

-	m_ShadowsInLeaf.Purge();

-	m_ShadowsOnRenderable.Purge();

-	m_DirtyRenderables.Purge();

-}

-

-

-//-----------------------------------------------------------------------------

-// This is what happens before rendering a particular view

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::PreRender()

-{

-	VPROF_BUDGET( "CClientLeafSystem::PreRender", "PreRender" );

-

-	int i;

-	int nIterations = 0;

-

-	while ( m_DirtyRenderables.Count() )

-	{

-		if ( ++nIterations > 10 )

-		{

-			Warning( "Too many dirty renderables!\n" );

-			break;

-		}

-

-		int nDirty = m_DirtyRenderables.Count();

-		for ( i = nDirty; --i >= 0; )

-		{

-			ClientRenderHandle_t handle = m_DirtyRenderables[i];

-			Assert( m_Renderables[ handle ].m_Flags & RENDER_FLAGS_HASCHANGED );

-

-			// Update position in leaf system

-			RemoveFromTree( handle );

-		}

-

-		bool bThreaded = false;//( nDirty > 5 && cl_threaded_client_leaf_system.GetBool() && g_pThreadPool->NumThreads() );

-

-		if ( !bThreaded )

-		{

-			for ( i = nDirty; --i >= 0; )

-			{

-				InsertIntoTree( m_DirtyRenderables[i] );

-			}

-		}

-		else

-		{

-			// InsertIntoTree can result in new renderables being added, so copy:

-			ClientRenderHandle_t *pDirtyRenderables = (ClientRenderHandle_t *)alloca( sizeof(ClientRenderHandle_t) * nDirty );

-			memcpy( pDirtyRenderables, m_DirtyRenderables.Base(), sizeof(ClientRenderHandle_t) * nDirty );

-			ParallelProcess( "CClientLeafSystem::PreRender", pDirtyRenderables, nDirty, this, &CClientLeafSystem::InsertIntoTree, &CClientLeafSystem::FrameLock, &CClientLeafSystem::FrameUnlock );

-		}

-

-		if ( m_DeferredInserts.Count() )

-		{

-			EnumResultList_t enumResultList;

-			while ( m_DeferredInserts.PopItem( &enumResultList ) )

-			{

-				m_ShadowEnum++;

-				while ( enumResultList.pHead )

-				{

-					EnumResult_t *p = enumResultList.pHead;

-					enumResultList.pHead = p->pNext;

-					AddRenderableToLeaf( p->leaf, enumResultList.handle );

-					delete p;

-				}

-			}

-		}

-

-		for ( i = nDirty; --i >= 0; )

-		{

-			// Cache off the area it's sitting in.

-			ClientRenderHandle_t handle = m_DirtyRenderables[i];

-			RenderableInfo_t& renderable = m_Renderables[ handle ];

-

-			renderable.m_Flags &= ~RENDER_FLAGS_HASCHANGED;

-			m_Renderables[handle].m_Area = GetRenderableArea( handle );

-		}

-

-		m_DirtyRenderables.RemoveMultiple( 0, nDirty );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Creates a new renderable

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::NewRenderable( IClientRenderable* pRenderable, RenderGroup_t type, int flags )

-{

-	Assert( pRenderable );

-	Assert( pRenderable->RenderHandle() == INVALID_CLIENT_RENDER_HANDLE );

-

-	ClientRenderHandle_t handle = m_Renderables.AddToTail();

-	RenderableInfo_t &info = m_Renderables[handle];

-

-	// We need to know if it's a brush model for shadows

-	int modelType = modelinfo->GetModelType( pRenderable->GetModel() );

-	if (modelType == mod_brush)

-	{

-		flags |= RENDER_FLAGS_BRUSH_MODEL;

-	}

-	else if ( modelType == mod_studio )

-	{

-		flags |= RENDER_FLAGS_STUDIO_MODEL;

-	}

-

-	info.m_pRenderable = pRenderable;

-	info.m_RenderFrame = -1;

-	info.m_RenderFrame2 = -1;

-	info.m_TranslucencyCalculated = -1;

-	info.m_TranslucencyCalculatedView = VIEW_ILLEGAL;

-	info.m_FirstShadow = m_ShadowsOnRenderable.InvalidIndex();

-	info.m_LeafList = m_RenderablesInLeaf.InvalidIndex();

-	info.m_Flags = flags;

-	info.m_RenderGroup = (unsigned char)type;

-	info.m_EnumCount = 0;

-	info.m_RenderLeaf = 0xFFFF;

-	if ( IsViewModelRenderGroup( (RenderGroup_t)info.m_RenderGroup ) )

-	{

-		AddToViewModelList( handle );

-	}

-

-	pRenderable->RenderHandle() = handle;

-}

-

-void CClientLeafSystem::CreateRenderableHandle( IClientRenderable* pRenderable, bool bIsStaticProp )

-{

-	// FIXME: The argument is unnecessary if we could get this next line to work

-	// the reason why we can't is because currently there are IClientRenderables

-	// which don't correctly implement GetRefEHandle.

-

-	//bool bIsStaticProp = staticpropmgr->IsStaticProp( pRenderable->GetIClientUnknown() );

-

-	// Add the prop to all the leaves it lies in

-	RenderGroup_t group = pRenderable->IsTransparent() ? RENDER_GROUP_TRANSLUCENT_ENTITY : RENDER_GROUP_OPAQUE_ENTITY;

-

-	bool bTwoPass = false;

-	if ( group == RENDER_GROUP_TRANSLUCENT_ENTITY )

-	{

-		bTwoPass = pRenderable->IsTwoPass( );

-	}

-

-	int flags = 0;

-	if ( bIsStaticProp )

-	{

-		flags = RENDER_FLAGS_STATIC_PROP;

-		if ( group == RENDER_GROUP_OPAQUE_ENTITY )

-		{

-			group = RENDER_GROUP_OPAQUE_STATIC;

-		}

-	}

-

-	if (bTwoPass)

-	{

-		flags |= RENDER_FLAGS_TWOPASS;

-	}

-

-	NewRenderable( pRenderable, group, flags );

-}

-

-

-//-----------------------------------------------------------------------------

-// Used to change renderables from translucent to opaque

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::ChangeRenderableRenderGroup( ClientRenderHandle_t handle, RenderGroup_t group )

-{

-	RenderableInfo_t &info = m_Renderables[handle];

-	info.m_RenderGroup = (unsigned char)group;

-}

-

-

-//-----------------------------------------------------------------------------

-// Use alternate translucent sorting algorithm (draw translucent objects in the furthest leaf they lie in)

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::EnableAlternateSorting( ClientRenderHandle_t handle, bool bEnable )

-{

-	RenderableInfo_t &info = m_Renderables[handle];

-	if ( bEnable )

-	{

-		info.m_Flags |= RENDER_FLAGS_ALTERNATE_SORTING;

-	}

-	else

-	{

-		info.m_Flags &= ~RENDER_FLAGS_ALTERNATE_SORTING; 

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Add/remove renderable

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::AddRenderable( IClientRenderable* pRenderable, RenderGroup_t group )

-{

-	// force a relink we we try to draw it for the first time

-	int flags = RENDER_FLAGS_HASCHANGED;

-

-	if ( group == RENDER_GROUP_TWOPASS )

-	{

-		group = RENDER_GROUP_TRANSLUCENT_ENTITY;

-		flags |= RENDER_FLAGS_TWOPASS;

-	}

-

-	NewRenderable( pRenderable, group, flags );

-	ClientRenderHandle_t handle = pRenderable->RenderHandle();

-	m_DirtyRenderables.AddToTail( handle );

-}

-

-void CClientLeafSystem::RemoveRenderable( ClientRenderHandle_t handle )

-{

-	// This can happen upon level shutdown

-	if (!m_Renderables.IsValidIndex(handle))

-		return;

-

-	// Reset the render handle in the entity.

-	IClientRenderable *pRenderable = m_Renderables[handle].m_pRenderable;

-	Assert( handle == pRenderable->RenderHandle() );

-	pRenderable->RenderHandle() = INVALID_CLIENT_RENDER_HANDLE;

-

-	// Reemove the renderable from the dirty list

-	if ( m_Renderables[handle].m_Flags & RENDER_FLAGS_HASCHANGED )

-	{

-		// NOTE: This isn't particularly fast (linear search),

-		// but I'm assuming it's an unusual case where we remove 

-		// renderables that are changing or that m_DirtyRenderables usually

-		// only has a couple entries

-		int i = m_DirtyRenderables.Find( handle );

-		Assert( i != m_DirtyRenderables.InvalidIndex() );

-		m_DirtyRenderables.FastRemove( i ); 

-	}

-

-	if ( IsViewModelRenderGroup( (RenderGroup_t)m_Renderables[handle].m_RenderGroup ) )

-	{

-		RemoveFromViewModelList( handle );

-	}

-

-	RemoveFromTree( handle );

-	m_Renderables.Remove( handle );

-}

-

-

-int CClientLeafSystem::GetRenderableLeaves( ClientRenderHandle_t handle, int leaves[128] )

-{

-	if ( !m_Renderables.IsValidIndex( handle ) )

-		return -1;

-

-	RenderableInfo_t *pRenderable = &m_Renderables[handle];

-	if ( pRenderable->m_LeafList == m_RenderablesInLeaf.InvalidIndex() )

-		return -1;

-

-	int nLeaves = 0;

-	for ( int i=m_RenderablesInLeaf.FirstBucket( handle ); i != m_RenderablesInLeaf.InvalidIndex(); i = m_RenderablesInLeaf.NextBucket( i ) )

-	{

-		leaves[nLeaves++] = m_RenderablesInLeaf.Bucket( i );

-		if ( nLeaves >= 128 )

-			break;

-	}

-	return nLeaves;

-}

-

-

-//-----------------------------------------------------------------------------

-// Retrieve leaf handles to leaves a renderable is in

-// the pOutLeaf parameter is filled with the leaf the renderable is in.

-// If pInIterator is not specified, pOutLeaf is the first leaf in the list.

-// if pInIterator is specified, that iterator is used to return the next leaf

-// in the list in pOutLeaf.

-// the pOutIterator parameter is filled with the iterater which index to the pOutLeaf returned.

-//

-// Returns false on failure cases where pOutLeaf will be invalid. CHECK THE RETURN!

-//-----------------------------------------------------------------------------

-bool CClientLeafSystem::GetRenderableLeaf(ClientRenderHandle_t handle, int* pOutLeaf, const int* pInIterator /* = 0 */, int* pOutIterator /* = 0  */)

-{

-	// bail on invalid handle

-	if ( !m_Renderables.IsValidIndex( handle ) )

-		return false;

-

-	// bail on no output value pointer

-	if ( !pOutLeaf )

-		return false;

-

-	// an iterator was specified

-	if ( pInIterator )

-	{

-		int iter = *pInIterator;

-

-		// test for invalid iterator

-		if ( iter == m_RenderablesInLeaf.InvalidIndex() )

-			return false;

-

-		int iterNext =  m_RenderablesInLeaf.NextBucket( iter );

-

-		// test for end of list

-		if ( iterNext == m_RenderablesInLeaf.InvalidIndex() )

-			return false;

-

-		// Give the caller the iterator used

-		if ( pOutIterator )

-		{

-			*pOutIterator = iterNext;

-		}

-		

-		// set output value to the next leaf

-		*pOutLeaf = m_RenderablesInLeaf.Bucket( iterNext );

-

-	}

-	else // no iter param, give them the first bucket in the renderable's list

-	{

-		int iter = m_RenderablesInLeaf.FirstBucket( handle );

-

-		if ( iter == m_RenderablesInLeaf.InvalidIndex() )

-			return false;

-

-		// Set output value to this leaf

-		*pOutLeaf = m_RenderablesInLeaf.Bucket( iter );

-

-		// give this iterator to caller

-		if ( pOutIterator )

-		{

-			*pOutIterator = iter;

-		}

-		

-	}

-	

-	return true;

-}

-

-bool CClientLeafSystem::IsRenderableInPVS( IClientRenderable *pRenderable )

-{

-	ClientRenderHandle_t handle = pRenderable->RenderHandle();

-	int leaves[128];

-	int nLeaves = GetRenderableLeaves( handle, leaves );

-	if ( nLeaves == -1 )

-		return false;

-

-	// Ask the engine if this guy is visible.

-	return render->AreAnyLeavesVisible( leaves, nLeaves );

-}

-

-short CClientLeafSystem::GetRenderableArea( ClientRenderHandle_t handle )

-{

-	int leaves[128];

-	int nLeaves = GetRenderableLeaves( handle, leaves );

-	if ( nLeaves == -1 )

-		return 0;

-

-	// Now ask the 

-	return engine->GetLeavesArea( leaves, nLeaves );

-}

-

-

-void CClientLeafSystem::SetSubSystemDataInLeaf( int leaf, int nSubSystemIdx, CClientLeafSubSystemData *pData )

-{

-	assert( nSubSystemIdx < N_CLSUBSYSTEMS );

-	if ( m_Leaf[leaf].m_pSubSystemData[nSubSystemIdx] )

-		delete m_Leaf[leaf].m_pSubSystemData[nSubSystemIdx];

-	m_Leaf[leaf].m_pSubSystemData[nSubSystemIdx] = pData;

-}

-

-CClientLeafSubSystemData *CClientLeafSystem::GetSubSystemDataInLeaf( int leaf, int nSubSystemIdx )

-{

-	assert( nSubSystemIdx < N_CLSUBSYSTEMS );

-	return m_Leaf[leaf].m_pSubSystemData[nSubSystemIdx];

-}

-

-//-----------------------------------------------------------------------------

-// Indicates which leaves detail objects are in

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::SetDetailObjectsInLeaf( int leaf, int firstDetailObject,

-											    int detailObjectCount )

-{

-	m_Leaf[leaf].m_FirstDetailProp = firstDetailObject;

-	m_Leaf[leaf].m_DetailPropCount = detailObjectCount;

-}

-

-//-----------------------------------------------------------------------------

-// Returns the detail objects in a leaf

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::GetDetailObjectsInLeaf( int leaf, int& firstDetailObject,

-											    int& detailObjectCount )

-{

-	firstDetailObject = m_Leaf[leaf].m_FirstDetailProp;

-	detailObjectCount = m_Leaf[leaf].m_DetailPropCount;

-}

-

-

-//-----------------------------------------------------------------------------

-// Create/destroy shadows...

-//-----------------------------------------------------------------------------

-ClientLeafShadowHandle_t CClientLeafSystem::AddShadow( ClientShadowHandle_t userId, unsigned short flags )

-{

-	ClientLeafShadowHandle_t idx = m_Shadows.AddToTail();

-	m_Shadows[idx].m_Shadow = userId;

-	m_Shadows[idx].m_FirstLeaf = m_ShadowsInLeaf.InvalidIndex();

-	m_Shadows[idx].m_FirstRenderable = m_ShadowsOnRenderable.InvalidIndex();

-	m_Shadows[idx].m_EnumCount = 0;

-	m_Shadows[idx].m_Flags = flags;

-	return idx;

-}

-

-void CClientLeafSystem::RemoveShadow( ClientLeafShadowHandle_t handle )

-{

-	// Remove the shadow from all leaves + renderables...

-	RemoveShadowFromLeaves( handle );

-	RemoveShadowFromRenderables( handle );

-

-	// Blow away the handle

-	m_Shadows.Remove( handle );

-}

-

-

-//-----------------------------------------------------------------------------

-// Adds a shadow to a leaf/removes shadow from renderable

-//-----------------------------------------------------------------------------

-inline bool CClientLeafSystem::ShouldRenderableReceiveShadow( ClientRenderHandle_t renderHandle, int nShadowFlags )

-{

-	RenderableInfo_t &renderable = m_Renderables[renderHandle];

-	if( !( renderable.m_Flags & ( RENDER_FLAGS_BRUSH_MODEL | RENDER_FLAGS_STATIC_PROP | RENDER_FLAGS_STUDIO_MODEL ) ) )

-		return false;

-

-	return renderable.m_pRenderable->ShouldReceiveProjectedTextures( nShadowFlags );

-}

-

-

-//-----------------------------------------------------------------------------

-// Adds a shadow to a leaf/removes shadow from renderable

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::AddShadowToRenderable( ClientRenderHandle_t renderHandle, 

-										ClientLeafShadowHandle_t shadowHandle )

-{

-	// Check if this renderable receives the type of projected texture that shadowHandle refers to.

-	int nShadowFlags = m_Shadows[shadowHandle].m_Flags;

-	if ( !ShouldRenderableReceiveShadow( renderHandle, nShadowFlags ) )

-		return;

-

-	m_ShadowsOnRenderable.AddElementToBucket( renderHandle, shadowHandle );

-

-	// Also, do some stuff specific to the particular types of renderables

-

-	// If the renderable is a brush model, then add this shadow to it

-	if (m_Renderables[renderHandle].m_Flags & RENDER_FLAGS_BRUSH_MODEL)

-	{

-		IClientRenderable* pRenderable = m_Renderables[renderHandle].m_pRenderable;

-		g_pClientShadowMgr->AddShadowToReceiver( m_Shadows[shadowHandle].m_Shadow,

-			pRenderable, SHADOW_RECEIVER_BRUSH_MODEL );

-	}

-	else if( m_Renderables[renderHandle].m_Flags & RENDER_FLAGS_STATIC_PROP )

-	{

-		IClientRenderable* pRenderable = m_Renderables[renderHandle].m_pRenderable;

-		g_pClientShadowMgr->AddShadowToReceiver( m_Shadows[shadowHandle].m_Shadow,

-			pRenderable, SHADOW_RECEIVER_STATIC_PROP );

-	}

-	else if( m_Renderables[renderHandle].m_Flags & RENDER_FLAGS_STUDIO_MODEL )

-	{

-		IClientRenderable* pRenderable = m_Renderables[renderHandle].m_pRenderable;

-		g_pClientShadowMgr->AddShadowToReceiver( m_Shadows[shadowHandle].m_Shadow,

-			pRenderable, SHADOW_RECEIVER_STUDIO_MODEL );

-	}

-}

-

-void CClientLeafSystem::RemoveShadowFromRenderables( ClientLeafShadowHandle_t handle )

-{

-	m_ShadowsOnRenderable.RemoveElement( handle );

-}

-

-

-//-----------------------------------------------------------------------------

-// Adds a shadow to a leaf/removes shadow from leaf

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::AddShadowToLeaf( int leaf, ClientLeafShadowHandle_t shadow )

-{

-	m_ShadowsInLeaf.AddElementToBucket( leaf, shadow ); 

-

-	// Add the shadow exactly once to all renderables in the leaf

-	unsigned short i = m_RenderablesInLeaf.FirstElement( leaf );

-	while ( i != m_RenderablesInLeaf.InvalidIndex() )

-	{

-		ClientRenderHandle_t renderable = m_RenderablesInLeaf.Element(i);

-		RenderableInfo_t& info = m_Renderables[renderable];

-

-		// Add each shadow exactly once to each renderable

-		if (info.m_EnumCount != m_ShadowEnum)

-		{

-			AddShadowToRenderable( renderable, shadow );

-			info.m_EnumCount = m_ShadowEnum;

-		}

-

-		Assert( m_ShadowsInLeaf.NumAllocated() < 2000 );

-

-		i = m_RenderablesInLeaf.NextElement(i);

-	}

-}

-

-void CClientLeafSystem::RemoveShadowFromLeaves( ClientLeafShadowHandle_t handle )

-{

-	m_ShadowsInLeaf.RemoveElement( handle );

-}

-

-

-//-----------------------------------------------------------------------------

-// Adds a shadow to all leaves listed

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::ProjectShadow( ClientLeafShadowHandle_t handle, int nLeafCount, const int *pLeafList )

-{

-	// Remove the shadow from any leaves it current exists in

-	RemoveShadowFromLeaves( handle );

-	RemoveShadowFromRenderables( handle );

-

-	Assert( ( m_Shadows[handle].m_Flags & SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK ) == SHADOW_FLAGS_SHADOW );

-

-	// This will help us to avoid adding the shadow multiple times to a renderable

-	++m_ShadowEnum;

-

-	for ( int i = 0; i < nLeafCount; ++i )

-	{

-		AddShadowToLeaf( pLeafList[i], handle );

-	}

-}

-

-void CClientLeafSystem::ProjectFlashlight( ClientLeafShadowHandle_t handle, int nLeafCount, const int *pLeafList )

-{

-	VPROF_BUDGET( "CClientLeafSystem::ProjectFlashlight", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );

-

-	// Remove the shadow from any leaves it current exists in

-	RemoveShadowFromLeaves( handle );

-	RemoveShadowFromRenderables( handle );

-

-	Assert( ( m_Shadows[handle].m_Flags & SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK ) == SHADOW_FLAGS_FLASHLIGHT );

-	

-	// This will help us to avoid adding the shadow multiple times to a renderable

-	++m_ShadowEnum;

-

-	for ( int i = 0; i < nLeafCount; ++i )

-	{

-		AddShadowToLeaf( pLeafList[i], handle );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Find all shadow casters in a set of leaves

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::EnumerateShadowsInLeaves( int leafCount, LeafIndex_t* pLeaves, IClientLeafShadowEnum* pEnum )

-{

-	if (leafCount == 0)

-		return;

-

-	// This will help us to avoid enumerating the shadow multiple times

-	++m_ShadowEnum;

-

-	for (int i = 0; i < leafCount; ++i)

-	{

-		int leaf = pLeaves[i];

-

-		unsigned short j = m_ShadowsInLeaf.FirstElement( leaf );

-		while ( j != m_ShadowsInLeaf.InvalidIndex() )

-		{

-			ClientLeafShadowHandle_t shadow = m_ShadowsInLeaf.Element(j);

-			ShadowInfo_t& info = m_Shadows[shadow];

-

-			if (info.m_EnumCount != m_ShadowEnum)

-			{

-				pEnum->EnumShadow(info.m_Shadow);

-				info.m_EnumCount = m_ShadowEnum;

-			}

-

-			j = m_ShadowsInLeaf.NextElement(j);

-		}

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Adds a renderable to a leaf

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::AddRenderableToLeaf( int leaf, ClientRenderHandle_t renderable )

-{

-#ifdef VALIDATE_CLIENT_LEAF_SYSTEM

-	m_RenderablesInLeaf.ValidateAddElementToBucket( leaf, renderable );

-#endif

-	m_RenderablesInLeaf.AddElementToBucket( leaf, renderable );

-

-	if ( !ShouldRenderableReceiveShadow( renderable, SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK ) )

-		return;

-

-	// Add all shadows in the leaf to the renderable...

-	unsigned short i = m_ShadowsInLeaf.FirstElement( leaf );

-	while (i != m_ShadowsInLeaf.InvalidIndex() )

-	{

-		ClientLeafShadowHandle_t shadow = m_ShadowsInLeaf.Element(i);

-		ShadowInfo_t& info = m_Shadows[shadow];

-

-		// Add each shadow exactly once to each renderable

-		if (info.m_EnumCount != m_ShadowEnum)

-		{

-			AddShadowToRenderable( renderable, shadow );

-			info.m_EnumCount = m_ShadowEnum;

-		}

-

-		i = m_ShadowsInLeaf.NextElement(i);

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Adds a renderable to a set of leaves

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::AddRenderableToLeaves( ClientRenderHandle_t handle, int nLeafCount, unsigned short *pLeaves )

-{ 

-	for (int j = 0; j < nLeafCount; ++j)

-	{

-		AddRenderableToLeaf( pLeaves[j], handle ); 

-	}

-	m_Renderables[handle].m_Area = GetRenderableArea( handle );

-}

-

-

-//-----------------------------------------------------------------------------

-// Inserts an element into the tree

-//-----------------------------------------------------------------------------

-bool CClientLeafSystem::EnumerateLeaf( int leaf, int context )

-{

-	EnumResultList_t *pList = (EnumResultList_t *)context;

-	if ( ThreadInMainThread() )

-	{

-		AddRenderableToLeaf( leaf, pList->handle );

-	}

-	else

-	{

-		EnumResult_t *p = new EnumResult_t;

-		p->leaf = leaf;

-		p->pNext = pList->pHead;

-		pList->pHead = p;

-	}

-	return true;

-}

-

-void CClientLeafSystem::InsertIntoTree( ClientRenderHandle_t &handle )

-{

-	if ( ThreadInMainThread() )

-	{

-		// When we insert into the tree, increase the shadow enumerator

-		// to make sure each shadow is added exactly once to each renderable

-		m_ShadowEnum++;

-	}

-

-	EnumResultList_t list = { NULL, handle };

-

-	// NOTE: The render bounds here are relative to the renderable's coordinate system

-	IClientRenderable* pRenderable = m_Renderables[handle].m_pRenderable;

-	Vector absMins, absMaxs;

-	

-	CalcRenderableWorldSpaceAABB_Fast( pRenderable, absMins, absMaxs );

-	Assert( absMins.IsValid() && absMaxs.IsValid() );

-

-	ISpatialQuery* pQuery = engine->GetBSPTreeQuery();

-	pQuery->EnumerateLeavesInBox( absMins, absMaxs, this, (int)&list );

-

-	if ( list.pHead )

-	{

-		m_DeferredInserts.PushItem( list );

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Removes an element from the tree

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::RemoveFromTree( ClientRenderHandle_t handle )

-{

-	m_RenderablesInLeaf.RemoveElement( handle );

-

-	// Remove all shadows cast onto the object

-	m_ShadowsOnRenderable.RemoveBucket( handle );

-

-	// If the renderable is a brush model, then remove all shadows from it

-	if (m_Renderables[handle].m_Flags & RENDER_FLAGS_BRUSH_MODEL)

-	{

-		g_pClientShadowMgr->RemoveAllShadowsFromReceiver( 

-			m_Renderables[handle].m_pRenderable, SHADOW_RECEIVER_BRUSH_MODEL );

-	}

-	else if( m_Renderables[handle].m_Flags & RENDER_FLAGS_STUDIO_MODEL )

-	{

-		g_pClientShadowMgr->RemoveAllShadowsFromReceiver( 

-			m_Renderables[handle].m_pRenderable, SHADOW_RECEIVER_STUDIO_MODEL );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Call this when the renderable moves

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::RenderableChanged( ClientRenderHandle_t handle )

-{

-	Assert ( handle != INVALID_CLIENT_RENDER_HANDLE );

-	Assert( m_Renderables.IsValidIndex( handle ) );

-	if ( !m_Renderables.IsValidIndex( handle ) )

-		return;

-

-	if ( (m_Renderables[handle].m_Flags & RENDER_FLAGS_HASCHANGED ) == 0 )

-	{

-		m_Renderables[handle].m_Flags |= RENDER_FLAGS_HASCHANGED;

-		m_DirtyRenderables.AddToTail( handle );

-	}

-#if _DEBUG

-	else

-	{

-		// It had better be in the list

-		Assert( m_DirtyRenderables.Find( handle ) != m_DirtyRenderables.InvalidIndex() );

-	}

-#endif

-}

-

-

-//-----------------------------------------------------------------------------

-// Returns if it's a view model render group

-//-----------------------------------------------------------------------------

-inline bool CClientLeafSystem::IsViewModelRenderGroup( RenderGroup_t group ) const

-{

-	return (group == RENDER_GROUP_VIEW_MODEL_TRANSLUCENT) || (group == RENDER_GROUP_VIEW_MODEL_OPAQUE);

-}

-

-

-//-----------------------------------------------------------------------------

-// Adds, removes renderables from view model list

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::AddToViewModelList( ClientRenderHandle_t handle )

-{

-	MEM_ALLOC_CREDIT();

-	Assert( m_ViewModels.Find( handle ) == m_ViewModels.InvalidIndex() );

-	m_ViewModels.AddToTail( handle );

-}

-

-void CClientLeafSystem::RemoveFromViewModelList( ClientRenderHandle_t handle )

-{

-	int i = m_ViewModels.Find( handle );

-	Assert( i != m_ViewModels.InvalidIndex() );

-	m_ViewModels.FastRemove( i );

-}

-

-

-//-----------------------------------------------------------------------------

-// Call this to change the render group

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::SetRenderGroup( ClientRenderHandle_t handle, RenderGroup_t group )

-{

-	RenderableInfo_t *pInfo = &m_Renderables[handle];

-

-	bool twoPass = false;

-	if ( group == RENDER_GROUP_TWOPASS )

-	{

-		twoPass = true;

-		group = RENDER_GROUP_TRANSLUCENT_ENTITY;

-	}

-

-	if ( twoPass )

-	{

-		pInfo->m_Flags |= RENDER_FLAGS_TWOPASS;

-	}

-	else

-	{

-		pInfo->m_Flags &= ~RENDER_FLAGS_TWOPASS;

-	}

-

-	bool bOldViewModelRenderGroup = IsViewModelRenderGroup( (RenderGroup_t)pInfo->m_RenderGroup );

-	bool bNewViewModelRenderGroup = IsViewModelRenderGroup( group );

-	if ( bOldViewModelRenderGroup != bNewViewModelRenderGroup )

-	{

-		if ( bOldViewModelRenderGroup )

-		{

-			RemoveFromViewModelList( handle );

-		}

-		else 

-		{

-			AddToViewModelList( handle );

-		}

-	}

-

-	pInfo->m_RenderGroup = group;

-

-}

-

-

-//-----------------------------------------------------------------------------

-// Detail system marks 

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::DrawDetailObjectsInLeaf( int leaf, int nFrameNumber, int& nFirstDetailObject, int& nDetailObjectCount )

-{

-	ClientLeaf_t &leafInfo = m_Leaf[leaf];

-	leafInfo.m_DetailPropRenderFrame = nFrameNumber;

-	nFirstDetailObject = leafInfo.m_FirstDetailProp;

-	nDetailObjectCount = leafInfo.m_DetailPropCount;

-}

-

-

-//-----------------------------------------------------------------------------

-// Are we close enough to this leaf to draw detail props *and* are there any props in the leaf?

-//-----------------------------------------------------------------------------

-bool CClientLeafSystem::ShouldDrawDetailObjectsInLeaf( int leaf, int frameNumber )

-{

-	ClientLeaf_t &leafInfo = m_Leaf[leaf];

-	return ( (leafInfo.m_DetailPropRenderFrame == frameNumber ) &&

-			 ( ( leafInfo.m_DetailPropCount != 0 ) || ( leafInfo.m_pSubSystemData[CLSUBSYSTEM_DETAILOBJECTS] ) ) );

-}

-

-

-//-----------------------------------------------------------------------------

-// Compute which leaf the translucent renderables should render in

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::ComputeTranslucentRenderLeaf( int count, const LeafIndex_t *pLeafList, const LeafFogVolume_t *pLeafFogVolumeList, int frameNumber, int viewID )

-{

-	ASSERT_NO_REENTRY();

-	VPROF_BUDGET( "CClientLeafSystem::ComputeTranslucentRenderLeaf", "ComputeTranslucentRenderLeaf"  );

-

-	#define LeafToMarker( leaf ) reinterpret_cast<RenderableInfo_t *>(( (leaf) << 1 ) | 1)

-	#define IsLeafMarker( p ) (bool)((reinterpret_cast<size_t>(p)) & 1)

-	#define MarkerToLeaf( p ) (int)((reinterpret_cast<size_t>(p)) >> 1)

-

-	// For better sorting, we're gonna choose the leaf that is closest to the camera.

-	// The leaf list passed in here is sorted front to back

-	bool bThreaded = false;//( cl_threaded_client_leaf_system.GetBool() && g_pThreadPool->NumThreads() );

-	int globalFrameCount = gpGlobals->framecount;

-	int i;

-

-	static CUtlVector<RenderableInfo_t *> orderedList; // @MULTICORE (toml 8/30/2006): will need to make non-static if thread this function

-	static CUtlVector<IClientRenderable *> renderablesToUpdate;

-	int leaf = 0;

-	for ( i = 0; i < count; ++i )

-	{

-		leaf = pLeafList[i];

-		orderedList.AddToTail( LeafToMarker( leaf ) );

-

-		// iterate over all elements in this leaf

-		unsigned short idx = m_RenderablesInLeaf.FirstElement(leaf);

-		while (idx != m_RenderablesInLeaf.InvalidIndex())

-		{

-			RenderableInfo_t& info = m_Renderables[m_RenderablesInLeaf.Element(idx)];

-			if ( info.m_TranslucencyCalculated != globalFrameCount || info.m_TranslucencyCalculatedView != viewID )

-			{ 

-				// Compute translucency

-				if ( bThreaded )

-				{

-					renderablesToUpdate.AddToTail( info.m_pRenderable );

-				}

-				else

-				{

-					info.m_pRenderable->ComputeFxBlend();

-				}

-				info.m_TranslucencyCalculated = globalFrameCount;

-				info.m_TranslucencyCalculatedView = viewID;

-			}

-			orderedList.AddToTail( &info );

-			idx = m_RenderablesInLeaf.NextElement(idx); 

-		}

-	}

-

-	if ( bThreaded )

-	{

-		ParallelProcess( "CClientLeafSystem::ComputeTranslucentRenderLeaf", renderablesToUpdate.Base(), renderablesToUpdate.Count(), &CallComputeFXBlend, &::FrameLock, &::FrameUnlock );

-		renderablesToUpdate.RemoveAll();

-	}

-

-	for ( i = 0; i != orderedList.Count(); i++ )

-	{

-		RenderableInfo_t *pInfo = orderedList[i];

-		if ( !IsLeafMarker( pInfo ) )

-		{

-			if( pInfo->m_RenderFrame != frameNumber )

-			{   

-				if( pInfo->m_RenderGroup == RENDER_GROUP_TRANSLUCENT_ENTITY )

-				{

-					pInfo->m_RenderLeaf = leaf;

-				}

-				pInfo->m_RenderFrame = frameNumber;

-			}

-			else if ( pInfo->m_Flags & RENDER_FLAGS_ALTERNATE_SORTING )

-			{

-				if( pInfo->m_RenderGroup == RENDER_GROUP_TRANSLUCENT_ENTITY )

-				{

-					pInfo->m_RenderLeaf = leaf;

-				}

-			}

-

-		}

-		else

-		{

-			leaf = MarkerToLeaf( pInfo );

-		}

-	}

-

-	orderedList.RemoveAll();

-}

-

-

-//-----------------------------------------------------------------------------

-// Adds a renderable to the list of renderables to render this frame

-//-----------------------------------------------------------------------------

-inline void AddRenderableToRenderList( CClientRenderablesList &renderList, IClientRenderable *pRenderable, 

-	int iLeaf, RenderGroup_t group,	ClientRenderHandle_t renderHandle, bool bTwoPass = false )

-{

-#ifdef _DEBUG

-	if (cl_drawleaf.GetInt() >= 0)

-	{

-		if (iLeaf != cl_drawleaf.GetInt())

-			return;

-	}

-#endif

-

-	Assert( group >= 0 && group < RENDER_GROUP_COUNT );

-	

-	int &curCount = renderList.m_RenderGroupCounts[group];

-	if ( curCount < CClientRenderablesList::MAX_GROUP_ENTITIES )

-	{

-		Assert( (iLeaf >= 0) && (iLeaf <= 65535) );

-

-		CClientRenderablesList::CEntry *pEntry = &renderList.m_RenderGroups[group][curCount];

-		pEntry->m_pRenderable = pRenderable;

-		pEntry->m_iWorldListInfoLeaf = iLeaf;

-		pEntry->m_TwoPass = bTwoPass;

-		pEntry->m_RenderHandle = renderHandle;

-		curCount++;

-	}

-	else

-	{

-		engine->Con_NPrintf( 10, "Warning: overflowed CClientRenderablesList group %d", group );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : renderList - 

-//			renderGroup - 

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::CollateViewModelRenderables( CUtlVector< IClientRenderable * >& opaque, CUtlVector< IClientRenderable * >& translucent )

-{

-	for ( int i = m_ViewModels.Count()-1; i >= 0; --i )

-	{

-		ClientRenderHandle_t handle = m_ViewModels[i];

-		RenderableInfo_t& renderable = m_Renderables[handle];

-

-		// NOTE: In some cases, this removes the entity from the view model list

-		renderable.m_pRenderable->ComputeFxBlend();

-		

-		// That's why we need to test RENDER_GROUP_OPAQUE_ENTITY - it may have changed in ComputeFXBlend()

-		if ( renderable.m_RenderGroup == RENDER_GROUP_VIEW_MODEL_OPAQUE || renderable.m_RenderGroup == RENDER_GROUP_OPAQUE_ENTITY )

-		{

-			opaque.AddToTail( renderable.m_pRenderable );

-		}

-		else

-		{

-			translucent.AddToTail( renderable.m_pRenderable );

-		}

-	}

-}

-

-static RenderGroup_t DetectBucketedRenderGroup( RenderGroup_t group, float fDimension )

-{

-	float const arrThresholds[ 3 ] = {

-		200.f,	// tree size

-		80.f,	// player size

-		30.f,	// crate size

-	};

-	Assert( ARRAYSIZE( arrThresholds ) + 1 >= RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS );

-	Assert( group >= RENDER_GROUP_OPAQUE_STATIC && group <= RENDER_GROUP_OPAQUE_ENTITY );

-

-	int bucketedGroupIndex;

-	if ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS <= 2 ||

-		fDimension >= arrThresholds[1] )

-	{

-		if ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS <= 1 ||

-			fDimension >= arrThresholds[0] )

-			bucketedGroupIndex = 0;

-		else

-			bucketedGroupIndex = 1;

-	}

-	else

-	{

-		if ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS <= 3 ||

-			fDimension >= arrThresholds[2] )

-			bucketedGroupIndex = 2;

-		else

-			bucketedGroupIndex = 3;

-	}

-

-	// Determine the new bucketed group

-	RenderGroup_t bucketedGroup = RenderGroup_t( group - ( ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS - 1 ) - bucketedGroupIndex ) * 2 );

-	Assert( bucketedGroup >= RENDER_GROUP_OPAQUE_STATIC_HUGE && bucketedGroup <= RENDER_GROUP_OPAQUE_ENTITY );

-	

-	return bucketedGroup;

-}

-

-void CClientLeafSystem::CollateRenderablesInLeaf( int leaf, int worldListLeafIndex,	const SetupRenderInfo_t &info )

-{

-	bool portalTestEnts = r_PortalTestEnts.GetBool() && !r_portalsopenall.GetBool();

-	

-	// Place a fake entity for static/opaque ents in this leaf

-	AddRenderableToRenderList( *info.m_pRenderList, NULL, worldListLeafIndex, RENDER_GROUP_OPAQUE_STATIC, NULL );

-	AddRenderableToRenderList( *info.m_pRenderList, NULL, worldListLeafIndex, RENDER_GROUP_OPAQUE_ENTITY, NULL );

-

-	// Collate everything.

-	unsigned short idx = m_RenderablesInLeaf.FirstElement(leaf);

-	for ( ;idx != m_RenderablesInLeaf.InvalidIndex(); idx = m_RenderablesInLeaf.NextElement(idx) )

-	{

-		ClientRenderHandle_t handle = m_RenderablesInLeaf.Element(idx);

-		RenderableInfo_t& renderable = m_Renderables[handle];

-

-		// Early out on static props if we don't want to render them

-		if ((!m_DrawStaticProps) && (renderable.m_Flags & RENDER_FLAGS_STATIC_PROP))

-			continue;

-

-		// Early out if we're told to not draw small objects (top view only,

-		/* that's why we don't check the z component).

-		if (!m_DrawSmallObjects)

-		{

-			CCachedRenderInfo& cachedInfo =  m_CachedRenderInfos[renderable.m_CachedRenderInfo];

-			float sizeX = cachedInfo.m_Maxs.x - cachedInfo.m_Mins.x;

-			float sizeY = cachedInfo.m_Maxs.y - cachedInfo.m_Mins.y;

-			if ((sizeX < 50.f) && (sizeY < 50.f))

-				continue;

-		}*/

-

-		Assert( m_DrawSmallObjects ); // MOTODO

-

-		// Don't hit the same ent in multiple leaves twice.

-		if ( renderable.m_RenderGroup != RENDER_GROUP_TRANSLUCENT_ENTITY )

-		{

-			if ( renderable.m_RenderFrame2 == info.m_nRenderFrame )

-				continue;

-

-			renderable.m_RenderFrame2 = info.m_nRenderFrame;

-		}

-		else // translucent

-		{

-			// Shadow depth skips ComputeTranslucentRenderLeaf!

-

-			// Translucent entities already have had ComputeTranslucentRenderLeaf called on them

-			// so m_RenderLeaf should be set to the nearest leaf, so that's what we want here.

-			if ( renderable.m_RenderLeaf != leaf )

-				continue;

-		}

-

-		unsigned char nAlpha = 255;

-		if ( info.m_bDrawTranslucentObjects ) 

-		{

-			// Prevent culling if the renderable is invisible

-			// NOTE: OPAQUE objects can have alpha == 0. 

-			// They are made to be opaque because they don't have to be sorted.

-			nAlpha = renderable.m_pRenderable->GetFxBlend();

-			if ( nAlpha == 0 )

-				continue;

-		}

-

-		Vector absMins, absMaxs;

-		CalcRenderableWorldSpaceAABB( renderable.m_pRenderable, absMins, absMaxs );

-		// If the renderable is inside an area, cull it using the frustum for that area.

-		if ( portalTestEnts && renderable.m_Area != -1 )

-		{

-			VPROF( "r_PortalTestEnts" );

-			if ( !engine->DoesBoxTouchAreaFrustum( absMins, absMaxs, renderable.m_Area ) )

-				continue;

-		}

-		else

-		{

-			// cull with main frustum

-			if ( engine->CullBox( absMins, absMaxs ) )

-				continue;

-		}

-

-		// UNDONE: Investigate speed tradeoffs of occlusion culling brush models too?

-		if ( renderable.m_Flags & RENDER_FLAGS_STUDIO_MODEL )

-		{

-			// test to see if this renderable is occluded by the engine's occlusion system

-			if ( engine->IsOccluded( absMins, absMaxs ) )

-				continue;

-		}

-

-#ifdef INVASION_CLIENT_DLL

-		if (info.m_flRenderDistSq != 0.0f)

-		{

-			Vector mins, maxs;

-			renderable.m_pRenderable->GetRenderBounds( mins, maxs );

-

-			if ((maxs.z - mins.z) < 100)

-			{

-				Vector vCenter;

-				VectorLerp( mins, maxs, 0.5f, vCenter );

-				vCenter += renderable.m_pRenderable->GetRenderOrigin();

-

-				float flDistSq = info.m_vecRenderOrigin.DistToSqr( vCenter );

-				if (info.m_flRenderDistSq <= flDistSq)

-					continue;

-			}

-		}

-#endif

-

-		if( renderable.m_RenderGroup != RENDER_GROUP_TRANSLUCENT_ENTITY )

-		{

-			RenderGroup_t group = (RenderGroup_t)renderable.m_RenderGroup;

-

-			// Determine object group offset

-			if ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS > 1 &&

-				 group >= RENDER_GROUP_OPAQUE_STATIC &&

-				 group <= RENDER_GROUP_OPAQUE_ENTITY )

-			{

-				Vector dims;

-				VectorSubtract( absMaxs, absMins, dims );

-

-				float const fDimension = MAX( MAX( fabs(dims.x), fabs(dims.y) ), fabs(dims.z) );

-				group = DetectBucketedRenderGroup( group, fDimension );

-				

-				Assert( group >= RENDER_GROUP_OPAQUE_STATIC_HUGE && group <= RENDER_GROUP_OPAQUE_ENTITY );

-			}

-

-			AddRenderableToRenderList( *info.m_pRenderList, renderable.m_pRenderable, 

-				worldListLeafIndex, group, handle);

-		}

-		else

-		{

-			bool bTwoPass = ((renderable.m_Flags & RENDER_FLAGS_TWOPASS) != 0) && ( nAlpha == 255 );	// Two pass?

-

-			// Add to appropriate list if drawing translucent objects (shadow depth mapping will skip this)

-			if ( info.m_bDrawTranslucentObjects ) 

-			{

-				AddRenderableToRenderList( *info.m_pRenderList, renderable.m_pRenderable, 

-					worldListLeafIndex, (RenderGroup_t)renderable.m_RenderGroup, handle, bTwoPass );

-			}

-			

-			if ( bTwoPass )	// Also add to opaque list if it's a two-pass model... 

-			{

-				AddRenderableToRenderList( *info.m_pRenderList, renderable.m_pRenderable, 

-					worldListLeafIndex, RENDER_GROUP_OPAQUE_ENTITY, handle, bTwoPass );

-			}

-		}

-	}

-

-	// Do detail objects.

-	// These don't have render handles!

-	if ( info.m_bDrawDetailObjects && ShouldDrawDetailObjectsInLeaf( leaf, info.m_nDetailBuildFrame ) )

-	{

-		idx = m_Leaf[leaf].m_FirstDetailProp;

-		int count = m_Leaf[leaf].m_DetailPropCount;

-		while( --count >= 0 )

-		{

-			IClientRenderable* pRenderable = DetailObjectSystem()->GetDetailModel(idx);

-

-			// FIXME: This if check here is necessary because the detail object system also maintains lists of sprites...

-			if (pRenderable)

-			{

-				if( pRenderable->IsTransparent() )

-				{

-					if ( info.m_bDrawTranslucentObjects )	// Don't draw translucent objects into shadow depth maps

-					{

-						// Lots of the detail entities are invisible so avoid sorting them and all that.

-						if( pRenderable->GetFxBlend() > 0 )

-						{

-							AddRenderableToRenderList( *info.m_pRenderList, pRenderable, 

-								worldListLeafIndex, RENDER_GROUP_TRANSLUCENT_ENTITY, DETAIL_PROP_RENDER_HANDLE );

-						}

-					}

-				}

-				else

-				{

-					AddRenderableToRenderList( *info.m_pRenderList, pRenderable, 

-						worldListLeafIndex, RENDER_GROUP_OPAQUE_ENTITY, DETAIL_PROP_RENDER_HANDLE );

-				}

-			}

-			++idx;

-		}

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Sort entities in a back-to-front ordering

-//-----------------------------------------------------------------------------

-void CClientLeafSystem::SortEntities( const Vector &vecRenderOrigin, const Vector &vecRenderForward, CClientRenderablesList::CEntry *pEntities, int nEntities )

-{

-	// Don't sort if we only have 1 entity

-	if ( nEntities <= 1 )

-		return;

-

-	float dists[CClientRenderablesList::MAX_GROUP_ENTITIES];

-

-	// First get a distance for each entity.

-	int i;

-	for( i=0; i < nEntities; i++ )

-	{

-		IClientRenderable *pRenderable = pEntities[i].m_pRenderable;

-

-		// Compute the center of the object (needed for translucent brush models)

-		Vector boxcenter;

-		Vector mins,maxs;

-		pRenderable->GetRenderBounds( mins, maxs );

-		VectorAdd( mins, maxs, boxcenter );

-		VectorMA( pRenderable->GetRenderOrigin(), 0.5f, boxcenter, boxcenter );

-

-		// Compute distance...

-		Vector delta;

-		VectorSubtract( boxcenter, vecRenderOrigin, delta );

-		dists[i] = DotProduct( delta, vecRenderForward );

-	}

-

-	// H-sort.

-	int stepSize = 4;

-	while( stepSize )

-	{

-		int end = nEntities - stepSize;

-		for( i=0; i < end; i += stepSize )

-		{

-			if( dists[i] > dists[i+stepSize] )

-			{

-				::V_swap( pEntities[i], pEntities[i+stepSize] );

-				::V_swap( dists[i], dists[i+stepSize] );

-

-				if( i == 0 )

-				{

-					i = -stepSize;

-				}

-				else

-				{

-					i -= stepSize << 1;

-				}

-			}

-		}

-

-		stepSize >>= 1;

-	}

-}

-

-

-void CClientLeafSystem::BuildRenderablesList( const SetupRenderInfo_t &info )

-{

-	VPROF_BUDGET( "BuildRenderablesList", "BuildRenderablesList" );

-	int leafCount = info.m_pWorldListInfo->m_LeafCount;

-	const Vector &vecRenderOrigin = info.m_vecRenderOrigin;

-	const Vector &vecRenderForward = info.m_vecRenderForward;

-	CClientRenderablesList::CEntry *pTranslucentEntries = info.m_pRenderList->m_RenderGroups[RENDER_GROUP_TRANSLUCENT_ENTITY];

-	int &nTranslucentEntries = info.m_pRenderList->m_RenderGroupCounts[RENDER_GROUP_TRANSLUCENT_ENTITY];

-

-	for( int i = 0; i < leafCount; i++ )

-	{

-		int nTranslucent = nTranslucentEntries;

-

-		// Add renderables from this leaf...

-		CollateRenderablesInLeaf( info.m_pWorldListInfo->m_pLeafList[i], i, info );

-

-		int nNewTranslucent = nTranslucentEntries - nTranslucent;

-		if( (nNewTranslucent != 0 ) && info.m_bDrawTranslucentObjects )

-		{

-			// Sort the new translucent entities.

-			SortEntities( vecRenderOrigin, vecRenderForward, &pTranslucentEntries[nTranslucent], nNewTranslucent );

-		}

-	}

-}

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Revision: $
+// $NoKeywords: $
+//
+// This file contains code to allow us to associate client data with bsp leaves.
+//===========================================================================//
+
+#include "cbase.h"
+#include "clientleafsystem.h"
+#include "utlbidirectionalset.h"
+#include "model_types.h"
+#include "ivrenderview.h"
+#include "tier0/vprof.h"
+#include "bsptreedata.h"
+#include "detailobjectsystem.h"
+#include "engine/IStaticPropMgr.h"
+#include "engine/ivdebugoverlay.h"
+#include "vstdlib/jobthread.h"
+#include "tier1/utllinkedlist.h"
+#include "datacache/imdlcache.h"
+#include "view.h"
+#include "viewrender.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+class VMatrix;  // forward decl
+
+static ConVar cl_drawleaf("cl_drawleaf", "-1", FCVAR_CHEAT );
+static ConVar r_PortalTestEnts( "r_PortalTestEnts", "1", FCVAR_CHEAT, "Clip entities against portal frustums." );
+static ConVar r_portalsopenall( "r_portalsopenall", "0", FCVAR_CHEAT, "Open all portals" );
+static ConVar cl_threaded_client_leaf_system("cl_threaded_client_leaf_system", "0"  );
+
+
+DEFINE_FIXEDSIZE_ALLOCATOR( CClientRenderablesList, 1, CUtlMemoryPool::GROW_SLOW );
+
+//-----------------------------------------------------------------------------
+// Threading helpers
+//-----------------------------------------------------------------------------
+
+static void FrameLock()
+{
+	mdlcache->BeginLock();
+}
+
+static void FrameUnlock()
+{
+	mdlcache->EndLock();
+}
+
+static void CallComputeFXBlend( IClientRenderable *&pRenderable )
+{
+	pRenderable->ComputeFxBlend();
+}
+
+//-----------------------------------------------------------------------------
+// The client leaf system
+//-----------------------------------------------------------------------------
+class CClientLeafSystem : public IClientLeafSystem, public ISpatialLeafEnumerator
+{
+public:
+	virtual char const *Name() { return "CClientLeafSystem"; }
+
+	// constructor, destructor
+	CClientLeafSystem();
+	virtual ~CClientLeafSystem();
+
+	// Methods of IClientSystem
+	bool Init() { return true; }
+	void PostInit() {}
+	void Shutdown() {}
+
+	virtual bool IsPerFrame() { return true; }
+
+	void PreRender();
+	void PostRender() { }
+	void Update( float frametime ) { }
+
+	void LevelInitPreEntity();
+	void LevelInitPostEntity() {}
+	void LevelShutdownPreEntity();
+	void LevelShutdownPostEntity();
+
+	virtual void OnSave() {}
+	virtual void OnRestore() {}
+	virtual void SafeRemoveIfDesired() {}
+
+// Methods of IClientLeafSystem
+public:
+	
+	virtual void AddRenderable( IClientRenderable* pRenderable, RenderGroup_t group );
+	virtual bool IsRenderableInPVS( IClientRenderable *pRenderable );
+	virtual void CreateRenderableHandle( IClientRenderable* pRenderable, bool bIsStaticProp );
+	virtual void RemoveRenderable( ClientRenderHandle_t handle );
+
+
+	virtual void SetSubSystemDataInLeaf( int leaf, int nSubSystemIdx, CClientLeafSubSystemData *pData );
+	virtual CClientLeafSubSystemData *GetSubSystemDataInLeaf( int leaf, int nSubSystemIdx );
+
+	// FIXME: There's an incestuous relationship between DetailObjectSystem
+	// and the ClientLeafSystem. Maybe they should be the same system?
+	virtual void GetDetailObjectsInLeaf( int leaf, int& firstDetailObject, int& detailObjectCount );
+ 	virtual void SetDetailObjectsInLeaf( int leaf, int firstDetailObject, int detailObjectCount );
+	virtual void DrawDetailObjectsInLeaf( int leaf, int frameNumber, int& nFirstDetailObject, int& nDetailObjectCount );
+	virtual bool ShouldDrawDetailObjectsInLeaf( int leaf, int frameNumber );
+	virtual void RenderableChanged( ClientRenderHandle_t handle );
+	virtual void SetRenderGroup( ClientRenderHandle_t handle, RenderGroup_t group );
+	virtual void ComputeTranslucentRenderLeaf( int count, const LeafIndex_t *pLeafList, const LeafFogVolume_t *pLeafFogVolumeList, int frameNumber, int viewID );
+	virtual void CollateViewModelRenderables( CUtlVector< IClientRenderable * >& opaque, CUtlVector< IClientRenderable * >& translucent );
+	virtual void BuildRenderablesList( const SetupRenderInfo_t &info );
+			void CollateRenderablesInLeaf( int leaf, int worldListLeafIndex, const SetupRenderInfo_t &info );
+	virtual void DrawStaticProps( bool enable );
+	virtual void DrawSmallEntities( bool enable );
+	virtual void EnableAlternateSorting( ClientRenderHandle_t handle, bool bEnable );
+
+	// Adds a renderable to a set of leaves
+	virtual void AddRenderableToLeaves( ClientRenderHandle_t handle, int nLeafCount, unsigned short *pLeaves );
+
+	// The following methods are related to shadows...
+	virtual ClientLeafShadowHandle_t AddShadow( ClientShadowHandle_t userId, unsigned short flags );
+	virtual void RemoveShadow( ClientLeafShadowHandle_t h );
+
+	virtual void ProjectShadow( ClientLeafShadowHandle_t handle, int nLeafCount, const int *pLeafList );
+	virtual void ProjectFlashlight( ClientLeafShadowHandle_t handle, int nLeafCount, const int *pLeafList );
+
+	// Find all shadow casters in a set of leaves
+	virtual void EnumerateShadowsInLeaves( int leafCount, LeafIndex_t* pLeaves, IClientLeafShadowEnum* pEnum );
+
+	// methods of ISpatialLeafEnumerator
+public:
+
+	bool EnumerateLeaf( int leaf, int context );
+
+	// Adds a shadow to a leaf
+	void AddShadowToLeaf( int leaf, ClientLeafShadowHandle_t handle );
+
+	// Fill in a list of the leaves this renderable is in.
+	// Returns -1 if the handle is invalid.
+	int GetRenderableLeaves( ClientRenderHandle_t handle, int leaves[128] );
+
+	// Get leaves this renderable is in
+	virtual bool GetRenderableLeaf ( ClientRenderHandle_t handle, int* pOutLeaf, const int* pInIterator = 0, int* pOutIterator = 0 );
+
+	// Singleton instance...
+	static CClientLeafSystem s_ClientLeafSystem;
+
+private:
+	// Creates a new renderable
+	void NewRenderable( IClientRenderable* pRenderable, RenderGroup_t type, int flags = 0 );
+
+	// Adds a renderable to the list of renderables
+	void AddRenderableToLeaf( int leaf, ClientRenderHandle_t handle );
+
+	void SortEntities(  const Vector &vecRenderOrigin, const Vector &vecRenderForward, CClientRenderablesList::CEntry *pEntities, int nEntities );
+
+	// Returns -1 if the renderable spans more than one area. If it's totally in one area, then this returns the leaf.
+	short GetRenderableArea( ClientRenderHandle_t handle );
+
+	// remove renderables from leaves
+	void InsertIntoTree( ClientRenderHandle_t &handle );
+	void RemoveFromTree( ClientRenderHandle_t handle );
+
+	// Returns if it's a view model render group
+	inline bool IsViewModelRenderGroup( RenderGroup_t group ) const;
+
+	// Adds, removes renderables from view model list
+	void AddToViewModelList( ClientRenderHandle_t handle );
+	void RemoveFromViewModelList( ClientRenderHandle_t handle );
+
+	// Insert translucent renderables into list of translucent objects
+	void InsertTranslucentRenderable( IClientRenderable* pRenderable,
+		int& count, IClientRenderable** pList, float* pDist );
+
+	// Used to change renderables from translucent to opaque
+	// Only really used by the static prop fading...
+	void ChangeRenderableRenderGroup( ClientRenderHandle_t handle, RenderGroup_t group );
+
+	// Adds a shadow to a leaf/removes shadow from renderable
+	void AddShadowToRenderable( ClientRenderHandle_t renderHandle, ClientLeafShadowHandle_t shadowHandle );
+	void RemoveShadowFromRenderables( ClientLeafShadowHandle_t handle );
+
+	// Adds a shadow to a leaf/removes shadow from renderable
+	bool ShouldRenderableReceiveShadow( ClientRenderHandle_t renderHandle, int nShadowFlags );
+
+	// Adds a shadow to a leaf/removes shadow from leaf
+	void RemoveShadowFromLeaves( ClientLeafShadowHandle_t handle );
+
+	// Methods associated with the various bi-directional sets
+	static unsigned short& FirstRenderableInLeaf( int leaf ) 
+	{ 
+		return s_ClientLeafSystem.m_Leaf[leaf].m_FirstElement;
+	}
+
+	static unsigned short& FirstLeafInRenderable( unsigned short renderable ) 
+	{ 
+		return s_ClientLeafSystem.m_Renderables[renderable].m_LeafList;
+	}
+
+	static unsigned short& FirstShadowInLeaf( int leaf ) 
+	{ 
+		return s_ClientLeafSystem.m_Leaf[leaf].m_FirstShadow;
+	}
+
+	static unsigned short& FirstLeafInShadow( ClientLeafShadowHandle_t shadow ) 
+	{ 
+		return s_ClientLeafSystem.m_Shadows[shadow].m_FirstLeaf;
+	}
+
+	static unsigned short& FirstShadowOnRenderable( unsigned short renderable ) 
+	{ 
+		return s_ClientLeafSystem.m_Renderables[renderable].m_FirstShadow;
+	}
+
+	static unsigned short& FirstRenderableInShadow( ClientLeafShadowHandle_t shadow ) 
+	{ 
+		return s_ClientLeafSystem.m_Shadows[shadow].m_FirstRenderable;
+	}
+
+	void FrameLock()
+	{
+		mdlcache->BeginLock();
+	}
+
+	void FrameUnlock()
+	{
+		mdlcache->EndLock();
+	}
+
+private:
+	enum
+	{
+		RENDER_FLAGS_TWOPASS		= 0x01,
+		RENDER_FLAGS_STATIC_PROP	= 0x02,
+		RENDER_FLAGS_BRUSH_MODEL	= 0x04,
+		RENDER_FLAGS_STUDIO_MODEL	= 0x08,
+		RENDER_FLAGS_HASCHANGED		= 0x10,
+		RENDER_FLAGS_ALTERNATE_SORTING = 0x20,
+	};
+
+	// All the information associated with a particular handle
+	struct RenderableInfo_t
+	{
+		IClientRenderable*	m_pRenderable;
+		int					m_RenderFrame;	// which frame did I render it in?
+		int					m_RenderFrame2;
+		int					m_EnumCount;	// Have I been added to a particular shadow yet?
+		int					m_TranslucencyCalculated;
+		unsigned short		m_LeafList;		// What leafs is it in?
+		unsigned short		m_RenderLeaf;	// What leaf do I render in?
+		unsigned char		m_Flags;		// rendering flags
+		unsigned char		m_RenderGroup;	// RenderGroup_t type
+		unsigned short		m_FirstShadow;	// The first shadow caster that cast on it
+		short m_Area;	// -1 if the renderable spans multiple areas.
+		signed char			m_TranslucencyCalculatedView;
+	};
+
+	// The leaf contains an index into a list of renderables
+	struct ClientLeaf_t
+	{
+		unsigned short	m_FirstElement;
+		unsigned short	m_FirstShadow;
+
+		unsigned short	m_FirstDetailProp;
+		unsigned short	m_DetailPropCount;
+		int				m_DetailPropRenderFrame;
+		CClientLeafSubSystemData *m_pSubSystemData[N_CLSUBSYSTEMS];
+
+	};
+
+	// Shadow information
+	struct ShadowInfo_t
+	{
+		unsigned short	m_FirstLeaf;
+		unsigned short	m_FirstRenderable;
+		int				m_EnumCount;
+		ClientShadowHandle_t	m_Shadow;
+		unsigned short	m_Flags;
+	};
+
+	struct EnumResult_t
+	{
+		int leaf;
+		EnumResult_t *pNext;
+	};
+
+	struct EnumResultList_t
+	{
+		EnumResult_t *pHead;
+		ClientRenderHandle_t handle;
+	};
+
+	// Stores data associated with each leaf.
+	CUtlVector< ClientLeaf_t >	m_Leaf;
+
+	// Stores all unique non-detail renderables
+	CUtlLinkedList< RenderableInfo_t, ClientRenderHandle_t, false, unsigned int >	m_Renderables;
+
+	// Information associated with shadows registered with the client leaf system
+	CUtlLinkedList< ShadowInfo_t, ClientLeafShadowHandle_t, false, unsigned int >	m_Shadows;
+
+	// Maintains the list of all renderables in a particular leaf
+	CBidirectionalSet< int, ClientRenderHandle_t, unsigned short, unsigned int >	m_RenderablesInLeaf;
+
+	// Maintains a list of all shadows in a particular leaf 
+	CBidirectionalSet< int, ClientLeafShadowHandle_t, unsigned short, unsigned int >	m_ShadowsInLeaf;
+
+	// Maintains a list of all shadows cast on a particular renderable
+	CBidirectionalSet< ClientRenderHandle_t, ClientLeafShadowHandle_t, unsigned short, unsigned int >	m_ShadowsOnRenderable;
+
+	// Dirty list of renderables
+	CUtlVector< ClientRenderHandle_t >	m_DirtyRenderables;
+
+	// List of renderables in view model render groups
+	CUtlVector< ClientRenderHandle_t >	m_ViewModels;
+
+	// Should I draw static props?
+	bool m_DrawStaticProps;
+	bool m_DrawSmallObjects;
+
+	// A little enumerator to help us when adding shadows to renderables
+	int	m_ShadowEnum;
+
+	CTSList<EnumResultList_t> m_DeferredInserts;
+};
+
+
+//-----------------------------------------------------------------------------
+// Expose IClientLeafSystem to the client dll.
+//-----------------------------------------------------------------------------
+CClientLeafSystem CClientLeafSystem::s_ClientLeafSystem;
+IClientLeafSystem *g_pClientLeafSystem = &CClientLeafSystem::s_ClientLeafSystem;
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CClientLeafSystem, IClientLeafSystem, CLIENTLEAFSYSTEM_INTERFACE_VERSION, CClientLeafSystem::s_ClientLeafSystem );
+
+void CalcRenderableWorldSpaceAABB_Fast( IClientRenderable *pRenderable, Vector &absMin, Vector &absMax );
+
+//-----------------------------------------------------------------------------
+// Helper functions.
+//-----------------------------------------------------------------------------
+void DefaultRenderBoundsWorldspace( IClientRenderable *pRenderable, Vector &absMins, Vector &absMaxs )
+{
+	// Tracker 37433:  This fixes a bug where if the stunstick is being wielded by a combine soldier, the fact that the stick was
+	//  attached to the soldier's hand would move it such that it would get frustum culled near the edge of the screen.
+	C_BaseEntity *pEnt = pRenderable->GetIClientUnknown()->GetBaseEntity();
+	if ( pEnt && pEnt->IsFollowingEntity() )
+	{
+		C_BaseEntity *pParent = pEnt->GetFollowedEntity();
+		if ( pParent )
+		{
+			// Get the parent's abs space world bounds.
+			CalcRenderableWorldSpaceAABB_Fast( pParent, absMins, absMaxs );
+
+			// Add the maximum of our local render bounds. This is making the assumption that we can be at any
+			// point and at any angle within the parent's world space bounds.
+			Vector vAddMins, vAddMaxs;
+			pEnt->GetRenderBounds( vAddMins, vAddMaxs );
+			// if our origin is actually farther away than that, expand again
+			float radius = pEnt->GetLocalOrigin().Length();
+
+			float flBloatSize = MAX( vAddMins.Length(), vAddMaxs.Length() );
+			flBloatSize = MAX(flBloatSize, radius);
+			absMins -= Vector( flBloatSize, flBloatSize, flBloatSize );
+			absMaxs += Vector( flBloatSize, flBloatSize, flBloatSize );
+			return;
+		}
+	}
+
+	Vector mins, maxs;
+	pRenderable->GetRenderBounds( mins, maxs );
+
+	// FIXME: Should I just use a sphere here?
+	// Another option is to pass the OBB down the tree; makes for a better fit
+	// Generate a world-aligned AABB
+	const QAngle& angles = pRenderable->GetRenderAngles();
+	const Vector& origin = pRenderable->GetRenderOrigin();
+	if (angles == vec3_angle)
+	{
+		VectorAdd( mins, origin, absMins );
+		VectorAdd( maxs, origin, absMaxs );
+	}
+	else
+	{
+		matrix3x4_t	boxToWorld;
+		AngleMatrix( angles, origin, boxToWorld );
+		TransformAABB( boxToWorld, mins, maxs, absMins, absMaxs );
+	}
+	Assert( absMins.IsValid() && absMaxs.IsValid() );
+}
+
+// Figure out a world space bounding box that encloses the entity's local render bounds in world space.
+inline void CalcRenderableWorldSpaceAABB( 
+	IClientRenderable *pRenderable, 
+	Vector &absMins,
+	Vector &absMaxs )
+{
+	pRenderable->GetRenderBoundsWorldspace( absMins, absMaxs );
+}
+
+
+// This gets an AABB for the renderable, but it doesn't cause a parent's bones to be setup.
+// This is used for placement in the leaves, but the more expensive version is used for culling.
+void CalcRenderableWorldSpaceAABB_Fast( IClientRenderable *pRenderable, Vector &absMin, Vector &absMax )
+{
+	C_BaseEntity *pEnt = pRenderable->GetIClientUnknown()->GetBaseEntity();
+	if ( pEnt && pEnt->IsFollowingEntity() )
+	{
+		C_BaseEntity *pParent = pEnt->GetMoveParent();
+		Assert( pParent );
+
+		// Get the parent's abs space world bounds.
+		CalcRenderableWorldSpaceAABB_Fast( pParent, absMin, absMax );
+
+		// Add the maximum of our local render bounds. This is making the assumption that we can be at any
+		// point and at any angle within the parent's world space bounds.
+		Vector vAddMins, vAddMaxs;
+		pEnt->GetRenderBounds( vAddMins, vAddMaxs );
+		// if our origin is actually farther away than that, expand again
+		float radius = pEnt->GetLocalOrigin().Length();
+
+		float flBloatSize = MAX( vAddMins.Length(), vAddMaxs.Length() );
+		flBloatSize = MAX(flBloatSize, radius);
+		absMin -= Vector( flBloatSize, flBloatSize, flBloatSize );
+		absMax += Vector( flBloatSize, flBloatSize, flBloatSize );
+	}
+	else
+	{
+		// Start out with our own render bounds. Since we don't have a parent, this won't incur any nasty 
+		CalcRenderableWorldSpaceAABB( pRenderable, absMin, absMax );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// constructor, destructor
+//-----------------------------------------------------------------------------
+CClientLeafSystem::CClientLeafSystem() : m_DrawStaticProps(true), m_DrawSmallObjects(true)
+{
+	// Set up the bi-directional lists...
+	m_RenderablesInLeaf.Init( FirstRenderableInLeaf, FirstLeafInRenderable );
+	m_ShadowsInLeaf.Init( FirstShadowInLeaf, FirstLeafInShadow ); 
+	m_ShadowsOnRenderable.Init( FirstShadowOnRenderable, FirstRenderableInShadow );
+}
+
+CClientLeafSystem::~CClientLeafSystem()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Activate, deactivate static props
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::DrawStaticProps( bool enable )
+{
+	m_DrawStaticProps = enable;
+}
+
+void CClientLeafSystem::DrawSmallEntities( bool enable )
+{
+	m_DrawSmallObjects = enable;
+}
+
+
+//-----------------------------------------------------------------------------
+// Level init, shutdown
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::LevelInitPreEntity()
+{
+	MEM_ALLOC_CREDIT();
+
+	m_Renderables.EnsureCapacity( 1024 );
+	m_RenderablesInLeaf.EnsureCapacity( 1024 );
+	m_ShadowsInLeaf.EnsureCapacity( 256 );
+	m_ShadowsOnRenderable.EnsureCapacity( 256 );
+	m_DirtyRenderables.EnsureCapacity( 256 );
+
+	// Add all the leaves we'll need
+	int leafCount = engine->LevelLeafCount();
+	m_Leaf.EnsureCapacity( leafCount );
+
+	ClientLeaf_t newLeaf;
+	newLeaf.m_FirstElement = m_RenderablesInLeaf.InvalidIndex();
+	newLeaf.m_FirstShadow = m_ShadowsInLeaf.InvalidIndex();
+	memset( newLeaf.m_pSubSystemData, 0, sizeof( newLeaf.m_pSubSystemData ) );
+	newLeaf.m_FirstDetailProp = 0;
+	newLeaf.m_DetailPropCount = 0;
+	newLeaf.m_DetailPropRenderFrame = -1;
+	while ( --leafCount >= 0 )
+	{
+		m_Leaf.AddToTail( newLeaf );
+	}
+}
+
+void CClientLeafSystem::LevelShutdownPreEntity()
+{
+}
+
+void CClientLeafSystem::LevelShutdownPostEntity()
+{
+	m_ViewModels.Purge();
+	m_Renderables.Purge();
+	m_RenderablesInLeaf.Purge();
+	m_Shadows.Purge();
+
+	// delete subsystem data
+	for( int i = 0; i < m_Leaf.Count() ; i++ )
+	{
+		for( int j = 0 ; j < ARRAYSIZE( m_Leaf[i].m_pSubSystemData ) ; j++ )
+		{
+			if ( m_Leaf[i].m_pSubSystemData[j] )
+			{
+				delete m_Leaf[i].m_pSubSystemData[j];
+				m_Leaf[i].m_pSubSystemData[j] = NULL;
+			}
+		}
+	}
+	m_Leaf.Purge();
+	m_ShadowsInLeaf.Purge();
+	m_ShadowsOnRenderable.Purge();
+	m_DirtyRenderables.Purge();
+}
+
+
+//-----------------------------------------------------------------------------
+// This is what happens before rendering a particular view
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::PreRender()
+{
+	VPROF_BUDGET( "CClientLeafSystem::PreRender", "PreRender" );
+
+	int i;
+	int nIterations = 0;
+
+	while ( m_DirtyRenderables.Count() )
+	{
+		if ( ++nIterations > 10 )
+		{
+			Warning( "Too many dirty renderables!\n" );
+			break;
+		}
+
+		int nDirty = m_DirtyRenderables.Count();
+		for ( i = nDirty; --i >= 0; )
+		{
+			ClientRenderHandle_t handle = m_DirtyRenderables[i];
+			Assert( m_Renderables[ handle ].m_Flags & RENDER_FLAGS_HASCHANGED );
+
+			// Update position in leaf system
+			RemoveFromTree( handle );
+		}
+
+		bool bThreaded = false;//( nDirty > 5 && cl_threaded_client_leaf_system.GetBool() && g_pThreadPool->NumThreads() );
+
+		if ( !bThreaded )
+		{
+			for ( i = nDirty; --i >= 0; )
+			{
+				InsertIntoTree( m_DirtyRenderables[i] );
+			}
+		}
+		else
+		{
+			// InsertIntoTree can result in new renderables being added, so copy:
+			ClientRenderHandle_t *pDirtyRenderables = (ClientRenderHandle_t *)alloca( sizeof(ClientRenderHandle_t) * nDirty );
+			memcpy( pDirtyRenderables, m_DirtyRenderables.Base(), sizeof(ClientRenderHandle_t) * nDirty );
+			ParallelProcess( "CClientLeafSystem::PreRender", pDirtyRenderables, nDirty, this, &CClientLeafSystem::InsertIntoTree, &CClientLeafSystem::FrameLock, &CClientLeafSystem::FrameUnlock );
+		}
+
+		if ( m_DeferredInserts.Count() )
+		{
+			EnumResultList_t enumResultList;
+			while ( m_DeferredInserts.PopItem( &enumResultList ) )
+			{
+				m_ShadowEnum++;
+				while ( enumResultList.pHead )
+				{
+					EnumResult_t *p = enumResultList.pHead;
+					enumResultList.pHead = p->pNext;
+					AddRenderableToLeaf( p->leaf, enumResultList.handle );
+					delete p;
+				}
+			}
+		}
+
+		for ( i = nDirty; --i >= 0; )
+		{
+			// Cache off the area it's sitting in.
+			ClientRenderHandle_t handle = m_DirtyRenderables[i];
+			RenderableInfo_t& renderable = m_Renderables[ handle ];
+
+			renderable.m_Flags &= ~RENDER_FLAGS_HASCHANGED;
+			m_Renderables[handle].m_Area = GetRenderableArea( handle );
+		}
+
+		m_DirtyRenderables.RemoveMultiple( 0, nDirty );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates a new renderable
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::NewRenderable( IClientRenderable* pRenderable, RenderGroup_t type, int flags )
+{
+	Assert( pRenderable );
+	Assert( pRenderable->RenderHandle() == INVALID_CLIENT_RENDER_HANDLE );
+
+	ClientRenderHandle_t handle = m_Renderables.AddToTail();
+	RenderableInfo_t &info = m_Renderables[handle];
+
+	// We need to know if it's a brush model for shadows
+	int modelType = modelinfo->GetModelType( pRenderable->GetModel() );
+	if (modelType == mod_brush)
+	{
+		flags |= RENDER_FLAGS_BRUSH_MODEL;
+	}
+	else if ( modelType == mod_studio )
+	{
+		flags |= RENDER_FLAGS_STUDIO_MODEL;
+	}
+
+	info.m_pRenderable = pRenderable;
+	info.m_RenderFrame = -1;
+	info.m_RenderFrame2 = -1;
+	info.m_TranslucencyCalculated = -1;
+	info.m_TranslucencyCalculatedView = VIEW_ILLEGAL;
+	info.m_FirstShadow = m_ShadowsOnRenderable.InvalidIndex();
+	info.m_LeafList = m_RenderablesInLeaf.InvalidIndex();
+	info.m_Flags = flags;
+	info.m_RenderGroup = (unsigned char)type;
+	info.m_EnumCount = 0;
+	info.m_RenderLeaf = 0xFFFF;
+	if ( IsViewModelRenderGroup( (RenderGroup_t)info.m_RenderGroup ) )
+	{
+		AddToViewModelList( handle );
+	}
+
+	pRenderable->RenderHandle() = handle;
+}
+
+void CClientLeafSystem::CreateRenderableHandle( IClientRenderable* pRenderable, bool bIsStaticProp )
+{
+	// FIXME: The argument is unnecessary if we could get this next line to work
+	// the reason why we can't is because currently there are IClientRenderables
+	// which don't correctly implement GetRefEHandle.
+
+	//bool bIsStaticProp = staticpropmgr->IsStaticProp( pRenderable->GetIClientUnknown() );
+
+	// Add the prop to all the leaves it lies in
+	RenderGroup_t group = pRenderable->IsTransparent() ? RENDER_GROUP_TRANSLUCENT_ENTITY : RENDER_GROUP_OPAQUE_ENTITY;
+
+	bool bTwoPass = false;
+	if ( group == RENDER_GROUP_TRANSLUCENT_ENTITY )
+	{
+		bTwoPass = pRenderable->IsTwoPass( );
+	}
+
+	int flags = 0;
+	if ( bIsStaticProp )
+	{
+		flags = RENDER_FLAGS_STATIC_PROP;
+		if ( group == RENDER_GROUP_OPAQUE_ENTITY )
+		{
+			group = RENDER_GROUP_OPAQUE_STATIC;
+		}
+	}
+
+	if (bTwoPass)
+	{
+		flags |= RENDER_FLAGS_TWOPASS;
+	}
+
+	NewRenderable( pRenderable, group, flags );
+}
+
+
+//-----------------------------------------------------------------------------
+// Used to change renderables from translucent to opaque
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::ChangeRenderableRenderGroup( ClientRenderHandle_t handle, RenderGroup_t group )
+{
+	RenderableInfo_t &info = m_Renderables[handle];
+	info.m_RenderGroup = (unsigned char)group;
+}
+
+
+//-----------------------------------------------------------------------------
+// Use alternate translucent sorting algorithm (draw translucent objects in the furthest leaf they lie in)
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::EnableAlternateSorting( ClientRenderHandle_t handle, bool bEnable )
+{
+	RenderableInfo_t &info = m_Renderables[handle];
+	if ( bEnable )
+	{
+		info.m_Flags |= RENDER_FLAGS_ALTERNATE_SORTING;
+	}
+	else
+	{
+		info.m_Flags &= ~RENDER_FLAGS_ALTERNATE_SORTING; 
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Add/remove renderable
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::AddRenderable( IClientRenderable* pRenderable, RenderGroup_t group )
+{
+	// force a relink we we try to draw it for the first time
+	int flags = RENDER_FLAGS_HASCHANGED;
+
+	if ( group == RENDER_GROUP_TWOPASS )
+	{
+		group = RENDER_GROUP_TRANSLUCENT_ENTITY;
+		flags |= RENDER_FLAGS_TWOPASS;
+	}
+
+	NewRenderable( pRenderable, group, flags );
+	ClientRenderHandle_t handle = pRenderable->RenderHandle();
+	m_DirtyRenderables.AddToTail( handle );
+}
+
+void CClientLeafSystem::RemoveRenderable( ClientRenderHandle_t handle )
+{
+	// This can happen upon level shutdown
+	if (!m_Renderables.IsValidIndex(handle))
+		return;
+
+	// Reset the render handle in the entity.
+	IClientRenderable *pRenderable = m_Renderables[handle].m_pRenderable;
+	Assert( handle == pRenderable->RenderHandle() );
+	pRenderable->RenderHandle() = INVALID_CLIENT_RENDER_HANDLE;
+
+	// Reemove the renderable from the dirty list
+	if ( m_Renderables[handle].m_Flags & RENDER_FLAGS_HASCHANGED )
+	{
+		// NOTE: This isn't particularly fast (linear search),
+		// but I'm assuming it's an unusual case where we remove 
+		// renderables that are changing or that m_DirtyRenderables usually
+		// only has a couple entries
+		int i = m_DirtyRenderables.Find( handle );
+		Assert( i != m_DirtyRenderables.InvalidIndex() );
+		m_DirtyRenderables.FastRemove( i ); 
+	}
+
+	if ( IsViewModelRenderGroup( (RenderGroup_t)m_Renderables[handle].m_RenderGroup ) )
+	{
+		RemoveFromViewModelList( handle );
+	}
+
+	RemoveFromTree( handle );
+	m_Renderables.Remove( handle );
+}
+
+
+int CClientLeafSystem::GetRenderableLeaves( ClientRenderHandle_t handle, int leaves[128] )
+{
+	if ( !m_Renderables.IsValidIndex( handle ) )
+		return -1;
+
+	RenderableInfo_t *pRenderable = &m_Renderables[handle];
+	if ( pRenderable->m_LeafList == m_RenderablesInLeaf.InvalidIndex() )
+		return -1;
+
+	int nLeaves = 0;
+	for ( int i=m_RenderablesInLeaf.FirstBucket( handle ); i != m_RenderablesInLeaf.InvalidIndex(); i = m_RenderablesInLeaf.NextBucket( i ) )
+	{
+		leaves[nLeaves++] = m_RenderablesInLeaf.Bucket( i );
+		if ( nLeaves >= 128 )
+			break;
+	}
+	return nLeaves;
+}
+
+
+//-----------------------------------------------------------------------------
+// Retrieve leaf handles to leaves a renderable is in
+// the pOutLeaf parameter is filled with the leaf the renderable is in.
+// If pInIterator is not specified, pOutLeaf is the first leaf in the list.
+// if pInIterator is specified, that iterator is used to return the next leaf
+// in the list in pOutLeaf.
+// the pOutIterator parameter is filled with the iterater which index to the pOutLeaf returned.
+//
+// Returns false on failure cases where pOutLeaf will be invalid. CHECK THE RETURN!
+//-----------------------------------------------------------------------------
+bool CClientLeafSystem::GetRenderableLeaf(ClientRenderHandle_t handle, int* pOutLeaf, const int* pInIterator /* = 0 */, int* pOutIterator /* = 0  */)
+{
+	// bail on invalid handle
+	if ( !m_Renderables.IsValidIndex( handle ) )
+		return false;
+
+	// bail on no output value pointer
+	if ( !pOutLeaf )
+		return false;
+
+	// an iterator was specified
+	if ( pInIterator )
+	{
+		int iter = *pInIterator;
+
+		// test for invalid iterator
+		if ( iter == m_RenderablesInLeaf.InvalidIndex() )
+			return false;
+
+		int iterNext =  m_RenderablesInLeaf.NextBucket( iter );
+
+		// test for end of list
+		if ( iterNext == m_RenderablesInLeaf.InvalidIndex() )
+			return false;
+
+		// Give the caller the iterator used
+		if ( pOutIterator )
+		{
+			*pOutIterator = iterNext;
+		}
+		
+		// set output value to the next leaf
+		*pOutLeaf = m_RenderablesInLeaf.Bucket( iterNext );
+
+	}
+	else // no iter param, give them the first bucket in the renderable's list
+	{
+		int iter = m_RenderablesInLeaf.FirstBucket( handle );
+
+		if ( iter == m_RenderablesInLeaf.InvalidIndex() )
+			return false;
+
+		// Set output value to this leaf
+		*pOutLeaf = m_RenderablesInLeaf.Bucket( iter );
+
+		// give this iterator to caller
+		if ( pOutIterator )
+		{
+			*pOutIterator = iter;
+		}
+		
+	}
+	
+	return true;
+}
+
+bool CClientLeafSystem::IsRenderableInPVS( IClientRenderable *pRenderable )
+{
+	ClientRenderHandle_t handle = pRenderable->RenderHandle();
+	int leaves[128];
+	int nLeaves = GetRenderableLeaves( handle, leaves );
+	if ( nLeaves == -1 )
+		return false;
+
+	// Ask the engine if this guy is visible.
+	return render->AreAnyLeavesVisible( leaves, nLeaves );
+}
+
+short CClientLeafSystem::GetRenderableArea( ClientRenderHandle_t handle )
+{
+	int leaves[128];
+	int nLeaves = GetRenderableLeaves( handle, leaves );
+	if ( nLeaves == -1 )
+		return 0;
+
+	// Now ask the 
+	return engine->GetLeavesArea( leaves, nLeaves );
+}
+
+
+void CClientLeafSystem::SetSubSystemDataInLeaf( int leaf, int nSubSystemIdx, CClientLeafSubSystemData *pData )
+{
+	assert( nSubSystemIdx < N_CLSUBSYSTEMS );
+	if ( m_Leaf[leaf].m_pSubSystemData[nSubSystemIdx] )
+		delete m_Leaf[leaf].m_pSubSystemData[nSubSystemIdx];
+	m_Leaf[leaf].m_pSubSystemData[nSubSystemIdx] = pData;
+}
+
+CClientLeafSubSystemData *CClientLeafSystem::GetSubSystemDataInLeaf( int leaf, int nSubSystemIdx )
+{
+	assert( nSubSystemIdx < N_CLSUBSYSTEMS );
+	return m_Leaf[leaf].m_pSubSystemData[nSubSystemIdx];
+}
+
+//-----------------------------------------------------------------------------
+// Indicates which leaves detail objects are in
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::SetDetailObjectsInLeaf( int leaf, int firstDetailObject,
+											    int detailObjectCount )
+{
+	m_Leaf[leaf].m_FirstDetailProp = firstDetailObject;
+	m_Leaf[leaf].m_DetailPropCount = detailObjectCount;
+}
+
+//-----------------------------------------------------------------------------
+// Returns the detail objects in a leaf
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::GetDetailObjectsInLeaf( int leaf, int& firstDetailObject,
+											    int& detailObjectCount )
+{
+	firstDetailObject = m_Leaf[leaf].m_FirstDetailProp;
+	detailObjectCount = m_Leaf[leaf].m_DetailPropCount;
+}
+
+
+//-----------------------------------------------------------------------------
+// Create/destroy shadows...
+//-----------------------------------------------------------------------------
+ClientLeafShadowHandle_t CClientLeafSystem::AddShadow( ClientShadowHandle_t userId, unsigned short flags )
+{
+	ClientLeafShadowHandle_t idx = m_Shadows.AddToTail();
+	m_Shadows[idx].m_Shadow = userId;
+	m_Shadows[idx].m_FirstLeaf = m_ShadowsInLeaf.InvalidIndex();
+	m_Shadows[idx].m_FirstRenderable = m_ShadowsOnRenderable.InvalidIndex();
+	m_Shadows[idx].m_EnumCount = 0;
+	m_Shadows[idx].m_Flags = flags;
+	return idx;
+}
+
+void CClientLeafSystem::RemoveShadow( ClientLeafShadowHandle_t handle )
+{
+	// Remove the shadow from all leaves + renderables...
+	RemoveShadowFromLeaves( handle );
+	RemoveShadowFromRenderables( handle );
+
+	// Blow away the handle
+	m_Shadows.Remove( handle );
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a shadow to a leaf/removes shadow from renderable
+//-----------------------------------------------------------------------------
+inline bool CClientLeafSystem::ShouldRenderableReceiveShadow( ClientRenderHandle_t renderHandle, int nShadowFlags )
+{
+	RenderableInfo_t &renderable = m_Renderables[renderHandle];
+	if( !( renderable.m_Flags & ( RENDER_FLAGS_BRUSH_MODEL | RENDER_FLAGS_STATIC_PROP | RENDER_FLAGS_STUDIO_MODEL ) ) )
+		return false;
+
+	return renderable.m_pRenderable->ShouldReceiveProjectedTextures( nShadowFlags );
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a shadow to a leaf/removes shadow from renderable
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::AddShadowToRenderable( ClientRenderHandle_t renderHandle, 
+										ClientLeafShadowHandle_t shadowHandle )
+{
+	// Check if this renderable receives the type of projected texture that shadowHandle refers to.
+	int nShadowFlags = m_Shadows[shadowHandle].m_Flags;
+	if ( !ShouldRenderableReceiveShadow( renderHandle, nShadowFlags ) )
+		return;
+
+	m_ShadowsOnRenderable.AddElementToBucket( renderHandle, shadowHandle );
+
+	// Also, do some stuff specific to the particular types of renderables
+
+	// If the renderable is a brush model, then add this shadow to it
+	if (m_Renderables[renderHandle].m_Flags & RENDER_FLAGS_BRUSH_MODEL)
+	{
+		IClientRenderable* pRenderable = m_Renderables[renderHandle].m_pRenderable;
+		g_pClientShadowMgr->AddShadowToReceiver( m_Shadows[shadowHandle].m_Shadow,
+			pRenderable, SHADOW_RECEIVER_BRUSH_MODEL );
+	}
+	else if( m_Renderables[renderHandle].m_Flags & RENDER_FLAGS_STATIC_PROP )
+	{
+		IClientRenderable* pRenderable = m_Renderables[renderHandle].m_pRenderable;
+		g_pClientShadowMgr->AddShadowToReceiver( m_Shadows[shadowHandle].m_Shadow,
+			pRenderable, SHADOW_RECEIVER_STATIC_PROP );
+	}
+	else if( m_Renderables[renderHandle].m_Flags & RENDER_FLAGS_STUDIO_MODEL )
+	{
+		IClientRenderable* pRenderable = m_Renderables[renderHandle].m_pRenderable;
+		g_pClientShadowMgr->AddShadowToReceiver( m_Shadows[shadowHandle].m_Shadow,
+			pRenderable, SHADOW_RECEIVER_STUDIO_MODEL );
+	}
+}
+
+void CClientLeafSystem::RemoveShadowFromRenderables( ClientLeafShadowHandle_t handle )
+{
+	m_ShadowsOnRenderable.RemoveElement( handle );
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a shadow to a leaf/removes shadow from leaf
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::AddShadowToLeaf( int leaf, ClientLeafShadowHandle_t shadow )
+{
+	m_ShadowsInLeaf.AddElementToBucket( leaf, shadow ); 
+
+	// Add the shadow exactly once to all renderables in the leaf
+	unsigned short i = m_RenderablesInLeaf.FirstElement( leaf );
+	while ( i != m_RenderablesInLeaf.InvalidIndex() )
+	{
+		ClientRenderHandle_t renderable = m_RenderablesInLeaf.Element(i);
+		RenderableInfo_t& info = m_Renderables[renderable];
+
+		// Add each shadow exactly once to each renderable
+		if (info.m_EnumCount != m_ShadowEnum)
+		{
+			AddShadowToRenderable( renderable, shadow );
+			info.m_EnumCount = m_ShadowEnum;
+		}
+
+		Assert( m_ShadowsInLeaf.NumAllocated() < 2000 );
+
+		i = m_RenderablesInLeaf.NextElement(i);
+	}
+}
+
+void CClientLeafSystem::RemoveShadowFromLeaves( ClientLeafShadowHandle_t handle )
+{
+	m_ShadowsInLeaf.RemoveElement( handle );
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a shadow to all leaves listed
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::ProjectShadow( ClientLeafShadowHandle_t handle, int nLeafCount, const int *pLeafList )
+{
+	// Remove the shadow from any leaves it current exists in
+	RemoveShadowFromLeaves( handle );
+	RemoveShadowFromRenderables( handle );
+
+	Assert( ( m_Shadows[handle].m_Flags & SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK ) == SHADOW_FLAGS_SHADOW );
+
+	// This will help us to avoid adding the shadow multiple times to a renderable
+	++m_ShadowEnum;
+
+	for ( int i = 0; i < nLeafCount; ++i )
+	{
+		AddShadowToLeaf( pLeafList[i], handle );
+	}
+}
+
+void CClientLeafSystem::ProjectFlashlight( ClientLeafShadowHandle_t handle, int nLeafCount, const int *pLeafList )
+{
+	VPROF_BUDGET( "CClientLeafSystem::ProjectFlashlight", VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING );
+
+	// Remove the shadow from any leaves it current exists in
+	RemoveShadowFromLeaves( handle );
+	RemoveShadowFromRenderables( handle );
+
+	Assert( ( m_Shadows[handle].m_Flags & SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK ) == SHADOW_FLAGS_FLASHLIGHT );
+	
+	// This will help us to avoid adding the shadow multiple times to a renderable
+	++m_ShadowEnum;
+
+	for ( int i = 0; i < nLeafCount; ++i )
+	{
+		AddShadowToLeaf( pLeafList[i], handle );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Find all shadow casters in a set of leaves
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::EnumerateShadowsInLeaves( int leafCount, LeafIndex_t* pLeaves, IClientLeafShadowEnum* pEnum )
+{
+	if (leafCount == 0)
+		return;
+
+	// This will help us to avoid enumerating the shadow multiple times
+	++m_ShadowEnum;
+
+	for (int i = 0; i < leafCount; ++i)
+	{
+		int leaf = pLeaves[i];
+
+		unsigned short j = m_ShadowsInLeaf.FirstElement( leaf );
+		while ( j != m_ShadowsInLeaf.InvalidIndex() )
+		{
+			ClientLeafShadowHandle_t shadow = m_ShadowsInLeaf.Element(j);
+			ShadowInfo_t& info = m_Shadows[shadow];
+
+			if (info.m_EnumCount != m_ShadowEnum)
+			{
+				pEnum->EnumShadow(info.m_Shadow);
+				info.m_EnumCount = m_ShadowEnum;
+			}
+
+			j = m_ShadowsInLeaf.NextElement(j);
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a renderable to a leaf
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::AddRenderableToLeaf( int leaf, ClientRenderHandle_t renderable )
+{
+#ifdef VALIDATE_CLIENT_LEAF_SYSTEM
+	m_RenderablesInLeaf.ValidateAddElementToBucket( leaf, renderable );
+#endif
+	m_RenderablesInLeaf.AddElementToBucket( leaf, renderable );
+
+	if ( !ShouldRenderableReceiveShadow( renderable, SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK ) )
+		return;
+
+	// Add all shadows in the leaf to the renderable...
+	unsigned short i = m_ShadowsInLeaf.FirstElement( leaf );
+	while (i != m_ShadowsInLeaf.InvalidIndex() )
+	{
+		ClientLeafShadowHandle_t shadow = m_ShadowsInLeaf.Element(i);
+		ShadowInfo_t& info = m_Shadows[shadow];
+
+		// Add each shadow exactly once to each renderable
+		if (info.m_EnumCount != m_ShadowEnum)
+		{
+			AddShadowToRenderable( renderable, shadow );
+			info.m_EnumCount = m_ShadowEnum;
+		}
+
+		i = m_ShadowsInLeaf.NextElement(i);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a renderable to a set of leaves
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::AddRenderableToLeaves( ClientRenderHandle_t handle, int nLeafCount, unsigned short *pLeaves )
+{ 
+	for (int j = 0; j < nLeafCount; ++j)
+	{
+		AddRenderableToLeaf( pLeaves[j], handle ); 
+	}
+	m_Renderables[handle].m_Area = GetRenderableArea( handle );
+}
+
+
+//-----------------------------------------------------------------------------
+// Inserts an element into the tree
+//-----------------------------------------------------------------------------
+bool CClientLeafSystem::EnumerateLeaf( int leaf, int context )
+{
+	EnumResultList_t *pList = (EnumResultList_t *)context;
+	if ( ThreadInMainThread() )
+	{
+		AddRenderableToLeaf( leaf, pList->handle );
+	}
+	else
+	{
+		EnumResult_t *p = new EnumResult_t;
+		p->leaf = leaf;
+		p->pNext = pList->pHead;
+		pList->pHead = p;
+	}
+	return true;
+}
+
+void CClientLeafSystem::InsertIntoTree( ClientRenderHandle_t &handle )
+{
+	if ( ThreadInMainThread() )
+	{
+		// When we insert into the tree, increase the shadow enumerator
+		// to make sure each shadow is added exactly once to each renderable
+		m_ShadowEnum++;
+	}
+
+	EnumResultList_t list = { NULL, handle };
+
+	// NOTE: The render bounds here are relative to the renderable's coordinate system
+	IClientRenderable* pRenderable = m_Renderables[handle].m_pRenderable;
+	Vector absMins, absMaxs;
+	
+	CalcRenderableWorldSpaceAABB_Fast( pRenderable, absMins, absMaxs );
+	Assert( absMins.IsValid() && absMaxs.IsValid() );
+
+	ISpatialQuery* pQuery = engine->GetBSPTreeQuery();
+	pQuery->EnumerateLeavesInBox( absMins, absMaxs, this, (int)&list );
+
+	if ( list.pHead )
+	{
+		m_DeferredInserts.PushItem( list );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Removes an element from the tree
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::RemoveFromTree( ClientRenderHandle_t handle )
+{
+	m_RenderablesInLeaf.RemoveElement( handle );
+
+	// Remove all shadows cast onto the object
+	m_ShadowsOnRenderable.RemoveBucket( handle );
+
+	// If the renderable is a brush model, then remove all shadows from it
+	if (m_Renderables[handle].m_Flags & RENDER_FLAGS_BRUSH_MODEL)
+	{
+		g_pClientShadowMgr->RemoveAllShadowsFromReceiver( 
+			m_Renderables[handle].m_pRenderable, SHADOW_RECEIVER_BRUSH_MODEL );
+	}
+	else if( m_Renderables[handle].m_Flags & RENDER_FLAGS_STUDIO_MODEL )
+	{
+		g_pClientShadowMgr->RemoveAllShadowsFromReceiver( 
+			m_Renderables[handle].m_pRenderable, SHADOW_RECEIVER_STUDIO_MODEL );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Call this when the renderable moves
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::RenderableChanged( ClientRenderHandle_t handle )
+{
+	Assert ( handle != INVALID_CLIENT_RENDER_HANDLE );
+	Assert( m_Renderables.IsValidIndex( handle ) );
+	if ( !m_Renderables.IsValidIndex( handle ) )
+		return;
+
+	if ( (m_Renderables[handle].m_Flags & RENDER_FLAGS_HASCHANGED ) == 0 )
+	{
+		m_Renderables[handle].m_Flags |= RENDER_FLAGS_HASCHANGED;
+		m_DirtyRenderables.AddToTail( handle );
+	}
+#if _DEBUG
+	else
+	{
+		// It had better be in the list
+		Assert( m_DirtyRenderables.Find( handle ) != m_DirtyRenderables.InvalidIndex() );
+	}
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns if it's a view model render group
+//-----------------------------------------------------------------------------
+inline bool CClientLeafSystem::IsViewModelRenderGroup( RenderGroup_t group ) const
+{
+	return (group == RENDER_GROUP_VIEW_MODEL_TRANSLUCENT) || (group == RENDER_GROUP_VIEW_MODEL_OPAQUE);
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds, removes renderables from view model list
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::AddToViewModelList( ClientRenderHandle_t handle )
+{
+	MEM_ALLOC_CREDIT();
+	Assert( m_ViewModels.Find( handle ) == m_ViewModels.InvalidIndex() );
+	m_ViewModels.AddToTail( handle );
+}
+
+void CClientLeafSystem::RemoveFromViewModelList( ClientRenderHandle_t handle )
+{
+	int i = m_ViewModels.Find( handle );
+	Assert( i != m_ViewModels.InvalidIndex() );
+	m_ViewModels.FastRemove( i );
+}
+
+
+//-----------------------------------------------------------------------------
+// Call this to change the render group
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::SetRenderGroup( ClientRenderHandle_t handle, RenderGroup_t group )
+{
+	RenderableInfo_t *pInfo = &m_Renderables[handle];
+
+	bool twoPass = false;
+	if ( group == RENDER_GROUP_TWOPASS )
+	{
+		twoPass = true;
+		group = RENDER_GROUP_TRANSLUCENT_ENTITY;
+	}
+
+	if ( twoPass )
+	{
+		pInfo->m_Flags |= RENDER_FLAGS_TWOPASS;
+	}
+	else
+	{
+		pInfo->m_Flags &= ~RENDER_FLAGS_TWOPASS;
+	}
+
+	bool bOldViewModelRenderGroup = IsViewModelRenderGroup( (RenderGroup_t)pInfo->m_RenderGroup );
+	bool bNewViewModelRenderGroup = IsViewModelRenderGroup( group );
+	if ( bOldViewModelRenderGroup != bNewViewModelRenderGroup )
+	{
+		if ( bOldViewModelRenderGroup )
+		{
+			RemoveFromViewModelList( handle );
+		}
+		else 
+		{
+			AddToViewModelList( handle );
+		}
+	}
+
+	pInfo->m_RenderGroup = group;
+
+}
+
+
+//-----------------------------------------------------------------------------
+// Detail system marks 
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::DrawDetailObjectsInLeaf( int leaf, int nFrameNumber, int& nFirstDetailObject, int& nDetailObjectCount )
+{
+	ClientLeaf_t &leafInfo = m_Leaf[leaf];
+	leafInfo.m_DetailPropRenderFrame = nFrameNumber;
+	nFirstDetailObject = leafInfo.m_FirstDetailProp;
+	nDetailObjectCount = leafInfo.m_DetailPropCount;
+}
+
+
+//-----------------------------------------------------------------------------
+// Are we close enough to this leaf to draw detail props *and* are there any props in the leaf?
+//-----------------------------------------------------------------------------
+bool CClientLeafSystem::ShouldDrawDetailObjectsInLeaf( int leaf, int frameNumber )
+{
+	ClientLeaf_t &leafInfo = m_Leaf[leaf];
+	return ( (leafInfo.m_DetailPropRenderFrame == frameNumber ) &&
+			 ( ( leafInfo.m_DetailPropCount != 0 ) || ( leafInfo.m_pSubSystemData[CLSUBSYSTEM_DETAILOBJECTS] ) ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Compute which leaf the translucent renderables should render in
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::ComputeTranslucentRenderLeaf( int count, const LeafIndex_t *pLeafList, const LeafFogVolume_t *pLeafFogVolumeList, int frameNumber, int viewID )
+{
+	ASSERT_NO_REENTRY();
+	VPROF_BUDGET( "CClientLeafSystem::ComputeTranslucentRenderLeaf", "ComputeTranslucentRenderLeaf"  );
+
+	#define LeafToMarker( leaf ) reinterpret_cast<RenderableInfo_t *>(( (leaf) << 1 ) | 1)
+	#define IsLeafMarker( p ) (bool)((reinterpret_cast<size_t>(p)) & 1)
+	#define MarkerToLeaf( p ) (int)((reinterpret_cast<size_t>(p)) >> 1)
+
+	// For better sorting, we're gonna choose the leaf that is closest to the camera.
+	// The leaf list passed in here is sorted front to back
+	bool bThreaded = false;//( cl_threaded_client_leaf_system.GetBool() && g_pThreadPool->NumThreads() );
+	int globalFrameCount = gpGlobals->framecount;
+	int i;
+
+	static CUtlVector<RenderableInfo_t *> orderedList; // @MULTICORE (toml 8/30/2006): will need to make non-static if thread this function
+	static CUtlVector<IClientRenderable *> renderablesToUpdate;
+	int leaf = 0;
+	for ( i = 0; i < count; ++i )
+	{
+		leaf = pLeafList[i];
+		orderedList.AddToTail( LeafToMarker( leaf ) );
+
+		// iterate over all elements in this leaf
+		unsigned short idx = m_RenderablesInLeaf.FirstElement(leaf);
+		while (idx != m_RenderablesInLeaf.InvalidIndex())
+		{
+			RenderableInfo_t& info = m_Renderables[m_RenderablesInLeaf.Element(idx)];
+			if ( info.m_TranslucencyCalculated != globalFrameCount || info.m_TranslucencyCalculatedView != viewID )
+			{ 
+				// Compute translucency
+				if ( bThreaded )
+				{
+					renderablesToUpdate.AddToTail( info.m_pRenderable );
+				}
+				else
+				{
+					info.m_pRenderable->ComputeFxBlend();
+				}
+				info.m_TranslucencyCalculated = globalFrameCount;
+				info.m_TranslucencyCalculatedView = viewID;
+			}
+			orderedList.AddToTail( &info );
+			idx = m_RenderablesInLeaf.NextElement(idx); 
+		}
+	}
+
+	if ( bThreaded )
+	{
+		ParallelProcess( "CClientLeafSystem::ComputeTranslucentRenderLeaf", renderablesToUpdate.Base(), renderablesToUpdate.Count(), &CallComputeFXBlend, &::FrameLock, &::FrameUnlock );
+		renderablesToUpdate.RemoveAll();
+	}
+
+	for ( i = 0; i != orderedList.Count(); i++ )
+	{
+		RenderableInfo_t *pInfo = orderedList[i];
+		if ( !IsLeafMarker( pInfo ) )
+		{
+			if( pInfo->m_RenderFrame != frameNumber )
+			{   
+				if( pInfo->m_RenderGroup == RENDER_GROUP_TRANSLUCENT_ENTITY )
+				{
+					pInfo->m_RenderLeaf = leaf;
+				}
+				pInfo->m_RenderFrame = frameNumber;
+			}
+			else if ( pInfo->m_Flags & RENDER_FLAGS_ALTERNATE_SORTING )
+			{
+				if( pInfo->m_RenderGroup == RENDER_GROUP_TRANSLUCENT_ENTITY )
+				{
+					pInfo->m_RenderLeaf = leaf;
+				}
+			}
+
+		}
+		else
+		{
+			leaf = MarkerToLeaf( pInfo );
+		}
+	}
+
+	orderedList.RemoveAll();
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a renderable to the list of renderables to render this frame
+//-----------------------------------------------------------------------------
+inline void AddRenderableToRenderList( CClientRenderablesList &renderList, IClientRenderable *pRenderable, 
+	int iLeaf, RenderGroup_t group,	ClientRenderHandle_t renderHandle, bool bTwoPass = false )
+{
+#ifdef _DEBUG
+	if (cl_drawleaf.GetInt() >= 0)
+	{
+		if (iLeaf != cl_drawleaf.GetInt())
+			return;
+	}
+#endif
+
+	Assert( group >= 0 && group < RENDER_GROUP_COUNT );
+	
+	int &curCount = renderList.m_RenderGroupCounts[group];
+	if ( curCount < CClientRenderablesList::MAX_GROUP_ENTITIES )
+	{
+		Assert( (iLeaf >= 0) && (iLeaf <= 65535) );
+
+		CClientRenderablesList::CEntry *pEntry = &renderList.m_RenderGroups[group][curCount];
+		pEntry->m_pRenderable = pRenderable;
+		pEntry->m_iWorldListInfoLeaf = iLeaf;
+		pEntry->m_TwoPass = bTwoPass;
+		pEntry->m_RenderHandle = renderHandle;
+		curCount++;
+	}
+	else
+	{
+		engine->Con_NPrintf( 10, "Warning: overflowed CClientRenderablesList group %d", group );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : renderList - 
+//			renderGroup - 
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::CollateViewModelRenderables( CUtlVector< IClientRenderable * >& opaque, CUtlVector< IClientRenderable * >& translucent )
+{
+	for ( int i = m_ViewModels.Count()-1; i >= 0; --i )
+	{
+		ClientRenderHandle_t handle = m_ViewModels[i];
+		RenderableInfo_t& renderable = m_Renderables[handle];
+
+		// NOTE: In some cases, this removes the entity from the view model list
+		renderable.m_pRenderable->ComputeFxBlend();
+		
+		// That's why we need to test RENDER_GROUP_OPAQUE_ENTITY - it may have changed in ComputeFXBlend()
+		if ( renderable.m_RenderGroup == RENDER_GROUP_VIEW_MODEL_OPAQUE || renderable.m_RenderGroup == RENDER_GROUP_OPAQUE_ENTITY )
+		{
+			opaque.AddToTail( renderable.m_pRenderable );
+		}
+		else
+		{
+			translucent.AddToTail( renderable.m_pRenderable );
+		}
+	}
+}
+
+static RenderGroup_t DetectBucketedRenderGroup( RenderGroup_t group, float fDimension )
+{
+	float const arrThresholds[ 3 ] = {
+		200.f,	// tree size
+		80.f,	// player size
+		30.f,	// crate size
+	};
+	Assert( ARRAYSIZE( arrThresholds ) + 1 >= RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS );
+	Assert( group >= RENDER_GROUP_OPAQUE_STATIC && group <= RENDER_GROUP_OPAQUE_ENTITY );
+
+	int bucketedGroupIndex;
+	if ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS <= 2 ||
+		fDimension >= arrThresholds[1] )
+	{
+		if ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS <= 1 ||
+			fDimension >= arrThresholds[0] )
+			bucketedGroupIndex = 0;
+		else
+			bucketedGroupIndex = 1;
+	}
+	else
+	{
+		if ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS <= 3 ||
+			fDimension >= arrThresholds[2] )
+			bucketedGroupIndex = 2;
+		else
+			bucketedGroupIndex = 3;
+	}
+
+	// Determine the new bucketed group
+	RenderGroup_t bucketedGroup = RenderGroup_t( group - ( ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS - 1 ) - bucketedGroupIndex ) * 2 );
+	Assert( bucketedGroup >= RENDER_GROUP_OPAQUE_STATIC_HUGE && bucketedGroup <= RENDER_GROUP_OPAQUE_ENTITY );
+	
+	return bucketedGroup;
+}
+
+void CClientLeafSystem::CollateRenderablesInLeaf( int leaf, int worldListLeafIndex,	const SetupRenderInfo_t &info )
+{
+	bool portalTestEnts = r_PortalTestEnts.GetBool() && !r_portalsopenall.GetBool();
+	
+	// Place a fake entity for static/opaque ents in this leaf
+	AddRenderableToRenderList( *info.m_pRenderList, NULL, worldListLeafIndex, RENDER_GROUP_OPAQUE_STATIC, NULL );
+	AddRenderableToRenderList( *info.m_pRenderList, NULL, worldListLeafIndex, RENDER_GROUP_OPAQUE_ENTITY, NULL );
+
+	// Collate everything.
+	unsigned short idx = m_RenderablesInLeaf.FirstElement(leaf);
+	for ( ;idx != m_RenderablesInLeaf.InvalidIndex(); idx = m_RenderablesInLeaf.NextElement(idx) )
+	{
+		ClientRenderHandle_t handle = m_RenderablesInLeaf.Element(idx);
+		RenderableInfo_t& renderable = m_Renderables[handle];
+
+		// Early out on static props if we don't want to render them
+		if ((!m_DrawStaticProps) && (renderable.m_Flags & RENDER_FLAGS_STATIC_PROP))
+			continue;
+
+		// Early out if we're told to not draw small objects (top view only,
+		/* that's why we don't check the z component).
+		if (!m_DrawSmallObjects)
+		{
+			CCachedRenderInfo& cachedInfo =  m_CachedRenderInfos[renderable.m_CachedRenderInfo];
+			float sizeX = cachedInfo.m_Maxs.x - cachedInfo.m_Mins.x;
+			float sizeY = cachedInfo.m_Maxs.y - cachedInfo.m_Mins.y;
+			if ((sizeX < 50.f) && (sizeY < 50.f))
+				continue;
+		}*/
+
+		Assert( m_DrawSmallObjects ); // MOTODO
+
+		// Don't hit the same ent in multiple leaves twice.
+		if ( renderable.m_RenderGroup != RENDER_GROUP_TRANSLUCENT_ENTITY )
+		{
+			if ( renderable.m_RenderFrame2 == info.m_nRenderFrame )
+				continue;
+
+			renderable.m_RenderFrame2 = info.m_nRenderFrame;
+		}
+		else // translucent
+		{
+			// Shadow depth skips ComputeTranslucentRenderLeaf!
+
+			// Translucent entities already have had ComputeTranslucentRenderLeaf called on them
+			// so m_RenderLeaf should be set to the nearest leaf, so that's what we want here.
+			if ( renderable.m_RenderLeaf != leaf )
+				continue;
+		}
+
+		unsigned char nAlpha = 255;
+		if ( info.m_bDrawTranslucentObjects ) 
+		{
+			// Prevent culling if the renderable is invisible
+			// NOTE: OPAQUE objects can have alpha == 0. 
+			// They are made to be opaque because they don't have to be sorted.
+			nAlpha = renderable.m_pRenderable->GetFxBlend();
+			if ( nAlpha == 0 )
+				continue;
+		}
+
+		Vector absMins, absMaxs;
+		CalcRenderableWorldSpaceAABB( renderable.m_pRenderable, absMins, absMaxs );
+		// If the renderable is inside an area, cull it using the frustum for that area.
+		if ( portalTestEnts && renderable.m_Area != -1 )
+		{
+			VPROF( "r_PortalTestEnts" );
+			if ( !engine->DoesBoxTouchAreaFrustum( absMins, absMaxs, renderable.m_Area ) )
+				continue;
+		}
+		else
+		{
+			// cull with main frustum
+			if ( engine->CullBox( absMins, absMaxs ) )
+				continue;
+		}
+
+		// UNDONE: Investigate speed tradeoffs of occlusion culling brush models too?
+		if ( renderable.m_Flags & RENDER_FLAGS_STUDIO_MODEL )
+		{
+			// test to see if this renderable is occluded by the engine's occlusion system
+			if ( engine->IsOccluded( absMins, absMaxs ) )
+				continue;
+		}
+
+#ifdef INVASION_CLIENT_DLL
+		if (info.m_flRenderDistSq != 0.0f)
+		{
+			Vector mins, maxs;
+			renderable.m_pRenderable->GetRenderBounds( mins, maxs );
+
+			if ((maxs.z - mins.z) < 100)
+			{
+				Vector vCenter;
+				VectorLerp( mins, maxs, 0.5f, vCenter );
+				vCenter += renderable.m_pRenderable->GetRenderOrigin();
+
+				float flDistSq = info.m_vecRenderOrigin.DistToSqr( vCenter );
+				if (info.m_flRenderDistSq <= flDistSq)
+					continue;
+			}
+		}
+#endif
+
+		if( renderable.m_RenderGroup != RENDER_GROUP_TRANSLUCENT_ENTITY )
+		{
+			RenderGroup_t group = (RenderGroup_t)renderable.m_RenderGroup;
+
+			// Determine object group offset
+			if ( RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS > 1 &&
+				 group >= RENDER_GROUP_OPAQUE_STATIC &&
+				 group <= RENDER_GROUP_OPAQUE_ENTITY )
+			{
+				Vector dims;
+				VectorSubtract( absMaxs, absMins, dims );
+
+				float const fDimension = MAX( MAX( fabs(dims.x), fabs(dims.y) ), fabs(dims.z) );
+				group = DetectBucketedRenderGroup( group, fDimension );
+				
+				Assert( group >= RENDER_GROUP_OPAQUE_STATIC_HUGE && group <= RENDER_GROUP_OPAQUE_ENTITY );
+			}
+
+			AddRenderableToRenderList( *info.m_pRenderList, renderable.m_pRenderable, 
+				worldListLeafIndex, group, handle);
+		}
+		else
+		{
+			bool bTwoPass = ((renderable.m_Flags & RENDER_FLAGS_TWOPASS) != 0) && ( nAlpha == 255 );	// Two pass?
+
+			// Add to appropriate list if drawing translucent objects (shadow depth mapping will skip this)
+			if ( info.m_bDrawTranslucentObjects ) 
+			{
+				AddRenderableToRenderList( *info.m_pRenderList, renderable.m_pRenderable, 
+					worldListLeafIndex, (RenderGroup_t)renderable.m_RenderGroup, handle, bTwoPass );
+			}
+			
+			if ( bTwoPass )	// Also add to opaque list if it's a two-pass model... 
+			{
+				AddRenderableToRenderList( *info.m_pRenderList, renderable.m_pRenderable, 
+					worldListLeafIndex, RENDER_GROUP_OPAQUE_ENTITY, handle, bTwoPass );
+			}
+		}
+	}
+
+	// Do detail objects.
+	// These don't have render handles!
+	if ( info.m_bDrawDetailObjects && ShouldDrawDetailObjectsInLeaf( leaf, info.m_nDetailBuildFrame ) )
+	{
+		idx = m_Leaf[leaf].m_FirstDetailProp;
+		int count = m_Leaf[leaf].m_DetailPropCount;
+		while( --count >= 0 )
+		{
+			IClientRenderable* pRenderable = DetailObjectSystem()->GetDetailModel(idx);
+
+			// FIXME: This if check here is necessary because the detail object system also maintains lists of sprites...
+			if (pRenderable)
+			{
+				if( pRenderable->IsTransparent() )
+				{
+					if ( info.m_bDrawTranslucentObjects )	// Don't draw translucent objects into shadow depth maps
+					{
+						// Lots of the detail entities are invisible so avoid sorting them and all that.
+						if( pRenderable->GetFxBlend() > 0 )
+						{
+							AddRenderableToRenderList( *info.m_pRenderList, pRenderable, 
+								worldListLeafIndex, RENDER_GROUP_TRANSLUCENT_ENTITY, DETAIL_PROP_RENDER_HANDLE );
+						}
+					}
+				}
+				else
+				{
+					AddRenderableToRenderList( *info.m_pRenderList, pRenderable, 
+						worldListLeafIndex, RENDER_GROUP_OPAQUE_ENTITY, DETAIL_PROP_RENDER_HANDLE );
+				}
+			}
+			++idx;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Sort entities in a back-to-front ordering
+//-----------------------------------------------------------------------------
+void CClientLeafSystem::SortEntities( const Vector &vecRenderOrigin, const Vector &vecRenderForward, CClientRenderablesList::CEntry *pEntities, int nEntities )
+{
+	// Don't sort if we only have 1 entity
+	if ( nEntities <= 1 )
+		return;
+
+	float dists[CClientRenderablesList::MAX_GROUP_ENTITIES];
+
+	// First get a distance for each entity.
+	int i;
+	for( i=0; i < nEntities; i++ )
+	{
+		IClientRenderable *pRenderable = pEntities[i].m_pRenderable;
+
+		// Compute the center of the object (needed for translucent brush models)
+		Vector boxcenter;
+		Vector mins,maxs;
+		pRenderable->GetRenderBounds( mins, maxs );
+		VectorAdd( mins, maxs, boxcenter );
+		VectorMA( pRenderable->GetRenderOrigin(), 0.5f, boxcenter, boxcenter );
+
+		// Compute distance...
+		Vector delta;
+		VectorSubtract( boxcenter, vecRenderOrigin, delta );
+		dists[i] = DotProduct( delta, vecRenderForward );
+	}
+
+	// H-sort.
+	int stepSize = 4;
+	while( stepSize )
+	{
+		int end = nEntities - stepSize;
+		for( i=0; i < end; i += stepSize )
+		{
+			if( dists[i] > dists[i+stepSize] )
+			{
+				::V_swap( pEntities[i], pEntities[i+stepSize] );
+				::V_swap( dists[i], dists[i+stepSize] );
+
+				if( i == 0 )
+				{
+					i = -stepSize;
+				}
+				else
+				{
+					i -= stepSize << 1;
+				}
+			}
+		}
+
+		stepSize >>= 1;
+	}
+}
+
+
+void CClientLeafSystem::BuildRenderablesList( const SetupRenderInfo_t &info )
+{
+	VPROF_BUDGET( "BuildRenderablesList", "BuildRenderablesList" );
+	int leafCount = info.m_pWorldListInfo->m_LeafCount;
+	const Vector &vecRenderOrigin = info.m_vecRenderOrigin;
+	const Vector &vecRenderForward = info.m_vecRenderForward;
+	CClientRenderablesList::CEntry *pTranslucentEntries = info.m_pRenderList->m_RenderGroups[RENDER_GROUP_TRANSLUCENT_ENTITY];
+	int &nTranslucentEntries = info.m_pRenderList->m_RenderGroupCounts[RENDER_GROUP_TRANSLUCENT_ENTITY];
+
+	for( int i = 0; i < leafCount; i++ )
+	{
+		int nTranslucent = nTranslucentEntries;
+
+		// Add renderables from this leaf...
+		CollateRenderablesInLeaf( info.m_pWorldListInfo->m_pLeafList[i], i, info );
+
+		int nNewTranslucent = nTranslucentEntries - nTranslucent;
+		if( (nNewTranslucent != 0 ) && info.m_bDrawTranslucentObjects )
+		{
+			// Sort the new translucent entities.
+			SortEntities( vecRenderOrigin, vecRenderForward, &pTranslucentEntries[nTranslucent], nNewTranslucent );
+		}
+	}
+}