First version of the SOurce SDK 2013

1 files changed, 2811 insertions, 0 deletions

diff --git a/mp/src/game/client/detailobjectsystem.cpp b/mp/src/game/client/detailobjectsystem.cpp
new file mode 100644
index 00000000..ede990de
--- /dev/null
+++ b/mp/src/game/client/detailobjectsystem.cpp
@@ -0,0 +1,2811 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: Draws grasses and other small objects  

+//

+// $Revision: $

+// $NoKeywords: $

+//===========================================================================//

+#include "cbase.h"

+#include "detailobjectsystem.h"

+#include "gamebspfile.h"

+#include "tier1/utlbuffer.h"

+#include "tier1/utlmap.h"

+#include "view.h"

+#include "clientmode.h"

+#include "iviewrender.h"

+#include "bsptreedata.h"

+#include "tier0/vprof.h"

+#include "engine/ivmodelinfo.h"

+#include "materialsystem/imesh.h"

+#include "model_types.h"

+#include "env_detail_controller.h"

+#include "tier0/icommandline.h"

+#include "c_world.h"

+

+#include "tier0/valve_minmax_off.h"

+#include <algorithm>

+#include "tier0/valve_minmax_on.h"

+

+#if defined(DOD_DLL) || defined(CSTRIKE_DLL)

+#define USE_DETAIL_SHAPES

+#endif

+

+#ifdef USE_DETAIL_SHAPES

+#include "engine/ivdebugoverlay.h"

+#include "playerenumerator.h"

+#endif

+

+#include "materialsystem/imaterialsystemhardwareconfig.h"

+

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

+#include "tier0/memdbgon.h"

+

+#define DETAIL_SPRITE_MATERIAL		"detail/detailsprites"

+

+//-----------------------------------------------------------------------------

+// forward declarations

+//-----------------------------------------------------------------------------

+struct model_t;

+

+

+ConVar cl_detaildist( "cl_detaildist", "1200", 0, "Distance at which detail props are no longer visible" );

+ConVar cl_detailfade( "cl_detailfade", "400", 0, "Distance across which detail props fade in" );

+#if defined( USE_DETAIL_SHAPES ) 

+ConVar cl_detail_max_sway( "cl_detail_max_sway", "0", FCVAR_ARCHIVE, "Amplitude of the detail prop sway" );

+ConVar cl_detail_avoid_radius( "cl_detail_avoid_radius", "0", FCVAR_ARCHIVE, "radius around detail sprite to avoid players" );

+ConVar cl_detail_avoid_force( "cl_detail_avoid_force", "0", FCVAR_ARCHIVE, "force with which to avoid players ( in units, percentage of the width of the detail sprite )" );

+ConVar cl_detail_avoid_recover_speed( "cl_detail_avoid_recover_speed", "0", FCVAR_ARCHIVE, "how fast to recover position after avoiding players" );

+#endif

+

+// Per detail instance information

+struct DetailModelAdvInfo_t

+{

+	// precaculated angles for shaped sprites

+	Vector m_vecAnglesForward[3];

+	Vector m_vecAnglesRight[3];		// better to save this mem and calc per sprite ?

+	Vector m_vecAnglesUp[3];

+

+	// direction we're avoiding the player

+	Vector m_vecCurrentAvoid;

+

+	// yaw to sway on

+	float m_flSwayYaw;

+

+	// size of the shape

+	float m_flShapeSize;

+

+	int m_iShapeAngle;

+	float m_flSwayAmount;

+

+};

+

+class CDetailObjectSystemPerLeafData

+{

+	unsigned short	m_FirstDetailProp;

+	unsigned short	m_DetailPropCount;

+	int				m_DetailPropRenderFrame;

+

+	CDetailObjectSystemPerLeafData( void )

+	{

+		m_FirstDetailProp = 0;

+		m_DetailPropCount = 0;

+		m_DetailPropRenderFrame = -1;

+	}

+};

+

+//-----------------------------------------------------------------------------

+// Detail models

+//-----------------------------------------------------------------------------

+struct SptrintInfo_t

+{

+	unsigned short	m_nSpriteIndex;

+	float16			m_flScale;

+};

+

+class CDetailModel : public IClientUnknown, public IClientRenderable

+{

+	DECLARE_CLASS_NOBASE( CDetailModel );

+

+public:

+	CDetailModel();

+	~CDetailModel();

+

+

+	// Initialization

+	bool InitCommon( int index, const Vector& org, const QAngle& angles );

+	bool Init( int index, const Vector& org, const QAngle& angles, model_t* pModel, 

+		ColorRGBExp32 lighting, int lightstyle, unsigned char lightstylecount, int orientation );

+

+	bool InitSprite( int index, bool bFlipped, const Vector& org, const QAngle& angles,

+					 unsigned short nSpriteIndex, 

+					 ColorRGBExp32 lighting, int lightstyle, unsigned char lightstylecount,

+					 int orientation, float flScale, unsigned char type,

+					 unsigned char shapeAngle, unsigned char shapeSize, unsigned char swayAmount );

+

+	void SetAlpha( unsigned char alpha ) { m_Alpha = alpha; }

+

+

+	// IClientUnknown overrides.

+public:

+

+	virtual IClientUnknown*		GetIClientUnknown()		{ return this; }

+	virtual ICollideable*		GetCollideable()		{ return 0; }		// Static props DO implement this.

+	virtual IClientNetworkable*	GetClientNetworkable()	{ return 0; }

+	virtual IClientRenderable*	GetClientRenderable()	{ return this; }

+	virtual IClientEntity*		GetIClientEntity()		{ return 0; }

+	virtual C_BaseEntity*		GetBaseEntity()			{ return 0; }

+	virtual IClientThinkable*	GetClientThinkable()	{ return 0; }

+

+

+	// IClientRenderable overrides.

+public:

+

+	virtual int					GetBody() { return 0; }

+	virtual const Vector&		GetRenderOrigin( );

+	virtual const QAngle&		GetRenderAngles( );

+	virtual const matrix3x4_t &	RenderableToWorldTransform();

+	virtual bool				ShouldDraw();

+	virtual bool				IsTwoPass( void ) { return false; }

+	virtual void				OnThreadedDrawSetup() {}

+	virtual bool				IsTransparent( void );

+	virtual const model_t*		GetModel( ) const;

+	virtual int					DrawModel( int flags );

+	virtual void				ComputeFxBlend( );

+	virtual int					GetFxBlend( );

+	virtual bool				SetupBones( matrix3x4_t *pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime );

+	virtual void				SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights );

+	virtual bool				UsesFlexDelayedWeights() { return false; }

+	virtual void				DoAnimationEvents( void );

+	virtual void				GetRenderBounds( Vector& mins, Vector& maxs );

+	virtual IPVSNotify*			GetPVSNotifyInterface();

+	virtual void				GetRenderBoundsWorldspace( Vector& mins, Vector& maxs );

+	virtual bool				ShouldReceiveProjectedTextures( int flags );

+	virtual bool				GetShadowCastDistance( float *pDist, ShadowType_t shadowType ) const			{ return false; }

+	virtual bool				GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const	{ return false; }

+	virtual bool				UsesPowerOfTwoFrameBufferTexture();

+	virtual bool				UsesFullFrameBufferTexture();

+	virtual bool				IgnoresZBuffer( void ) const { return false; }

+	virtual bool				LODTest() { return true; }

+

+	virtual ClientShadowHandle_t	GetShadowHandle() const;

+	virtual ClientRenderHandle_t&	RenderHandle();

+	virtual void				GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType );

+	virtual bool IsShadowDirty( )			     { return false; }

+	virtual void MarkShadowDirty( bool bDirty )  {}

+	virtual IClientRenderable *GetShadowParent() { return NULL; }

+	virtual IClientRenderable *FirstShadowChild(){ return NULL; }

+	virtual IClientRenderable *NextShadowPeer()  { return NULL; }

+	virtual ShadowType_t		ShadowCastType() { return SHADOWS_NONE; }

+	virtual void CreateModelInstance()			 {}

+	virtual ModelInstanceHandle_t GetModelInstance() { return MODEL_INSTANCE_INVALID; }

+	virtual int					LookupAttachment( const char *pAttachmentName ) { return -1; }

+	virtual bool				GetAttachment( int number, matrix3x4_t &matrix );

+	virtual	bool				GetAttachment( int number, Vector &origin, QAngle &angles );

+	virtual float *				GetRenderClipPlane() { return NULL; }

+	virtual int					GetSkin() { return 0; }

+	virtual void				RecordToolMessage() {}

+

+	void GetColorModulation( float* color );

+

+	// Computes the render angles for screen alignment

+	void ComputeAngles( void );

+

+	// Calls the correct rendering func

+	void DrawSprite( CMeshBuilder &meshBuilder );

+

+	// Returns the number of quads the sprite will draw

+	int QuadsToDraw() const;

+

+	// Draw functions for the different types of sprite

+	void DrawTypeSprite( CMeshBuilder &meshBuilder );

+

+

+#ifdef USE_DETAIL_SHAPES

+	void DrawTypeShapeCross( CMeshBuilder &meshBuilder );

+	void DrawTypeShapeTri( CMeshBuilder &meshBuilder );

+

+	// check for players nearby and angle away from them

+	void UpdatePlayerAvoid( void );

+

+	void InitShapedSprite( unsigned char shapeAngle, unsigned char shapeSize, unsigned char swayAmount );

+	void InitShapeTri();

+	void InitShapeCross();

+

+	void DrawSwayingQuad( CMeshBuilder &meshBuilder, Vector vecOrigin, Vector vecSway, Vector2D texul, Vector2D texlr, unsigned char *color,

+		Vector width, Vector height );

+#endif

+

+	int GetType() const { return m_Type; }

+	unsigned char GetAlpha() const { return m_Alpha; }

+

+	bool IsDetailModelTranslucent();

+

+	// IHandleEntity stubs.

+public:

+	virtual void SetRefEHandle( const CBaseHandle &handle )	{ Assert( false ); }

+	virtual const CBaseHandle& GetRefEHandle() const		{ Assert( false ); return *((CBaseHandle*)0); }

+

+	//---------------------------------

+	struct LightStyleInfo_t

+	{

+		unsigned int	m_LightStyle:24;

+		unsigned int	m_LightStyleCount:8;

+	};

+

+protected:

+	Vector	m_Origin;

+	QAngle	m_Angles;

+

+	ColorRGBExp32	m_Color;

+

+	unsigned char	m_Orientation:2;

+	unsigned char	m_Type:2;

+	unsigned char	m_bHasLightStyle:1;

+	unsigned char	m_bFlipped:1;

+

+	unsigned char	m_Alpha;

+

+	static CUtlMap<CDetailModel *, LightStyleInfo_t> gm_LightStylesMap;

+

+#pragma warning( disable : 4201 ) //warning C4201: nonstandard extension used : nameless struct/union

+	union

+	{

+		model_t* m_pModel;

+		SptrintInfo_t m_SpriteInfo;

+	};

+#pragma warning( default : 4201 )

+

+#ifdef USE_DETAIL_SHAPES

+	// pointer to advanced properties

+	DetailModelAdvInfo_t *m_pAdvInfo;

+#endif

+};

+

+static ConVar mat_fullbright( "mat_fullbright", "0", FCVAR_CHEAT ); // hook into engine's cvars..

+extern ConVar r_DrawDetailProps;

+

+

+//-----------------------------------------------------------------------------

+// Dictionary for detail sprites

+//-----------------------------------------------------------------------------

+struct DetailPropSpriteDict_t 

+{

+	Vector2D	m_UL;		// Coordinate of upper left

+	Vector2D	m_LR;		// Coordinate of lower right

+	Vector2D	m_TexUL;	// Texcoords of upper left

+	Vector2D	m_TexLR;	// Texcoords of lower left

+};

+

+struct FastSpriteX4_t

+{

+	// mess with this structure without care and you'll be in a world of trouble. layout matters.

+	FourVectors m_Pos;

+	fltx4 m_HalfWidth;

+	fltx4 m_Height;

+	uint8 m_RGBColor[4][4];

+	DetailPropSpriteDict_t *m_pSpriteDefs[4];

+

+	void ReplicateFirstEntryToOthers( void )

+	{

+		m_HalfWidth = ReplicateX4( SubFloat( m_HalfWidth, 0 ) );

+		m_Height = ReplicateX4( SubFloat( m_Height, 0 ) );

+

+		for( int i = 1; i < 4; i++ )

+			for( int j = 0; j < 4; j++ )

+			{

+				m_RGBColor[i][j] = m_RGBColor[0][j];

+			}

+		m_Pos.x = ReplicateX4( SubFloat( m_Pos.x, 0 ) );

+		m_Pos.y = ReplicateX4( SubFloat( m_Pos.y, 0 ) );

+		m_Pos.z = ReplicateX4( SubFloat( m_Pos.z, 0 ) );

+	}

+

+};

+

+

+struct FastSpriteQuadBuildoutBufferX4_t

+{

+	// mess with this structure without care and you'll be in a world of trouble. layout matters.

+	FourVectors m_Coords[4];

+	uint8 m_RGBColor[4][4];

+	fltx4 m_Alpha;

+	DetailPropSpriteDict_t *m_pSpriteDefs[4];

+};

+

+struct FastSpriteQuadBuildoutBufferNonSIMDView_t

+{

+	// mess with this structure without care and you'll be in a world of trouble. layout matters.

+	float m_flX0[4], m_flY0[4], m_flZ0[4];

+	float m_flX1[4], m_flY1[4], m_flZ1[4];

+	float m_flX2[4], m_flY2[4], m_flZ2[4];

+	float m_flX3[4], m_flY3[4], m_flZ3[4];

+

+	uint8 m_RGBColor[4][4];

+	float m_Alpha[4];

+	DetailPropSpriteDict_t *m_pSpriteDefs[4];

+};

+

+

+class CFastDetailLeafSpriteList : public CClientLeafSubSystemData

+{

+	friend class CDetailObjectSystem;

+	int m_nNumSprites;

+	int m_nNumSIMDSprites;									// #sprites/4, rounded up

+	// simd pointers into larger array - don't free individually or you will be sad

+	FastSpriteX4_t *m_pSprites;

+

+	// state for partially drawn sprite lists

+	int m_nNumPendingSprites;

+	int m_nStartSpriteIndex;

+

+	CFastDetailLeafSpriteList( void )

+	{

+		m_nNumPendingSprites = 0;

+		m_nStartSpriteIndex = 0;

+	}

+

+};

+

+

+

+

+//-----------------------------------------------------------------------------

+// Responsible for managing detail objects

+//-----------------------------------------------------------------------------

+class CDetailObjectSystem : public IDetailObjectSystem, public ISpatialLeafEnumerator

+{

+public:

+	char const *Name() { return "DetailObjectSystem"; }

+

+	// constructor, destructor

+	CDetailObjectSystem();

+	~CDetailObjectSystem();

+

+	bool IsPerFrame() { return false; }

+

+	// Init, shutdown

+	bool Init()

+	{

+		m_flDefaultFadeStart = cl_detailfade.GetFloat();

+		m_flDefaultFadeEnd = cl_detaildist.GetFloat();

+		return true;

+	}

+	void PostInit() {}

+	void Shutdown() {}

+

+	// Level init, shutdown

+	void LevelInitPreEntity();

+	void LevelInitPostEntity();

+	void LevelShutdownPreEntity();

+	void LevelShutdownPostEntity();

+

+	void OnSave() {}

+	void OnRestore() {}

+	void SafeRemoveIfDesired() {}

+

+    // Gets a particular detail object

+	IClientRenderable* GetDetailModel( int idx );

+

+	// Prepares detail for rendering 

+	void BuildDetailObjectRenderLists( const Vector &vViewOrigin );

+

+	// Renders all opaque detail objects in a particular set of leaves

+	void RenderOpaqueDetailObjects( int nLeafCount, LeafIndex_t *pLeafList );

+

+	// Renders all translucent detail objects in a particular set of leaves

+	void RenderTranslucentDetailObjects( const Vector &viewOrigin, const Vector &viewForward, const Vector &viewRight, const Vector &viewUp, int nLeafCount, LeafIndex_t *pLeafList );

+

+	// Renders all translucent detail objects in a particular leaf up to a particular point

+	void RenderTranslucentDetailObjectsInLeaf( const Vector &viewOrigin, const Vector &viewForward, const Vector &viewRight, const Vector &viewUp, int nLeaf, const Vector *pVecClosestPoint );

+	void RenderFastTranslucentDetailObjectsInLeaf( const Vector &viewOrigin, const Vector &viewForward, const Vector &viewRight, const Vector &viewUp, int nLeaf, const Vector *pVecClosestPoint );

+

+

+

+	// Call this before rendering translucent detail objects

+	void BeginTranslucentDetailRendering( );

+

+	// Method of ISpatialLeafEnumerator

+	bool EnumerateLeaf( int leaf, int context );

+

+	DetailPropLightstylesLump_t& DetailLighting( int i ) { return m_DetailLighting[i]; }

+	DetailPropSpriteDict_t& DetailSpriteDict( int i ) { return m_DetailSpriteDict[i]; }

+

+private:

+	struct DetailModelDict_t

+	{

+		model_t* m_pModel;

+	};

+

+	struct EnumContext_t

+	{

+		Vector m_vViewOrigin;

+		int	m_BuildWorldListNumber;

+	};

+

+	struct SortInfo_t

+	{

+		int m_nIndex;

+		float m_flDistance;

+	};

+

+	int BuildOutSortedSprites( CFastDetailLeafSpriteList *pData,

+							   Vector const &viewOrigin,

+							   Vector const &viewForward,

+							   Vector const &viewRight,

+							   Vector const &viewUp );

+

+	void RenderFastSprites( const Vector &viewOrigin, const Vector &viewForward, const Vector &viewRight, const Vector &viewUp, int nLeafCount, LeafIndex_t const * pLeafList );

+

+	void UnserializeFastSprite( FastSpriteX4_t *pSpritex4, int nSubField, DetailObjectLump_t const &lump, bool bFlipped, Vector const &posOffset );

+

+	// Unserialization

+	void ScanForCounts( CUtlBuffer& buf, int *pNumOldStyleObjects, 

+						int *pNumFastSpritesToAllocate, int *nMaxOldInLeaf,

+						int *nMaxFastInLeaf ) const;

+

+	void UnserializeModelDict( CUtlBuffer& buf );

+	void UnserializeDetailSprites( CUtlBuffer& buf );

+	void UnserializeModels( CUtlBuffer& buf );

+	void UnserializeModelLighting( CUtlBuffer& buf );

+

+	Vector GetSpriteMiddleBottomPosition( DetailObjectLump_t const &lump ) const;

+	// Count the number of detail sprites in the leaf list

+	int CountSpritesInLeafList( int nLeafCount, LeafIndex_t *pLeafList ) const;

+

+	// Count the number of detail sprite quads in the leaf list

+	int CountSpriteQuadsInLeafList( int nLeafCount, LeafIndex_t *pLeafList ) const;

+

+	int CountFastSpritesInLeafList( int nLeafCount, LeafIndex_t const *pLeafList, int *nMaxInLeaf ) const;

+

+	void FreeSortBuffers( void );

+

+	// Sorts sprites in back-to-front order

+	static bool SortLessFunc( const SortInfo_t &left, const SortInfo_t &right );

+	int SortSpritesBackToFront( int nLeaf, const Vector &viewOrigin, const Vector &viewForward, SortInfo_t *pSortInfo );

+

+	// For fast detail object insertion

+	IterationRetval_t EnumElement( int userId, int context );

+

+	CUtlVector<DetailModelDict_t>			m_DetailObjectDict;

+	CUtlVector<CDetailModel>				m_DetailObjects;

+	CUtlVector<DetailPropSpriteDict_t>		m_DetailSpriteDict;

+	CUtlVector<DetailPropSpriteDict_t>		m_DetailSpriteDictFlipped;

+	CUtlVector<DetailPropLightstylesLump_t>	m_DetailLighting;

+	FastSpriteX4_t *m_pFastSpriteData;

+

+	// Necessary to get sprites to batch correctly

+	CMaterialReference m_DetailSpriteMaterial;

+	CMaterialReference m_DetailWireframeMaterial;

+

+	// State stored off for rendering detail sprites in a single leaf

+	int m_nSpriteCount;

+	int m_nFirstSprite;

+	int m_nSortedLeaf;

+	int m_nSortedFastLeaf;

+	SortInfo_t *m_pSortInfo;

+	SortInfo_t *m_pFastSortInfo;

+	FastSpriteQuadBuildoutBufferX4_t *m_pBuildoutBuffer;

+

+	float m_flDefaultFadeStart;

+	float m_flDefaultFadeEnd;

+

+

+	// pre calcs for the current render frame

+	float m_flCurMaxSqDist;

+	float m_flCurFadeSqDist;

+	float m_flCurFalloffFactor;

+

+};

+

+

+//-----------------------------------------------------------------------------

+// System for dealing with detail objects

+//-----------------------------------------------------------------------------

+static CDetailObjectSystem s_DetailObjectSystem;

+

+IDetailObjectSystem* DetailObjectSystem()

+{

+	return &s_DetailObjectSystem;

+}

+

+

+

+//-----------------------------------------------------------------------------

+// Initialization

+//-----------------------------------------------------------------------------

+

+CUtlMap<CDetailModel *, CDetailModel::LightStyleInfo_t> CDetailModel::gm_LightStylesMap( DefLessFunc( CDetailModel * ) );

+

+bool CDetailModel::InitCommon( int index, const Vector& org, const QAngle& angles )

+{

+	VectorCopy( org, m_Origin );

+	VectorCopy( angles, m_Angles );

+	m_Alpha = 255;

+

+	return true;

+}

+

+

+//-----------------------------------------------------------------------------

+// Inline methods

+//-----------------------------------------------------------------------------

+

+// NOTE: If DetailPropType_t enum changes, change CDetailModel::QuadsToDraw

+static int s_pQuadCount[4] =

+{

+	0, //DETAIL_PROP_TYPE_MODEL

+	1, //DETAIL_PROP_TYPE_SPRITE

+	4, //DETAIL_PROP_TYPE_SHAPE_CROSS

+	3, //DETAIL_PROP_TYPE_SHAPE_TRI

+};

+

+inline int CDetailModel::QuadsToDraw() const

+{

+	return s_pQuadCount[m_Type];

+}

+

+	

+//-----------------------------------------------------------------------------

+// Data accessors

+//-----------------------------------------------------------------------------

+const Vector& CDetailModel::GetRenderOrigin( void )

+{

+	return m_Origin;

+}

+

+const QAngle& CDetailModel::GetRenderAngles( void )

+{

+	return m_Angles;

+}

+

+const matrix3x4_t &CDetailModel::RenderableToWorldTransform()

+{

+	// Setup our transform.

+	static matrix3x4_t mat;

+	AngleMatrix( GetRenderAngles(), GetRenderOrigin(), mat );

+	return mat;

+}

+

+bool CDetailModel::GetAttachment( int number, matrix3x4_t &matrix )

+{

+	MatrixCopy( RenderableToWorldTransform(), matrix );

+	return true;

+}

+

+bool CDetailModel::GetAttachment( int number, Vector &origin, QAngle &angles )

+{

+	origin = m_Origin;

+	angles = m_Angles;

+	return true;

+}

+

+bool CDetailModel::IsTransparent( void )

+{

+	return (m_Alpha < 255) || modelinfo->IsTranslucent(m_pModel);

+}

+

+bool CDetailModel::ShouldDraw()

+{

+	// Don't draw in commander mode

+	return g_pClientMode->ShouldDrawDetailObjects();

+}

+

+void CDetailModel::GetRenderBounds( Vector& mins, Vector& maxs )

+{

+	int nModelType = modelinfo->GetModelType( m_pModel );

+	if (nModelType == mod_studio || nModelType == mod_brush)

+	{

+		modelinfo->GetModelRenderBounds( GetModel(), mins, maxs );

+	}

+	else

+	{

+		mins.Init( 0,0,0 );

+		maxs.Init( 0,0,0 );

+	}

+}

+

+IPVSNotify* CDetailModel::GetPVSNotifyInterface()

+{

+	return NULL;

+}

+

+void CDetailModel::GetRenderBoundsWorldspace( Vector& mins, Vector& maxs )

+{

+	DefaultRenderBoundsWorldspace( this, mins, maxs );

+}

+

+bool CDetailModel::ShouldReceiveProjectedTextures( int flags )

+{

+	return false;

+}

+

+bool CDetailModel::UsesPowerOfTwoFrameBufferTexture()

+{

+	return false;

+}

+

+bool CDetailModel::UsesFullFrameBufferTexture()

+{

+	return false;

+}

+

+void CDetailModel::GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType )

+{

+	GetRenderBounds( mins, maxs );

+}

+

+ClientShadowHandle_t CDetailModel::GetShadowHandle() const

+{

+	return CLIENTSHADOW_INVALID_HANDLE;

+}

+

+ClientRenderHandle_t& CDetailModel::RenderHandle()

+{

+	AssertMsg( 0, "CDetailModel has no render handle" );

+	return *((ClientRenderHandle_t*)NULL);

+}	

+

+

+//-----------------------------------------------------------------------------

+// Render setup

+//-----------------------------------------------------------------------------

+bool CDetailModel::SetupBones( matrix3x4_t *pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime )

+{

+	if (!m_pModel)

+		return false;

+

+	// Setup our transform.

+	matrix3x4_t parentTransform;

+	const QAngle &vRenderAngles = GetRenderAngles();

+	const Vector &vRenderOrigin = GetRenderOrigin();

+	AngleMatrix( vRenderAngles, parentTransform );

+	parentTransform[0][3] = vRenderOrigin.x;

+	parentTransform[1][3] = vRenderOrigin.y;

+	parentTransform[2][3] = vRenderOrigin.z;

+

+	// Just copy it on down baby

+	studiohdr_t *pStudioHdr = modelinfo->GetStudiomodel( m_pModel );

+	for (int i = 0; i < pStudioHdr->numbones; i++) 

+	{

+		MatrixCopy( parentTransform, pBoneToWorldOut[i] );

+	}

+

+	return true;

+}

+

+void	CDetailModel::SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights )

+{

+}

+

+void	CDetailModel::DoAnimationEvents( void )

+{

+}

+

+

+//-----------------------------------------------------------------------------

+// Render baby!

+//-----------------------------------------------------------------------------

+const model_t* CDetailModel::GetModel( ) const

+{

+	return m_pModel;

+}

+

+int CDetailModel::DrawModel( int flags )

+{

+	if ((m_Alpha == 0) || (!m_pModel))

+		return 0;

+

+	int drawn = modelrender->DrawModel( 

+		flags, 

+		this,

+		MODEL_INSTANCE_INVALID,

+		-1,		// no entity index

+		m_pModel,

+		m_Origin,

+		m_Angles,

+		0,	// skin

+		0,	// body

+		0  // hitboxset

+		);

+	return drawn;

+}

+

+

+//-----------------------------------------------------------------------------

+// Determine alpha and blend amount for transparent objects based on render state info

+//-----------------------------------------------------------------------------

+void CDetailModel::ComputeFxBlend( )

+{

+	// Do nothing, it's already calculate in our m_Alpha

+}

+

+int CDetailModel::GetFxBlend( )

+{

+	return m_Alpha;

+}

+

+//-----------------------------------------------------------------------------

+// Detail models stuff

+//-----------------------------------------------------------------------------

+CDetailModel::CDetailModel()

+{

+	m_Color.r = m_Color.g = m_Color.b = 255;

+	m_Color.exponent = 0;

+	m_bFlipped = 0;

+	m_bHasLightStyle = 0;

+

+#ifdef USE_DETAIL_SHAPES

+	m_pAdvInfo = NULL;

+#endif

+}

+

+//-----------------------------------------------------------------------------

+// Destructor

+//-----------------------------------------------------------------------------

+CDetailModel::~CDetailModel()

+{

+#ifdef USE_DETAIL_SHAPES

+	// delete advanced

+	if ( m_pAdvInfo )

+	{

+		delete m_pAdvInfo;

+		m_pAdvInfo = NULL;

+	}

+#endif

+

+	if ( m_bHasLightStyle )

+		gm_LightStylesMap.Remove( this );

+}

+

+

+//-----------------------------------------------------------------------------

+// Initialization

+//-----------------------------------------------------------------------------

+bool CDetailModel::Init( int index, const Vector& org, const QAngle& angles, 

+	model_t* pModel, ColorRGBExp32 lighting, int lightstyle, unsigned char lightstylecount, 

+	int orientation)

+{

+	m_Color = lighting;

+	if ( lightstylecount > 0)

+	{

+		m_bHasLightStyle = 1;

+		int iInfo = gm_LightStylesMap.Insert( this );

+		if ( lightstyle >= 0x1000000 || lightstylecount >= 100  )

+			Error( "Light style overflow\n" );

+		gm_LightStylesMap[iInfo].m_LightStyle = lightstyle;

+		gm_LightStylesMap[iInfo].m_LightStyleCount = lightstylecount;

+	}

+	m_Orientation = orientation;

+	m_Type = DETAIL_PROP_TYPE_MODEL;

+	m_pModel = pModel;

+	return InitCommon( index, org, angles );

+}

+

+bool CDetailModel::InitSprite( int index, bool bFlipped, const Vector& org, const QAngle& angles, unsigned short nSpriteIndex, 

+	ColorRGBExp32 lighting, int lightstyle, unsigned char lightstylecount, int orientation, float flScale,

+	unsigned char type, unsigned char shapeAngle, unsigned char shapeSize, unsigned char swayAmount )

+{

+	m_Color = lighting;

+	if ( lightstylecount > 0)

+	{

+		m_bHasLightStyle = 1;

+		int iInfo = gm_LightStylesMap.Insert( this );

+		if ( lightstyle >= 0x1000000 || lightstylecount >= 100  )

+			Error( "Light style overflow\n" );

+		gm_LightStylesMap[iInfo].m_LightStyle = lightstyle;

+		gm_LightStylesMap[iInfo].m_LightStyleCount = lightstylecount;

+	}

+	m_Orientation = orientation;

+	m_SpriteInfo.m_nSpriteIndex = nSpriteIndex;

+	m_Type = type;

+	m_SpriteInfo.m_flScale.SetFloat( flScale );

+

+#ifdef USE_DETAIL_SHAPES

+	m_pAdvInfo = NULL;

+	Assert( type <= 3 );

+	// precalculate angles for shapes

+	if ( type == DETAIL_PROP_TYPE_SHAPE_TRI || type == DETAIL_PROP_TYPE_SHAPE_CROSS || swayAmount > 0 )

+	{

+		m_Angles = angles;

+		InitShapedSprite( shapeAngle, shapeSize, swayAmount);

+	}

+

+#endif

+

+	m_bFlipped = bFlipped;

+	return InitCommon( index, org, angles );

+}

+

+#ifdef USE_DETAIL_SHAPES

+void CDetailModel::InitShapedSprite( unsigned char shapeAngle, unsigned char shapeSize, unsigned char swayAmount )

+{

+	// Set up pointer to advanced shape properties object ( per instance )

+	Assert( m_pAdvInfo == NULL );

+	m_pAdvInfo = new DetailModelAdvInfo_t;

+	Assert( m_pAdvInfo );

+

+	if ( m_pAdvInfo )

+	{

+		m_pAdvInfo->m_iShapeAngle = shapeAngle;

+		m_pAdvInfo->m_flSwayAmount = (float)swayAmount / 255.0f;

+		m_pAdvInfo->m_flShapeSize = (float)shapeSize / 255.0f;

+		m_pAdvInfo->m_vecCurrentAvoid = vec3_origin;

+		m_pAdvInfo->m_flSwayYaw = random->RandomFloat( 0, 180 );

+	}

+

+	switch ( m_Type )

+	{

+	case DETAIL_PROP_TYPE_SHAPE_TRI:

+		InitShapeTri();

+		break;

+

+	case DETAIL_PROP_TYPE_SHAPE_CROSS:

+		InitShapeCross();

+		break;

+

+	default:	// sprite will get here

+		break;

+	}

+}

+

+void CDetailModel::InitShapeTri( void )

+{

+	// store the three sets of directions

+	matrix3x4_t matrix;

+

+	// Convert roll/pitch only to matrix

+	AngleMatrix( m_Angles, matrix );

+

+	// calculate the vectors for the three sides so they can be used in the sorting test

+	// as well as in drawing

+	for ( int i=0; i<3; i++ )

+	{		

+		// Convert desired rotation to angles

+		QAngle anglesRotated( m_pAdvInfo->m_iShapeAngle, i*120, 0 );

+

+		Vector rotForward, rotRight, rotUp;

+		AngleVectors( anglesRotated, &rotForward, &rotRight, &rotUp );

+

+		// Rotate direction vectors

+		VectorRotate( rotForward, matrix, m_pAdvInfo->m_vecAnglesForward[i] );

+		VectorRotate( rotRight, matrix, m_pAdvInfo->m_vecAnglesRight[i] );

+		VectorRotate( rotUp, matrix, m_pAdvInfo->m_vecAnglesUp[i] );

+	}

+}

+

+void CDetailModel::InitShapeCross( void )

+{

+	AngleVectors( m_Angles,

+		&m_pAdvInfo->m_vecAnglesForward[0],

+		&m_pAdvInfo->m_vecAnglesRight[0],

+		&m_pAdvInfo->m_vecAnglesUp[0] );

+}

+#endif

+

+//-----------------------------------------------------------------------------

+// Color, alpha modulation

+//-----------------------------------------------------------------------------

+void CDetailModel::GetColorModulation( float *color )

+{

+	if (mat_fullbright.GetInt() == 1)

+	{

+		color[0] = color[1] = color[2] = 1.0f;

+		return;

+	}

+

+	Vector tmp;

+	Vector normal( 1, 0, 0);

+	engine->ComputeDynamicLighting( m_Origin, &normal, tmp );

+

+	float val = engine->LightStyleValue( 0 );

+	color[0] = tmp[0] + val * TexLightToLinear( m_Color.r, m_Color.exponent );

+	color[1] = tmp[1] + val * TexLightToLinear( m_Color.g, m_Color.exponent );

+	color[2] = tmp[2] + val * TexLightToLinear( m_Color.b, m_Color.exponent );

+

+	// Add in the lightstyles

+	if ( m_bHasLightStyle )

+	{

+		int iInfo = gm_LightStylesMap.Find( this );

+		Assert( iInfo != gm_LightStylesMap.InvalidIndex() );

+		if ( iInfo != gm_LightStylesMap.InvalidIndex() )

+		{

+			int nLightStyles = gm_LightStylesMap[iInfo].m_LightStyleCount;

+			int iLightStyle = gm_LightStylesMap[iInfo].m_LightStyle;

+			for (int i = 0; i < nLightStyles; ++i)

+			{

+				DetailPropLightstylesLump_t& lighting = s_DetailObjectSystem.DetailLighting( iLightStyle + i );

+				val = engine->LightStyleValue( lighting.m_Style );

+				if (val != 0)

+				{

+					color[0] += val * TexLightToLinear( lighting.m_Lighting.r, lighting.m_Lighting.exponent ); 

+					color[1] += val * TexLightToLinear( lighting.m_Lighting.g, lighting.m_Lighting.exponent ); 

+					color[2] += val * TexLightToLinear( lighting.m_Lighting.b, lighting.m_Lighting.exponent ); 

+				}

+			}

+		}

+	}

+

+	// Gamma correct....

+	engine->LinearToGamma( color, color );

+}

+

+

+//-----------------------------------------------------------------------------

+// Is the model itself translucent, regardless of modulation?

+//-----------------------------------------------------------------------------

+bool CDetailModel::IsDetailModelTranslucent()

+{

+	// FIXME: This is only true for my first pass of this feature

+	if (m_Type >= DETAIL_PROP_TYPE_SPRITE)

+		return true;

+

+	return modelinfo->IsTranslucent(GetModel());

+}

+

+

+//-----------------------------------------------------------------------------

+// Computes the render angles for screen alignment

+//-----------------------------------------------------------------------------

+void CDetailModel::ComputeAngles( void )

+{

+	switch( m_Orientation )

+	{

+	case 0:

+		break;

+

+	case 1:

+		{

+			Vector vecDir;

+			VectorSubtract( CurrentViewOrigin(), m_Origin, vecDir );

+			VectorAngles( vecDir, m_Angles );

+		}

+		break;

+

+	case 2:

+		{

+			Vector vecDir;

+			VectorSubtract( CurrentViewOrigin(), m_Origin, vecDir );

+			vecDir.z = 0.0f;

+			VectorAngles( vecDir, m_Angles );

+		}

+		break;

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Select which rendering func to call

+//-----------------------------------------------------------------------------

+void CDetailModel::DrawSprite( CMeshBuilder &meshBuilder )

+{

+	switch( m_Type )

+	{

+#ifdef USE_DETAIL_SHAPES

+	case DETAIL_PROP_TYPE_SHAPE_CROSS:

+		DrawTypeShapeCross( meshBuilder );

+		break;

+

+	case DETAIL_PROP_TYPE_SHAPE_TRI:

+		DrawTypeShapeTri( meshBuilder );

+		break;

+#endif

+	case DETAIL_PROP_TYPE_SPRITE:

+		DrawTypeSprite( meshBuilder );

+		break;

+

+	default:

+		Assert(0);

+		break;

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Draws the single sprite type

+//-----------------------------------------------------------------------------

+void CDetailModel::DrawTypeSprite( CMeshBuilder &meshBuilder )

+{

+	Assert( m_Type == DETAIL_PROP_TYPE_SPRITE );

+

+	Vector vecColor;

+	GetColorModulation( vecColor.Base() );

+

+	unsigned char color[4];

+	color[0] = (unsigned char)(vecColor[0] * 255.0f);

+	color[1] = (unsigned char)(vecColor[1] * 255.0f);

+	color[2] = (unsigned char)(vecColor[2] * 255.0f);

+	color[3] = m_Alpha;

+

+	DetailPropSpriteDict_t &dict = s_DetailObjectSystem.DetailSpriteDict( m_SpriteInfo.m_nSpriteIndex );

+

+	Vector vecOrigin, dx, dy;

+	AngleVectors( m_Angles, NULL, &dx, &dy );

+

+	Vector2D ul, lr;

+	float scale = m_SpriteInfo.m_flScale.GetFloat();

+	Vector2DMultiply( dict.m_UL, scale, ul );

+	Vector2DMultiply( dict.m_LR, scale, lr );

+

+#ifdef USE_DETAIL_SHAPES

+	UpdatePlayerAvoid();

+

+	Vector vecSway = vec3_origin;

+

+	if ( m_pAdvInfo )

+	{

+		vecSway = m_pAdvInfo->m_vecCurrentAvoid * m_SpriteInfo.m_flScale.GetFloat();

+		float flSwayAmplitude = m_pAdvInfo->m_flSwayAmount * cl_detail_max_sway.GetFloat();

+		if ( flSwayAmplitude > 0 )

+		{

+			// sway based on time plus a random seed that is constant for this instance of the sprite

+			vecSway += dx * sin(gpGlobals->curtime+m_Origin.x) * flSwayAmplitude;

+		}

+	}

+#endif

+

+	VectorMA( m_Origin, ul.x, dx, vecOrigin );

+	VectorMA( vecOrigin, ul.y, dy, vecOrigin );

+	dx *= (lr.x - ul.x);

+	dy *= (lr.y - ul.y);

+

+	Vector2D texul, texlr;

+	texul = dict.m_TexUL;

+	texlr = dict.m_TexLR;

+

+	if ( !m_bFlipped )

+	{

+		texul.x = dict.m_TexLR.x;

+		texlr.x = dict.m_TexUL.x;

+	}

+

+#ifndef USE_DETAIL_SHAPES

+	meshBuilder.Position3fv( vecOrigin.Base() );

+#else

+	meshBuilder.Position3fv( (vecOrigin+vecSway).Base() );

+#endif

+

+	meshBuilder.Color4ubv( color );

+	meshBuilder.TexCoord2fv( 0, texul.Base() );

+	meshBuilder.AdvanceVertex();

+

+	vecOrigin += dy;

+	meshBuilder.Position3fv( vecOrigin.Base() );

+	meshBuilder.Color4ubv( color );

+	meshBuilder.TexCoord2f( 0, texul.x, texlr.y );

+	meshBuilder.AdvanceVertex();

+

+	vecOrigin += dx;

+	meshBuilder.Position3fv( vecOrigin.Base() );

+	meshBuilder.Color4ubv( color );

+	meshBuilder.TexCoord2fv( 0, texlr.Base() );

+	meshBuilder.AdvanceVertex();

+

+	vecOrigin -= dy;

+#ifndef USE_DETAIL_SHAPES

+	meshBuilder.Position3fv( vecOrigin.Base() );

+#else

+	meshBuilder.Position3fv( (vecOrigin+vecSway).Base() );

+#endif

+	meshBuilder.Color4ubv( color );

+	meshBuilder.TexCoord2f( 0, texlr.x, texul.y );

+	meshBuilder.AdvanceVertex();

+}

+

+//-----------------------------------------------------------------------------

+// draws a procedural model, cross shape

+// two perpendicular sprites

+//-----------------------------------------------------------------------------

+#ifdef USE_DETAIL_SHAPES

+void CDetailModel::DrawTypeShapeCross( CMeshBuilder &meshBuilder )

+{

+	Assert( m_Type == DETAIL_PROP_TYPE_SHAPE_CROSS );

+

+	Vector vecColor;

+	GetColorModulation( vecColor.Base() );

+

+	unsigned char color[4];

+	color[0] = (unsigned char)(vecColor[0] * 255.0f);

+	color[1] = (unsigned char)(vecColor[1] * 255.0f);

+	color[2] = (unsigned char)(vecColor[2] * 255.0f);

+	color[3] = m_Alpha;

+

+	DetailPropSpriteDict_t &dict = s_DetailObjectSystem.DetailSpriteDict( m_SpriteInfo.m_nSpriteIndex );

+

+	Vector2D texul, texlr;

+	texul = dict.m_TexUL;

+	texlr = dict.m_TexLR;

+

+	// What a shameless re-use of bits (m_pModel == 0 when it should be flipped horizontally)

+	if ( !m_pModel )

+	{

+		texul.x = dict.m_TexLR.x;

+		texlr.x = dict.m_TexUL.x;

+	}

+

+	Vector2D texumid, texlmid;

+	texumid.y = texul.y;

+	texlmid.y = texlr.y;

+	texumid.x = texlmid.x = ( texul.x + texlr.x ) / 2;

+

+	Vector2D texll;

+	texll.x = texul.x;

+	texll.y = texlr.y;

+

+	Vector2D ul, lr;

+	float flScale = m_SpriteInfo.m_flScale.GetFloat();

+	Vector2DMultiply( dict.m_UL, flScale, ul );

+	Vector2DMultiply( dict.m_LR, flScale, lr );

+

+	float flSizeX = ( lr.x - ul.x ) / 2;

+	float flSizeY = ( lr.y - ul.y );

+

+	UpdatePlayerAvoid();

+

+	// sway based on time plus a random seed that is constant for this instance of the sprite

+	Vector vecSway = ( m_pAdvInfo->m_vecCurrentAvoid * flSizeX * 2 );

+	float flSwayAmplitude = m_pAdvInfo->m_flSwayAmount * cl_detail_max_sway.GetFloat();

+	if ( flSwayAmplitude > 0 )

+	{

+		vecSway += UTIL_YawToVector( m_pAdvInfo->m_flSwayYaw ) * sin(gpGlobals->curtime+m_Origin.x) * flSwayAmplitude;

+	}

+

+	Vector vecOrigin;

+	VectorMA( m_Origin, ul.y, m_pAdvInfo->m_vecAnglesUp[0], vecOrigin );

+

+	Vector forward, right, up;

+	forward = m_pAdvInfo->m_vecAnglesForward[0] * flSizeX;

+	right = m_pAdvInfo->m_vecAnglesRight[0] * flSizeX;

+	up = m_pAdvInfo->m_vecAnglesUp[0] * flSizeY;

+

+	// figure out drawing order so the branches sort properly

+	// do dot products with the forward and right vectors to determine the quadrant the viewer is in

+	// assume forward points North , right points East

+	/*

+			   N

+			   |

+			3  |  0

+		  W---------E

+			2  |  1

+			   |

+			   S

+	*/ 

+	// eg if they are in quadrant 0, set iBranch to 0, and the draw order will be

+	// 0, 1, 2, 3, or South, west, north, east

+	Vector viewOffset = CurrentViewOrigin() - m_Origin;

+	bool bForward = ( DotProduct( forward, viewOffset ) > 0 );

+	bool bRight = ( DotProduct( right, viewOffset ) > 0 );	

+	int iBranch = bForward ? ( bRight ? 0 : 3 ) : ( bRight ? 1 : 2 );

+

+	//debugoverlay->AddLineOverlay( m_Origin, m_Origin + right * 20, 255, 0, 0, true, 0.01 );

+	//debugoverlay->AddLineOverlay( m_Origin, m_Origin + forward * 20, 0, 0, 255, true, 0.01 );

+

+	int iDrawn = 0;

+	while( iDrawn < 4 )

+	{

+		switch( iBranch )

+		{

+		case 0:		// south

+			DrawSwayingQuad( meshBuilder, vecOrigin, vecSway, texumid, texlr, color, -forward, up );

+			break;

+		case 1:		// west

+			DrawSwayingQuad( meshBuilder, vecOrigin, vecSway, texumid, texll, color, -right, up );

+			break;

+		case 2:		// north

+			DrawSwayingQuad( meshBuilder, vecOrigin, vecSway, texumid, texll, color, forward, up );

+			break;

+		case 3:		// east

+			DrawSwayingQuad( meshBuilder, vecOrigin, vecSway, texumid, texlr, color, right, up );

+			break;

+		}

+

+		iDrawn++;

+		iBranch++;

+		if ( iBranch > 3 )

+			iBranch = 0;

+	}	

+}

+#endif

+

+//-----------------------------------------------------------------------------

+// draws a procedural model, tri shape

+//-----------------------------------------------------------------------------

+#ifdef USE_DETAIL_SHAPES

+void CDetailModel::DrawTypeShapeTri( CMeshBuilder &meshBuilder )

+{

+	Assert( m_Type == DETAIL_PROP_TYPE_SHAPE_TRI );

+

+	Vector vecColor;

+	GetColorModulation( vecColor.Base() );

+

+	unsigned char color[4];

+	color[0] = (unsigned char)(vecColor[0] * 255.0f);

+	color[1] = (unsigned char)(vecColor[1] * 255.0f);

+	color[2] = (unsigned char)(vecColor[2] * 255.0f);

+	color[3] = m_Alpha;

+

+	DetailPropSpriteDict_t &dict = s_DetailObjectSystem.DetailSpriteDict( m_SpriteInfo.m_nSpriteIndex );

+

+	Vector2D texul, texlr;

+	texul = dict.m_TexUL;

+	texlr = dict.m_TexLR;

+

+	// What a shameless re-use of bits (m_pModel == 0 when it should be flipped horizontally)

+	if ( !m_pModel )

+	{

+		texul.x = dict.m_TexLR.x;

+		texlr.x = dict.m_TexUL.x;

+	}

+

+	Vector2D ul, lr;

+	float flScale = m_SpriteInfo.m_flScale.GetFloat();

+	Vector2DMultiply( dict.m_UL, flScale, ul );

+	Vector2DMultiply( dict.m_LR, flScale, lr );

+

+	// sort the sides relative to the view origin

+	Vector viewOffset = CurrentViewOrigin() - m_Origin;

+

+	// three sides, A, B, C, counter-clockwise from A is the unrotated side

+	bool bOutsideA = DotProduct( m_pAdvInfo->m_vecAnglesForward[0], viewOffset ) > 0;

+	bool bOutsideB = DotProduct( m_pAdvInfo->m_vecAnglesForward[1], viewOffset ) > 0;

+	bool bOutsideC = DotProduct( m_pAdvInfo->m_vecAnglesForward[2], viewOffset ) > 0;

+

+	int iBranch = 0;

+	if ( bOutsideA && !bOutsideB )

+		iBranch = 1;

+	else if ( bOutsideB && !bOutsideC )

+		iBranch = 2;

+

+	float flHeight, flWidth;

+	flHeight = (lr.y - ul.y);

+	flWidth = (lr.x - ul.x);

+

+	Vector vecSway;

+	Vector vecOrigin;

+	Vector vecHeight, vecWidth;

+

+	UpdatePlayerAvoid();

+

+	Vector vecSwayYaw = UTIL_YawToVector( m_pAdvInfo->m_flSwayYaw );

+	float flSwayAmplitude = m_pAdvInfo->m_flSwayAmount * cl_detail_max_sway.GetFloat();

+

+	int iDrawn = 0;

+	while( iDrawn < 3 )

+	{

+		vecHeight = m_pAdvInfo->m_vecAnglesUp[iBranch] * flHeight;

+		vecWidth = m_pAdvInfo->m_vecAnglesRight[iBranch] * flWidth;

+

+		VectorMA( m_Origin, ul.x, m_pAdvInfo->m_vecAnglesRight[iBranch], vecOrigin );

+		VectorMA( vecOrigin, ul.y, m_pAdvInfo->m_vecAnglesUp[iBranch], vecOrigin );

+		VectorMA( vecOrigin, m_pAdvInfo->m_flShapeSize*flWidth, m_pAdvInfo->m_vecAnglesForward[iBranch], vecOrigin );

+

+		// sway is calculated per side so they don't sway exactly the same

+		Vector vecSway = ( m_pAdvInfo->m_vecCurrentAvoid * flWidth ) + 

+			vecSwayYaw * sin(gpGlobals->curtime+m_Origin.x+iBranch) * flSwayAmplitude;

+

+		DrawSwayingQuad( meshBuilder, vecOrigin, vecSway, texul, texlr, color, vecWidth, vecHeight );

+		

+		iDrawn++;

+		iBranch++;

+		if ( iBranch > 2 )

+			iBranch = 0;

+	}	

+}

+#endif

+

+//-----------------------------------------------------------------------------

+// checks for nearby players and pushes the detail to the side

+//-----------------------------------------------------------------------------

+#ifdef USE_DETAIL_SHAPES

+void CDetailModel::UpdatePlayerAvoid( void )

+{

+	float flForce = cl_detail_avoid_force.GetFloat();

+

+	if ( flForce < 0.1 )

+		return;

+

+	if ( m_pAdvInfo == NULL )

+		return;

+

+	// get players in a radius

+	float flRadius = cl_detail_avoid_radius.GetFloat();

+	float flRecoverSpeed = cl_detail_avoid_recover_speed.GetFloat();

+

+	Vector vecAvoid;

+	C_BaseEntity *pEnt;

+

+	float flMaxForce = 0;

+	Vector vecMaxAvoid(0,0,0);

+

+	CPlayerEnumerator avoid( flRadius, m_Origin );

+	::partition->EnumerateElementsInSphere( PARTITION_CLIENT_SOLID_EDICTS, m_Origin, flRadius, false, &avoid );

+

+	// Okay, decide how to avoid if there's anything close by

+	int c = avoid.GetObjectCount();

+	for ( int i=0; i<c+1; i++ )	// +1 for the local player we tack on the end

+	{

+		if ( i == c )

+		{

+			pEnt = C_BasePlayer::GetLocalPlayer();

+			if ( !pEnt ) continue;

+		}

+		else

+			pEnt = avoid.GetObject( i );

+		

+		vecAvoid = m_Origin - pEnt->GetAbsOrigin();

+		vecAvoid.z = 0;

+

+		float flDist = vecAvoid.Length2D();

+

+		if ( flDist > flRadius )

+			continue;

+

+		float flForceScale = RemapValClamped( flDist, 0, flRadius, flForce, 0.0 );

+

+		if ( flForceScale > flMaxForce )

+		{

+			flMaxForce = flForceScale;

+			vecAvoid.NormalizeInPlace();

+			vecAvoid *= flMaxForce;

+			vecMaxAvoid = vecAvoid;

+		}

+	}

+

+	// if we are being moved, move fast. Else we recover at a slow rate

+	if ( vecMaxAvoid.Length2D() > m_pAdvInfo->m_vecCurrentAvoid.Length2D() )

+		flRecoverSpeed = 10;	// fast approach

+

+	m_pAdvInfo->m_vecCurrentAvoid[0] = Approach( vecMaxAvoid[0], m_pAdvInfo->m_vecCurrentAvoid[0], flRecoverSpeed );

+	m_pAdvInfo->m_vecCurrentAvoid[1] = Approach( vecMaxAvoid[1], m_pAdvInfo->m_vecCurrentAvoid[1], flRecoverSpeed );

+	m_pAdvInfo->m_vecCurrentAvoid[2] = Approach( vecMaxAvoid[2], m_pAdvInfo->m_vecCurrentAvoid[2], flRecoverSpeed );

+}

+#endif

+

+//-----------------------------------------------------------------------------

+// draws a quad that sways on the top two vertices

+// pass vecOrigin as the top left vertex position

+//-----------------------------------------------------------------------------

+#ifdef USE_DETAIL_SHAPES

+void CDetailModel::DrawSwayingQuad( CMeshBuilder &meshBuilder, Vector vecOrigin, Vector vecSway, Vector2D texul, Vector2D texlr, unsigned char *color,

+								   Vector width, Vector height )

+{

+	meshBuilder.Position3fv( (vecOrigin + vecSway).Base() );

+	meshBuilder.TexCoord2fv( 0, texul.Base() );

+	meshBuilder.Color4ubv( color );

+	meshBuilder.AdvanceVertex();

+

+	vecOrigin += height;

+	meshBuilder.Position3fv( vecOrigin.Base() );

+	meshBuilder.TexCoord2f( 0, texul.x, texlr.y );

+	meshBuilder.Color4ubv( color );

+	meshBuilder.AdvanceVertex();

+

+	vecOrigin += width;

+	meshBuilder.Position3fv( vecOrigin.Base() );

+	meshBuilder.TexCoord2fv( 0, texlr.Base() );

+	meshBuilder.Color4ubv( color );

+	meshBuilder.AdvanceVertex();

+

+	vecOrigin -= height;

+	meshBuilder.Position3fv( (vecOrigin + vecSway).Base() );

+	meshBuilder.TexCoord2f( 0, texlr.x, texul.y );

+	meshBuilder.Color4ubv( color );

+	meshBuilder.AdvanceVertex();

+}

+#endif

+

+//-----------------------------------------------------------------------------

+// constructor, destructor

+//-----------------------------------------------------------------------------

+CDetailObjectSystem::CDetailObjectSystem() : m_DetailSpriteDict( 0, 32 ), m_DetailObjectDict( 0, 32 ), m_DetailSpriteDictFlipped( 0, 32 )

+{

+	m_pFastSpriteData = NULL;

+	m_pSortInfo = NULL;

+	m_pFastSortInfo = NULL;

+	m_pBuildoutBuffer = NULL;

+}

+

+void CDetailObjectSystem::FreeSortBuffers( void )

+{

+	if ( m_pSortInfo )

+	{

+		MemAlloc_FreeAligned(  m_pSortInfo );

+		m_pSortInfo = NULL;

+	}

+	if ( m_pFastSortInfo )

+	{

+		MemAlloc_FreeAligned(  m_pFastSortInfo );

+		m_pFastSortInfo = NULL;

+	}

+	if ( m_pBuildoutBuffer )

+	{

+		MemAlloc_FreeAligned(  m_pBuildoutBuffer );

+		m_pBuildoutBuffer = NULL;

+	}

+}

+

+CDetailObjectSystem::~CDetailObjectSystem()

+{

+	if ( m_pFastSpriteData )

+	{

+		MemAlloc_FreeAligned( m_pFastSpriteData );

+		m_pFastSpriteData = NULL;

+	}

+	FreeSortBuffers();

+

+}

+

+	   

+//-----------------------------------------------------------------------------

+// Level init, shutdown

+//-----------------------------------------------------------------------------

+void CDetailObjectSystem::LevelInitPreEntity()

+{

+	// Prepare the translucent detail sprite material; we only have 1!

+	m_DetailSpriteMaterial.Init( "detail/detailsprites", TEXTURE_GROUP_OTHER );

+	m_DetailWireframeMaterial.Init( "debug/debugspritewireframe", TEXTURE_GROUP_OTHER );

+

+	// Version check

+	if (engine->GameLumpVersion( GAMELUMP_DETAIL_PROPS ) < 4)

+	{

+		Warning("Map uses old detail prop file format.. ignoring detail props\n");

+		return;

+	}

+

+	MEM_ALLOC_CREDIT();

+

+	// Unserialize

+	int size = engine->GameLumpSize( GAMELUMP_DETAIL_PROPS );

+	CUtlMemory<unsigned char> fileMemory;

+	fileMemory.EnsureCapacity( size );

+	if (engine->LoadGameLump( GAMELUMP_DETAIL_PROPS, fileMemory.Base(), size ))

+	{

+		CUtlBuffer buf( fileMemory.Base(), size, CUtlBuffer::READ_ONLY );

+		UnserializeModelDict( buf );

+

+		switch (engine->GameLumpVersion( GAMELUMP_DETAIL_PROPS ) )

+		{

+		case 4:

+			UnserializeDetailSprites( buf );

+			UnserializeModels( buf );

+			break;

+		}

+	}

+

+	if ( m_DetailObjects.Count() || m_DetailSpriteDict.Count() )

+	{

+		// There are detail objects in the level, so precache the material

+		PrecacheMaterial( DETAIL_SPRITE_MATERIAL );

+		IMaterial *pMat = m_DetailSpriteMaterial;

+		// adjust for non-square textures (cropped)

+		float flRatio = pMat->GetMappingWidth() / pMat->GetMappingHeight();

+		if ( flRatio > 1.0 )

+		{

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

+			{

+				m_DetailSpriteDict[i].m_TexUL.y *= flRatio;

+				m_DetailSpriteDict[i].m_TexLR.y *= flRatio;

+				m_DetailSpriteDictFlipped[i].m_TexUL.y *= flRatio;

+				m_DetailSpriteDictFlipped[i].m_TexLR.y *= flRatio;

+			}

+		}

+	}

+

+	int detailPropLightingLump;

+	if( g_pMaterialSystemHardwareConfig->GetHDRType() != HDR_TYPE_NONE )

+	{

+		detailPropLightingLump = GAMELUMP_DETAIL_PROP_LIGHTING_HDR;

+	}

+	else

+	{

+		detailPropLightingLump = GAMELUMP_DETAIL_PROP_LIGHTING;

+	}

+	size = engine->GameLumpSize( detailPropLightingLump );

+

+	fileMemory.EnsureCapacity( size );

+	if (engine->LoadGameLump( detailPropLightingLump, fileMemory.Base(), size ))

+	{

+		CUtlBuffer buf( fileMemory.Base(), size, CUtlBuffer::READ_ONLY );

+		UnserializeModelLighting( buf );

+	}

+}

+

+

+void CDetailObjectSystem::LevelInitPostEntity()

+{

+	const char *pDetailSpriteMaterial = DETAIL_SPRITE_MATERIAL;

+	C_World *pWorld = GetClientWorldEntity();

+	if ( pWorld && pWorld->GetDetailSpriteMaterial() && *(pWorld->GetDetailSpriteMaterial()) )

+	{

+		pDetailSpriteMaterial = pWorld->GetDetailSpriteMaterial(); 

+	}

+	m_DetailSpriteMaterial.Init( pDetailSpriteMaterial, TEXTURE_GROUP_OTHER );

+

+	if ( GetDetailController() )

+	{

+		cl_detailfade.SetValue( MIN( m_flDefaultFadeStart, GetDetailController()->m_flFadeStartDist ) );

+		cl_detaildist.SetValue( MIN( m_flDefaultFadeEnd, GetDetailController()->m_flFadeEndDist ) );

+	}

+	else

+	{

+		// revert to default values if the map doesn't specify

+		cl_detailfade.SetValue( m_flDefaultFadeStart );

+		cl_detaildist.SetValue( m_flDefaultFadeEnd );

+	}

+}

+

+void CDetailObjectSystem::LevelShutdownPreEntity()

+{

+	m_DetailObjects.Purge();

+	m_DetailObjectDict.Purge();

+	m_DetailSpriteDict.Purge();

+	m_DetailSpriteDictFlipped.Purge();

+	m_DetailLighting.Purge();

+	m_DetailSpriteMaterial.Shutdown();

+	if ( m_pFastSpriteData )

+	{

+		MemAlloc_FreeAligned( m_pFastSpriteData );

+		m_pFastSpriteData = NULL;

+	}

+	FreeSortBuffers();

+

+}

+

+void CDetailObjectSystem::LevelShutdownPostEntity()

+{

+	m_DetailWireframeMaterial.Shutdown();

+}

+

+//-----------------------------------------------------------------------------

+// Before each view, blat out the stored detail sprite state

+//-----------------------------------------------------------------------------

+void CDetailObjectSystem::BeginTranslucentDetailRendering( )

+{

+	m_nSortedLeaf = -1;

+	m_nSortedFastLeaf = -1;

+	m_nSpriteCount = m_nFirstSprite = 0;

+}

+

+

+//-----------------------------------------------------------------------------

+// Gets a particular detail object

+//-----------------------------------------------------------------------------

+IClientRenderable* CDetailObjectSystem::GetDetailModel( int idx )

+{

+	// FIXME: This is necessary because we have intermixed models + sprites

+	// in a single list (m_DetailObjects)

+	if (m_DetailObjects[idx].GetType() != DETAIL_PROP_TYPE_MODEL)

+		return NULL;

+	

+	return &m_DetailObjects[idx];

+}

+

+

+//-----------------------------------------------------------------------------

+// Unserialization

+//-----------------------------------------------------------------------------

+void CDetailObjectSystem::UnserializeModelDict( CUtlBuffer& buf )

+{

+	int count = buf.GetInt();

+	m_DetailObjectDict.EnsureCapacity( count );

+	while ( --count >= 0 )

+	{

+		DetailObjectDictLump_t lump;

+		buf.Get( &lump, sizeof(DetailObjectDictLump_t) );

+		

+		DetailModelDict_t dict;

+		dict.m_pModel = (model_t *)engine->LoadModel( lump.m_Name, true );

+

+		// Don't allow vertex-lit models

+		if (modelinfo->IsModelVertexLit(dict.m_pModel))

+		{

+			Warning("Detail prop model %s is using vertex-lit materials!\nIt must use unlit materials!\n", lump.m_Name );

+			dict.m_pModel = (model_t *)engine->LoadModel( "models/error.mdl" );

+		}

+

+		m_DetailObjectDict.AddToTail( dict );

+	}

+}

+

+void CDetailObjectSystem::UnserializeDetailSprites( CUtlBuffer& buf )

+{

+	int count = buf.GetInt();

+	m_DetailSpriteDict.EnsureCapacity( count );

+	m_DetailSpriteDictFlipped.EnsureCapacity( count );

+	while ( --count >= 0 )

+	{

+		int i = m_DetailSpriteDict.AddToTail();

+		buf.Get( &m_DetailSpriteDict[i], sizeof(DetailSpriteDictLump_t) );

+		int flipi = m_DetailSpriteDictFlipped.AddToTail();

+		m_DetailSpriteDictFlipped[flipi] = m_DetailSpriteDict[i];

+		::V_swap( m_DetailSpriteDictFlipped[flipi].m_TexUL.x, m_DetailSpriteDictFlipped[flipi].m_TexLR.x );

+	}

+}

+

+

+void CDetailObjectSystem::UnserializeModelLighting( CUtlBuffer& buf )

+{

+	int count = buf.GetInt();

+	m_DetailLighting.EnsureCapacity( count );

+	while ( --count >= 0 )

+	{

+		int i = m_DetailLighting.AddToTail();

+		buf.Get( &m_DetailLighting[i], sizeof(DetailPropLightstylesLump_t) );

+	}

+}

+

+

+ConVar cl_detail_multiplier( "cl_detail_multiplier", "1", FCVAR_CHEAT, "extra details to create" );

+

+#define SPRITE_MULTIPLIER  ( cl_detail_multiplier.GetInt() )

+

+ConVar cl_fastdetailsprites( "cl_fastdetailsprites", "1", FCVAR_CHEAT, "whether to use new detail sprite system");

+

+static bool DetailObjectIsFastSprite( DetailObjectLump_t const & lump )

+{

+	return (

+		( cl_fastdetailsprites.GetInt() ) &&

+		( lump.m_Type == DETAIL_PROP_TYPE_SPRITE ) &&

+		( lump.m_LightStyleCount == 0 ) &&

+		( lump.m_Orientation == 2 ) &&

+		( lump.m_ShapeAngle == 0 ) &&

+		( lump.m_ShapeSize == 0 ) &&

+		( lump.m_SwayAmount == 0 ) );

+}

+

+

+void CDetailObjectSystem::ScanForCounts( CUtlBuffer& buf,

+										 int *pNumOldStyleObjects,

+										 int *pNumFastSpritesToAllocate,

+										 int *nMaxNumOldSpritesInLeaf,

+										 int *nMaxNumFastSpritesInLeaf

+										 ) const

+{

+	int oldpos = buf.TellGet();								// we need to seek back

+	int count = buf.GetInt();

+

+	int nOld = 0;

+	int nFast = 0;

+	int detailObjectLeaf = -1;

+

+	int nNumOldInLeaf = 0;

+	int nNumFastInLeaf = 0;

+	int nMaxOld = 0;

+	int nMaxFast = 0;

+	while ( --count >= 0 )

+	{

+		DetailObjectLump_t lump;

+		buf.Get( &lump, sizeof(DetailObjectLump_t) );

+		

+		// We rely on the fact that details objects are sorted by leaf in the

+		// bsp file for this

+		if ( detailObjectLeaf != lump.m_Leaf )

+		{

+			// need to pad nfast to next sse boundary

+			nFast += ( 0 - nFast ) & 3;

+			nMaxFast = MAX( nMaxFast, nNumFastInLeaf );

+			nMaxOld = MAX( nMaxOld, nNumOldInLeaf );

+			nNumOldInLeaf = 0;

+			nNumFastInLeaf = 0;

+			detailObjectLeaf = lump.m_Leaf;

+

+		}

+

+		if ( DetailObjectIsFastSprite( lump ) )

+		{

+			nFast += SPRITE_MULTIPLIER;

+			nNumFastInLeaf += SPRITE_MULTIPLIER;

+		}

+		else

+		{

+			nOld += SPRITE_MULTIPLIER;

+			nNumOldInLeaf += SPRITE_MULTIPLIER;

+		}

+	}

+

+	// need to pad nfast to next sse boundary

+	nFast += ( 0 - nFast ) & 3;

+	nMaxFast = MAX( nMaxFast, nNumFastInLeaf );

+	nMaxOld = MAX( nMaxOld, nNumOldInLeaf );

+

+	buf.SeekGet( CUtlBuffer::SEEK_HEAD, oldpos );

+	*pNumFastSpritesToAllocate = nFast;

+	*pNumOldStyleObjects = nOld;

+	nMaxFast = ( 3 + nMaxFast ) & ~3;

+	*nMaxNumOldSpritesInLeaf = nMaxOld;

+	*nMaxNumFastSpritesInLeaf = nMaxFast;

+	

+}

+

+//-----------------------------------------------------------------------------

+// Unserialize all models

+//-----------------------------------------------------------------------------

+void CDetailObjectSystem::UnserializeModels( CUtlBuffer& buf )

+{

+	int firstDetailObject = 0;

+	int detailObjectCount = 0;

+	int detailObjectLeaf = -1;

+

+	int nNumOldStyleObjects;

+	int nNumFastSpritesToAllocate;

+	int nMaxOldInLeaf;

+	int nMaxFastInLeaf;

+	ScanForCounts( buf, &nNumOldStyleObjects, &nNumFastSpritesToAllocate, &nMaxOldInLeaf, &nMaxFastInLeaf );

+

+	FreeSortBuffers();

+

+	if ( nMaxOldInLeaf )

+	{

+		m_pSortInfo = reinterpret_cast<SortInfo_t *> (

+			MemAlloc_AllocAligned( (3 + nMaxOldInLeaf ) * sizeof( SortInfo_t ), sizeof( fltx4 ) ) );

+	}

+	if ( nMaxFastInLeaf )

+	{

+		m_pFastSortInfo = reinterpret_cast<SortInfo_t *> (

+			MemAlloc_AllocAligned( (3 + nMaxFastInLeaf ) * sizeof( SortInfo_t ), sizeof( fltx4 ) ) );

+

+		m_pBuildoutBuffer = reinterpret_cast<FastSpriteQuadBuildoutBufferX4_t *> (

+			MemAlloc_AllocAligned( 

+				( 1 + nMaxFastInLeaf / 4 ) * sizeof( FastSpriteQuadBuildoutBufferX4_t ),

+				sizeof( fltx4 ) ) );

+	}

+

+	if ( nNumFastSpritesToAllocate )

+	{

+		Assert( ( nNumFastSpritesToAllocate & 3 ) == 0 );

+		Assert( ! m_pFastSpriteData );						// wtf? didn't free?

+		m_pFastSpriteData = reinterpret_cast<FastSpriteX4_t *> (

+			MemAlloc_AllocAligned( 

+				( nNumFastSpritesToAllocate >> 2 ) * sizeof( FastSpriteX4_t ),

+				sizeof( fltx4 ) ) );

+	}

+

+	m_DetailObjects.EnsureCapacity( nNumOldStyleObjects  );

+

+	int count = buf.GetInt();

+	

+	int nCurFastObject = 0;

+	int nNumFastObjectsInCurLeaf = 0;

+	FastSpriteX4_t *pCurFastSpriteOut = m_pFastSpriteData;

+

+	bool bFlipped = true;

+	while ( --count >= 0 )

+	{

+		bFlipped = !bFlipped;

+		DetailObjectLump_t lump;

+		buf.Get( &lump, sizeof(DetailObjectLump_t) );

+		

+		// We rely on the fact that details objects are sorted by leaf in the

+		// bsp file for this

+		if ( detailObjectLeaf != lump.m_Leaf )

+		{

+			if (detailObjectLeaf != -1)

+			{

+				if ( nNumFastObjectsInCurLeaf )

+				{

+					CFastDetailLeafSpriteList *pNew = new CFastDetailLeafSpriteList;

+					pNew->m_nNumSprites = nNumFastObjectsInCurLeaf;

+					pNew->m_nNumSIMDSprites = ( 3 + nNumFastObjectsInCurLeaf ) >> 2;

+					pNew->m_pSprites = pCurFastSpriteOut;

+					pCurFastSpriteOut += pNew->m_nNumSIMDSprites;

+					ClientLeafSystem()->SetSubSystemDataInLeaf( 

+						detailObjectLeaf, CLSUBSYSTEM_DETAILOBJECTS, pNew );

+					// round to see boundary

+					nCurFastObject += ( 0 - nCurFastObject ) & 3;

+					nNumFastObjectsInCurLeaf = 0;

+				}

+				ClientLeafSystem()->SetDetailObjectsInLeaf( detailObjectLeaf, 

+					firstDetailObject, detailObjectCount );

+			}

+

+			detailObjectLeaf = lump.m_Leaf;

+			firstDetailObject = m_DetailObjects.Count();

+			detailObjectCount = 0;

+		}

+

+		if ( DetailObjectIsFastSprite( lump ) )

+		{

+			for( int i =0 ; i < SPRITE_MULTIPLIER ; i++)

+			{

+				FastSpriteX4_t *pSpritex4 = m_pFastSpriteData +  (nCurFastObject >> 2 );

+				int nSubField = ( nCurFastObject & 3 );

+				Vector pos(0,0,0);

+				if ( i ) 

+				{

+					pos += RandomVector( -50, 50 );

+					pos.z = 0;

+				}

+				UnserializeFastSprite( pSpritex4, nSubField, lump, bFlipped, pos );

+				if ( nSubField == 0 )

+					pSpritex4->ReplicateFirstEntryToOthers(); // keep bad numbers out to prevent denormals, etc

+				nCurFastObject++;

+				nNumFastObjectsInCurLeaf++;

+			}

+		}

+		else

+		{

+			switch( lump.m_Type )

+			{

+				case DETAIL_PROP_TYPE_MODEL:

+				{

+					int newObj = m_DetailObjects.AddToTail();

+					m_DetailObjects[newObj].Init(

+						newObj, lump.m_Origin, lump.m_Angles, 

+						m_DetailObjectDict[lump.m_DetailModel].m_pModel, lump.m_Lighting,

+						lump.m_LightStyles, lump.m_LightStyleCount, lump.m_Orientation );

+					++detailObjectCount;

+				}

+				break;

+

+				case DETAIL_PROP_TYPE_SPRITE:

+				case DETAIL_PROP_TYPE_SHAPE_CROSS:

+				case DETAIL_PROP_TYPE_SHAPE_TRI:

+				{

+					for( int i=0;i<SPRITE_MULTIPLIER;i++)

+					{

+						Vector pos = lump.m_Origin;

+						if ( i != 0)

+						{

+							pos += RandomVector( -50, 50 );

+							pos. z = lump.m_Origin.z;

+						}

+						int newObj = m_DetailObjects.AddToTail();

+						m_DetailObjects[newObj].InitSprite( 

+							newObj, bFlipped, pos, lump.m_Angles, 

+							lump.m_DetailModel, lump.m_Lighting,

+							lump.m_LightStyles, lump.m_LightStyleCount, lump.m_Orientation, lump.m_flScale,

+							lump.m_Type, lump.m_ShapeAngle, lump.m_ShapeSize, lump.m_SwayAmount );

+						++detailObjectCount;

+					}

+				}

+				break;

+			}

+		}

+	}

+

+	

+	if (detailObjectLeaf != -1)

+	{

+		if ( nNumFastObjectsInCurLeaf )

+		{

+			CFastDetailLeafSpriteList *pNew = new CFastDetailLeafSpriteList;

+			pNew->m_nNumSprites = nNumFastObjectsInCurLeaf;

+			pNew->m_nNumSIMDSprites = ( 3 + nNumFastObjectsInCurLeaf ) >> 2;

+			pNew->m_pSprites = pCurFastSpriteOut;

+			pCurFastSpriteOut += pNew->m_nNumSIMDSprites;

+			ClientLeafSystem()->SetSubSystemDataInLeaf( 

+				detailObjectLeaf, CLSUBSYSTEM_DETAILOBJECTS, pNew );

+		}

+		ClientLeafSystem()->SetDetailObjectsInLeaf( detailObjectLeaf, 

+													firstDetailObject, detailObjectCount );

+	}

+}

+

+

+Vector CDetailObjectSystem::GetSpriteMiddleBottomPosition( DetailObjectLump_t const &lump ) const

+{

+	DetailPropSpriteDict_t &dict = s_DetailObjectSystem.DetailSpriteDict( lump.m_DetailModel );

+

+	Vector vecDir;

+	QAngle Angles;

+

+	VectorSubtract( lump.m_Origin + Vector(0,-100,0), lump.m_Origin, vecDir );

+	vecDir.z = 0.0f;

+	VectorAngles( vecDir, Angles );

+

+	Vector vecOrigin, dx, dy;

+	AngleVectors( Angles, NULL, &dx, &dy );

+

+	Vector2D ul, lr;

+	float scale = lump.m_flScale;

+	Vector2DMultiply( dict.m_UL, scale, ul );

+	Vector2DMultiply( dict.m_LR, scale, lr );

+

+	VectorMA( lump.m_Origin, ul.x, dx, vecOrigin );

+	VectorMA( vecOrigin, ul.y, dy, vecOrigin );

+	dx *= (lr.x - ul.x);

+	dy *= (lr.y - ul.y);

+

+	Vector2D texul, texlr;

+	texul = dict.m_TexUL;

+	texlr = dict.m_TexLR;

+

+	return vecOrigin + dy + 0.5 * dx;

+}

+

+

+void CDetailObjectSystem::UnserializeFastSprite( FastSpriteX4_t *pSpritex4, int nSubField, DetailObjectLump_t const &lump, bool bFlipped, Vector const &posOffset )

+{

+	Vector pos = lump.m_Origin + posOffset;

+	pos = GetSpriteMiddleBottomPosition( lump ) + posOffset;

+

+	pSpritex4->m_Pos.X( nSubField ) = pos.x;

+	pSpritex4->m_Pos.Y( nSubField ) = pos.y;

+	pSpritex4->m_Pos.Z( nSubField ) = pos.z;

+	DetailPropSpriteDict_t *pSDef = &m_DetailSpriteDict[lump.m_DetailModel];

+

+	SubFloat( pSpritex4->m_HalfWidth, nSubField ) = 0.5 * lump.m_flScale * ( pSDef->m_LR.x - pSDef->m_UL.x );

+	SubFloat( pSpritex4->m_Height, nSubField ) = lump.m_flScale * ( pSDef->m_LR.y - pSDef->m_UL.y );

+	if ( !bFlipped )

+	{

+		pSDef = &m_DetailSpriteDictFlipped[lump.m_DetailModel];

+	}

+	// do packed color

+	ColorRGBExp32 rgbcolor = lump.m_Lighting;

+	float color[4];

+	color[0] = TexLightToLinear( rgbcolor.r, rgbcolor.exponent );

+	color[1] = TexLightToLinear( rgbcolor.g, rgbcolor.exponent );

+	color[2] = TexLightToLinear( rgbcolor.b, rgbcolor.exponent );

+	color[3] = 255;

+	engine->LinearToGamma( color, color );

+	pSpritex4->m_RGBColor[nSubField][0] = 255.0 * color[0];

+	pSpritex4->m_RGBColor[nSubField][1] = 255.0 * color[1];

+	pSpritex4->m_RGBColor[nSubField][2] = 255.0 * color[2];

+	pSpritex4->m_RGBColor[nSubField][3] = 255;

+

+	pSpritex4->m_pSpriteDefs[nSubField] = pSDef;

+}

+

+

+

+//-----------------------------------------------------------------------------

+// Renders all opaque detail objects in a particular set of leaves

+//-----------------------------------------------------------------------------

+void CDetailObjectSystem::RenderOpaqueDetailObjects( int nLeafCount, LeafIndex_t *pLeafList )

+{

+	// FIXME: Implement!

+}

+

+

+//-----------------------------------------------------------------------------

+// Count the number of detail sprites in the leaf list

+//-----------------------------------------------------------------------------

+int CDetailObjectSystem::CountSpritesInLeafList( int nLeafCount, LeafIndex_t *pLeafList ) const

+{

+	VPROF_BUDGET( "CDetailObjectSystem::CountSpritesInLeafList", VPROF_BUDGETGROUP_DETAILPROP_RENDERING );

+	int nPropCount = 0;

+	int nFirstDetailObject, nDetailObjectCount;

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

+	{

+		// FIXME: This actually counts *everything* in the leaf, which is ok for now

+		// given how we're using it

+		ClientLeafSystem()->GetDetailObjectsInLeaf( pLeafList[i], nFirstDetailObject, nDetailObjectCount );

+		nPropCount += nDetailObjectCount;

+	}

+

+	return nPropCount;

+}

+

+//-----------------------------------------------------------------------------

+// Count the number of fast sprites in the leaf list

+//-----------------------------------------------------------------------------

+int CDetailObjectSystem::CountFastSpritesInLeafList( int nLeafCount, LeafIndex_t const *pLeafList,

+													 int *nMaxFoundInLeaf ) const

+{

+	VPROF_BUDGET( "CDetailObjectSystem::CountSpritesInLeafList", VPROF_BUDGETGROUP_DETAILPROP_RENDERING );

+	int nCount = 0;

+	int nMax = 0;

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

+	{

+		CFastDetailLeafSpriteList *pData = reinterpret_cast< CFastDetailLeafSpriteList *> (

+			ClientLeafSystem()->GetSubSystemDataInLeaf( pLeafList[i], CLSUBSYSTEM_DETAILOBJECTS ) );

+		if ( pData )

+		{

+			nCount += pData->m_nNumSprites;

+			nMax = MAX( nMax, pData->m_nNumSprites );

+		}

+	}

+	*nMaxFoundInLeaf = ( nMax + 3 ) & ~3;					// round up

+	return nCount;

+}

+

+

+//-----------------------------------------------------------------------------

+// Count the number of detail sprite quads in the leaf list

+//-----------------------------------------------------------------------------

+int CDetailObjectSystem::CountSpriteQuadsInLeafList( int nLeafCount, LeafIndex_t *pLeafList ) const

+{

+#ifdef USE_DETAIL_SHAPES

+	VPROF_BUDGET( "CDetailObjectSystem::CountSpritesInLeafList", VPROF_BUDGETGROUP_DETAILPROP_RENDERING );

+	int nQuadCount = 0;

+	int nFirstDetailObject, nDetailObjectCount;

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

+	{

+		// FIXME: This actually counts *everything* in the leaf, which is ok for now

+		// given how we're using it

+		ClientLeafSystem()->GetDetailObjectsInLeaf( pLeafList[i], nFirstDetailObject, nDetailObjectCount );

+		for ( int j = 0; j < nDetailObjectCount; ++j )

+		{

+			nQuadCount += m_DetailObjects[j + nFirstDetailObject].QuadsToDraw();

+		}

+	}

+

+	return nQuadCount;

+#else

+	return CountSpritesInLeafList( nLeafCount, pLeafList );

+#endif

+}

+

+

+#define TREATASINT(x) ( *(  ( (int32 const *)( &(x) ) ) ) )

+

+//-----------------------------------------------------------------------------

+// Sorts sprites in back-to-front order

+//-----------------------------------------------------------------------------

+inline bool CDetailObjectSystem::SortLessFunc( const CDetailObjectSystem::SortInfo_t &left, const CDetailObjectSystem::SortInfo_t &right )

+{

+	return TREATASINT( left.m_flDistance ) > TREATASINT( right.m_flDistance );

+//	return left.m_flDistance > right.m_flDistance;

+}

+

+

+int CDetailObjectSystem::SortSpritesBackToFront( int nLeaf, const Vector &viewOrigin, const Vector &viewForward, SortInfo_t *pSortInfo )

+{

+	VPROF_BUDGET( "CDetailObjectSystem::SortSpritesBackToFront", VPROF_BUDGETGROUP_DETAILPROP_RENDERING );

+	int nFirstDetailObject, nDetailObjectCount;

+	ClientLeafSystem()->GetDetailObjectsInLeaf( nLeaf, nFirstDetailObject, nDetailObjectCount );

+

+	float flFactor = 1.0f;

+	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();

+	if ( pLocalPlayer )

+	{

+		flFactor = 1.0 / pLocalPlayer->GetFOVDistanceAdjustFactor();

+	}

+

+	float flMaxSqDist;

+	float flFadeSqDist;

+	float flDetailDist = cl_detaildist.GetFloat();

+

+	flMaxSqDist = flDetailDist * flDetailDist;

+	flFadeSqDist = flDetailDist - cl_detailfade.GetFloat();

+	flMaxSqDist *= flFactor;

+	flFadeSqDist *= flFactor;

+	if (flFadeSqDist > 0)

+	{

+		flFadeSqDist *= flFadeSqDist;

+	}

+	else 

+	{

+		flFadeSqDist = 0;

+	}

+	float flFalloffFactor = 255.0f / (flMaxSqDist - flFadeSqDist);

+

+	Vector vecDelta;

+	int nCount = 0;

+	nDetailObjectCount += nFirstDetailObject;

+	for ( int j = nFirstDetailObject; j < nDetailObjectCount; ++j )

+	{

+		CDetailModel &model = m_DetailObjects[j];

+

+		Vector v;

+		VectorSubtract( model.GetRenderOrigin(), viewOrigin, vecDelta );

+		float flSqDist = vecDelta.LengthSqr();

+		if ( flSqDist >= flMaxSqDist )

+			continue;

+

+		if ((flFadeSqDist > 0) && (flSqDist > flFadeSqDist))

+		{

+			model.SetAlpha( flFalloffFactor * ( flMaxSqDist - flSqDist ) );

+		}

+		else

+		{

+			model.SetAlpha( 255 );

+		}

+

+		if ( (model.GetType() == DETAIL_PROP_TYPE_MODEL) || (model.GetAlpha() == 0) )

+			continue;

+

+		// Perform screen alignment if necessary.

+		model.ComputeAngles();

+		SortInfo_t *pSortInfoCurrent = &pSortInfo[nCount];

+

+		pSortInfoCurrent->m_nIndex = j;

+

+		// Compute distance from the camera to each object

+		pSortInfoCurrent->m_flDistance = flSqDist;

+		++nCount;

+	}

+

+	if ( nCount )

+	{

+		VPROF( "CDetailObjectSystem::SortSpritesBackToFront -- Sort" );

+		std::make_heap( pSortInfo, pSortInfo + nCount, SortLessFunc ); 

+		std::sort_heap( pSortInfo, pSortInfo + nCount, SortLessFunc ); 

+	}

+

+	return nCount;

+}

+

+

+#define MAGIC_NUMBER (1<<23)

+#ifdef VALVE_BIG_ENDIAN

+#define MANTISSA_LSB_OFFSET 3

+#else

+#define MANTISSA_LSB_OFFSET 0

+#endif

+static fltx4 Four_MagicNumbers={ MAGIC_NUMBER, MAGIC_NUMBER, MAGIC_NUMBER, MAGIC_NUMBER };

+static fltx4 Four_255s={ 255.0, 255.0, 255.0, 255.0 };

+

+static ALIGN16 int32 And255Mask[4] ALIGN16_POST = {0xff,0xff,0xff,0xff};

+#define PIXMASK ( * ( reinterpret_cast< fltx4 *>( &And255Mask ) ) )

+

+int CDetailObjectSystem::BuildOutSortedSprites( CFastDetailLeafSpriteList *pData,

+												Vector const &viewOrigin,

+												Vector const &viewForward,

+												Vector const &viewRight,

+												Vector const &viewUp )

+{

+	// part 1 - do all vertex math, fading, etc into a buffer, using as much simd as we can

+	int nSIMDSprites = pData->m_nNumSIMDSprites;

+	FastSpriteX4_t const *pSprites = pData->m_pSprites;

+	SortInfo_t *pOut = m_pFastSortInfo;

+	FastSpriteQuadBuildoutBufferX4_t *pQuadBufferOut = m_pBuildoutBuffer;

+	int curidx = 0;

+	int nLastBfMask = 0;

+

+	FourVectors vecViewPos;

+	vecViewPos.DuplicateVector( viewOrigin );

+	fltx4 maxsqdist = ReplicateX4( m_flCurMaxSqDist );

+

+	fltx4 falloffFactor = ReplicateX4( 1.0/ ( m_flCurMaxSqDist - m_flCurFadeSqDist ) );

+	fltx4 startFade = ReplicateX4( m_flCurFadeSqDist );

+

+	FourVectors vecUp;

+	vecUp.DuplicateVector(Vector(0,0,1) );

+	FourVectors vecFwd;

+	vecFwd.DuplicateVector( viewForward );

+

+	do

+	{

+		// calculate alpha

+		FourVectors ofs = pSprites->m_Pos;

+		ofs -= vecViewPos;

+		fltx4 ofsDotFwd = ofs * vecFwd;

+		fltx4 distanceSquared = ofs * ofs;

+		nLastBfMask = TestSignSIMD( OrSIMD( ofsDotFwd, CmpGtSIMD( distanceSquared, maxsqdist ) ) );		//  cull

+		if ( nLastBfMask != 0xf )

+		{

+			FourVectors dx1;

+			dx1.x = fnegate( ofs.y );

+			dx1.y = ( ofs.x );

+			dx1.z = Four_Zeros;

+			dx1.VectorNormalizeFast();

+				

+			FourVectors vecDx = dx1;

+			FourVectors vecDy = vecUp;

+

+			FourVectors vecPos0 = pSprites->m_Pos;

+

+			vecDx *= pSprites->m_HalfWidth;

+			vecDy *= pSprites->m_Height;

+			fltx4 alpha = MulSIMD( falloffFactor, SubSIMD( distanceSquared, startFade ) );

+			alpha = SubSIMD( Four_Ones, MinSIMD( MaxSIMD( alpha, Four_Zeros), Four_Ones ) );

+

+			pQuadBufferOut->m_Alpha = AddSIMD( Four_MagicNumbers, 

+											   MulSIMD( Four_255s,alpha ) );

+

+			vecPos0 += vecDx;

+			pQuadBufferOut->m_Coords[0] = vecPos0;

+			vecPos0 -= vecDy;

+			pQuadBufferOut->m_Coords[1] = vecPos0;

+			vecPos0 -= vecDx;

+			vecPos0 -= vecDx;

+			pQuadBufferOut->m_Coords[2] = vecPos0;

+			vecPos0 += vecDy;

+			pQuadBufferOut->m_Coords[3] = vecPos0;

+

+			fltx4 fetch4 = *( ( fltx4 *) ( &pSprites->m_pSpriteDefs[0] ) );

+			*( (fltx4 *) ( & ( pQuadBufferOut->m_pSpriteDefs[0] ) ) ) = fetch4;

+

+			fetch4 = *( ( fltx4 *) ( &pSprites->m_RGBColor[0][0] ) );

+			*( (fltx4 *) ( & ( pQuadBufferOut->m_RGBColor[0][0] ) ) ) = fetch4;

+

+			//!! bug!! store distance

+			// !! speed!! simd?

+			pOut[0].m_nIndex = curidx;

+			pOut[0].m_flDistance = SubFloat( distanceSquared, 0 );

+			pOut[1].m_nIndex = curidx+1;

+			pOut[1].m_flDistance = SubFloat( distanceSquared, 1 );

+			pOut[2].m_nIndex = curidx+2;

+			pOut[2].m_flDistance = SubFloat( distanceSquared, 2 );

+			pOut[3].m_nIndex = curidx+3;

+			pOut[3].m_flDistance = SubFloat( distanceSquared, 3 );

+			curidx += 4;

+			pOut += 4;

+			pQuadBufferOut++;

+		}

+		pSprites++;

+	} while( --nSIMDSprites );

+

+	// adjust count for tail

+	int nCount = pOut - m_pFastSortInfo;

+	if ( nLastBfMask != 0xf )						// if last not skipped

+		nCount -= ( 0 - pData->m_nNumSprites ) & 3;

+

+	// part 2 - sort

+	if ( nCount )

+	{

+		VPROF( "CDetailObjectSystem::SortSpritesBackToFront -- Sort" );

+		std::make_heap( m_pFastSortInfo, m_pFastSortInfo + nCount, SortLessFunc ); 

+		std::sort_heap( m_pFastSortInfo, m_pFastSortInfo + nCount, SortLessFunc ); 

+	}

+	return nCount;

+}

+

+

+void CDetailObjectSystem::RenderFastSprites( const Vector &viewOrigin, const Vector &viewForward, const Vector &viewRight, const Vector &viewUp, int nLeafCount, LeafIndex_t const * pLeafList )

+{

+	// Here, we must draw all detail objects back-to-front

+	// FIXME: Cache off a sorted list so we don't have to re-sort every frame

+

+	// Count the total # of detail quads we possibly could render

+	int nMaxInLeaf;

+

+	int nQuadCount = CountFastSpritesInLeafList( nLeafCount, pLeafList, &nMaxInLeaf );

+	if ( nQuadCount == 0 )

+		return;

+	if  ( r_DrawDetailProps.GetInt() == 0 )

+		return;

+

+

+	CMatRenderContextPtr pRenderContext( materials );

+	pRenderContext->MatrixMode( MATERIAL_MODEL );

+	pRenderContext->PushMatrix();

+	pRenderContext->LoadIdentity();

+

+	IMaterial *pMaterial = m_DetailSpriteMaterial;

+	if ( ShouldDrawInWireFrameMode() || r_DrawDetailProps.GetInt() == 2 )

+	{

+		pMaterial = m_DetailWireframeMaterial;

+	}

+

+	CMeshBuilder meshBuilder;

+	IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );

+

+	int nMaxVerts, nMaxIndices;

+	pRenderContext->GetMaxToRender( pMesh, false, &nMaxVerts, &nMaxIndices );

+	int nMaxQuadsToDraw = nMaxIndices / 6;

+	if ( nMaxQuadsToDraw > nMaxVerts / 4 ) 

+	{

+		nMaxQuadsToDraw = nMaxVerts / 4;

+	}

+

+	if ( nMaxQuadsToDraw == 0 )

+		return;

+

+	int nQuadsToDraw = MIN( nQuadCount, nMaxQuadsToDraw );

+	int nQuadsRemaining = nQuadsToDraw;

+

+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, nQuadsToDraw );

+

+

+

+	// Sort detail sprites in each leaf independently; then render them

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

+	{

+		int nLeaf = pLeafList[i];

+

+		CFastDetailLeafSpriteList *pData = reinterpret_cast<CFastDetailLeafSpriteList *> (

+			ClientLeafSystem()->GetSubSystemDataInLeaf( nLeaf, CLSUBSYSTEM_DETAILOBJECTS ) );

+

+		if ( pData )

+		{

+			Assert( pData->m_nNumSprites );					// ptr with no sprites?

+

+			int nCount = BuildOutSortedSprites( pData, viewOrigin, viewForward, viewRight, viewUp );

+

+			// part 3 - stuff the sorted sprites into the vb

+			SortInfo_t const *pDraw = m_pFastSortInfo;

+			FastSpriteQuadBuildoutBufferNonSIMDView_t const *pQuadBuffer =

+				( FastSpriteQuadBuildoutBufferNonSIMDView_t const *) m_pBuildoutBuffer;

+

+			COMPILE_TIME_ASSERT( sizeof( FastSpriteQuadBuildoutBufferNonSIMDView_t ) ==

+								 sizeof( FastSpriteQuadBuildoutBufferX4_t ) );

+

+			while( nCount )

+			{

+				if ( ! nQuadsRemaining )					// no room left?

+				{

+					meshBuilder.End();

+					pMesh->Draw();

+					nQuadsRemaining = nQuadsToDraw;

+					meshBuilder.Begin( pMesh, MATERIAL_QUADS, nQuadsToDraw );

+				}

+				int nToDraw = MIN( nCount, nQuadsRemaining );

+				nCount -= nToDraw;

+				nQuadsRemaining -= nToDraw;

+				while( nToDraw-- )

+				{

+					// draw the sucker

+					int nSIMDIdx = pDraw->m_nIndex >> 2;

+					int nSubIdx = pDraw->m_nIndex & 3;

+

+					FastSpriteQuadBuildoutBufferNonSIMDView_t const *pquad = pQuadBuffer+nSIMDIdx;

+

+					// voodoo - since everything is in 4s, offset structure pointer by a couple of floats to handle sub-index

+					pquad = (FastSpriteQuadBuildoutBufferNonSIMDView_t const *) ( ( (int) ( pquad ) )+ ( nSubIdx << 2 ) );

+					uint8 const *pColorsCasted = reinterpret_cast<uint8 const *> ( pquad->m_Alpha );

+

+					uint8 color[4];

+					color[0] = pquad->m_RGBColor[0][0];

+					color[1] = pquad->m_RGBColor[0][1];

+					color[2] = pquad->m_RGBColor[0][2];

+					color[3] = pColorsCasted[MANTISSA_LSB_OFFSET];

+

+					DetailPropSpriteDict_t *pDict = pquad->m_pSpriteDefs[0];

+

+					meshBuilder.Position3f( pquad->m_flX0[0], pquad->m_flY0[0], pquad->m_flZ0[0] );

+					meshBuilder.Color4ubv( color );

+					meshBuilder.TexCoord2f( 0, pDict->m_TexLR.x, pDict->m_TexLR.y );

+					meshBuilder.AdvanceVertex();

+

+					meshBuilder.Position3f( pquad->m_flX1[0], pquad->m_flY1[0], pquad->m_flZ1[0] );

+					meshBuilder.Color4ubv( color );

+					meshBuilder.TexCoord2f( 0, pDict->m_TexLR.x, pDict->m_TexUL.y );

+					meshBuilder.AdvanceVertex();

+

+					meshBuilder.Position3f( pquad->m_flX2[0], pquad->m_flY2[0], pquad->m_flZ2[0] );

+					meshBuilder.Color4ubv( color );

+					meshBuilder.TexCoord2f( 0, pDict->m_TexUL.x, pDict->m_TexUL.y );

+					meshBuilder.AdvanceVertex();

+

+					meshBuilder.Position3f( pquad->m_flX3[0], pquad->m_flY3[0], pquad->m_flZ3[0] );

+					meshBuilder.Color4ubv( color );

+					meshBuilder.TexCoord2f( 0, pDict->m_TexUL.x, pDict->m_TexLR.y );

+					meshBuilder.AdvanceVertex();

+					pDraw++;

+				}

+			}

+		}

+	}

+	meshBuilder.End();

+	pMesh->Draw();

+	pRenderContext->PopMatrix();

+}

+

+

+//-----------------------------------------------------------------------------

+// Renders all translucent detail objects in a particular set of leaves

+//-----------------------------------------------------------------------------

+void CDetailObjectSystem::RenderTranslucentDetailObjects( const Vector &viewOrigin, const Vector &viewForward, const Vector &viewRight, const Vector &viewUp, int nLeafCount, LeafIndex_t *pLeafList )

+{

+	VPROF_BUDGET( "CDetailObjectSystem::RenderTranslucentDetailObjects", VPROF_BUDGETGROUP_DETAILPROP_RENDERING );

+	if (nLeafCount == 0)

+		return;

+

+	// We better not have any partially drawn leaf of detail sprites!

+	Assert( m_nSpriteCount == m_nFirstSprite );

+

+	// Here, we must draw all detail objects back-to-front

+	RenderFastSprites( viewOrigin, viewForward, viewRight, viewUp, nLeafCount, pLeafList );

+

+	// FIXME: Cache off a sorted list so we don't have to re-sort every frame

+

+	// Count the total # of detail quads we possibly could render

+	int nQuadCount = CountSpriteQuadsInLeafList( nLeafCount, pLeafList );

+	if ( nQuadCount == 0 )

+		return;

+

+	CMatRenderContextPtr pRenderContext( materials );

+	pRenderContext->MatrixMode( MATERIAL_MODEL );

+	pRenderContext->PushMatrix();

+	pRenderContext->LoadIdentity();

+

+	IMaterial *pMaterial = m_DetailSpriteMaterial;

+	if ( ShouldDrawInWireFrameMode() || r_DrawDetailProps.GetInt() == 2 )

+	{

+		pMaterial = m_DetailWireframeMaterial;

+	}

+

+	CMeshBuilder meshBuilder;

+	IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );

+

+	int nMaxVerts, nMaxIndices;

+	pRenderContext->GetMaxToRender( pMesh, false, &nMaxVerts, &nMaxIndices );

+	int nMaxQuadsToDraw = nMaxIndices / 6;

+	if ( nMaxQuadsToDraw > nMaxVerts / 4 ) 

+	{

+		nMaxQuadsToDraw = nMaxVerts / 4;

+	}

+

+	if ( nMaxQuadsToDraw == 0 )

+		return;

+

+	int nQuadsToDraw = nQuadCount;

+	if ( nQuadsToDraw > nMaxQuadsToDraw )

+	{

+		nQuadsToDraw = nMaxQuadsToDraw;

+	}

+

+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, nQuadsToDraw );

+

+	int nQuadsDrawn = 0;

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

+	{

+		int nLeaf = pLeafList[i];

+

+		int nFirstDetailObject, nDetailObjectCount;

+		ClientLeafSystem()->GetDetailObjectsInLeaf( nLeaf, nFirstDetailObject, nDetailObjectCount );

+

+		// Sort detail sprites in each leaf independently; then render them

+		SortInfo_t *pSortInfo = m_pSortInfo;

+		int nCount = SortSpritesBackToFront( nLeaf, viewOrigin, viewForward, pSortInfo );

+

+		for ( int j = 0; j < nCount; ++j )

+		{

+			CDetailModel &model = m_DetailObjects[ pSortInfo[j].m_nIndex ];

+			int nQuadsInModel = model.QuadsToDraw();

+

+			// Prevent the batches from getting too large

+			if ( nQuadsDrawn + nQuadsInModel > nQuadsToDraw )

+			{

+				meshBuilder.End();

+				pMesh->Draw();

+

+				nQuadCount -= nQuadsDrawn;

+				nQuadsToDraw = nQuadCount;

+				if (nQuadsToDraw > nMaxQuadsToDraw)

+				{

+					nQuadsToDraw = nMaxQuadsToDraw;

+				}

+

+				meshBuilder.Begin( pMesh, MATERIAL_QUADS, nQuadsToDraw );

+				nQuadsDrawn = 0;

+			}

+

+			model.DrawSprite( meshBuilder );

+

+			nQuadsDrawn += nQuadsInModel;

+		}

+	}

+

+	meshBuilder.End();

+	pMesh->Draw();

+

+	pRenderContext->PopMatrix();

+}

+

+

+void CDetailObjectSystem::RenderFastTranslucentDetailObjectsInLeaf( const Vector &viewOrigin, const Vector &viewForward, const Vector &viewRight, const Vector &viewUp, int nLeaf, const Vector *pVecClosestPoint )

+{

+	CFastDetailLeafSpriteList *pData = reinterpret_cast< CFastDetailLeafSpriteList *> (

+		ClientLeafSystem()->GetSubSystemDataInLeaf( nLeaf, CLSUBSYSTEM_DETAILOBJECTS ) );

+	if ( ! pData )

+		return;

+

+	if ( m_nSortedFastLeaf != nLeaf )

+	{

+		m_nSortedFastLeaf = nLeaf;

+		pData->m_nNumPendingSprites = BuildOutSortedSprites( pData, viewOrigin, viewForward, viewRight, viewUp );

+		pData->m_nStartSpriteIndex = 0;

+	}

+	if ( pData->m_nNumPendingSprites == 0 )

+		return;

+

+	float flMinDistance = 0.0f;

+	if ( pVecClosestPoint )

+	{

+		Vector vecDelta;

+		VectorSubtract( *pVecClosestPoint, viewOrigin, vecDelta );

+		flMinDistance = vecDelta.LengthSqr();

+	}

+		

+	if ( m_pFastSortInfo[pData->m_nStartSpriteIndex].m_flDistance < flMinDistance )

+		return;

+

+	int nCount = pData->m_nNumPendingSprites;

+

+	if  ( r_DrawDetailProps.GetInt() == 0 )

+		return;

+

+

+	CMatRenderContextPtr pRenderContext( materials );

+	pRenderContext->MatrixMode( MATERIAL_MODEL );

+	pRenderContext->PushMatrix();

+	pRenderContext->LoadIdentity();

+		

+	IMaterial *pMaterial = m_DetailSpriteMaterial;

+	if ( ShouldDrawInWireFrameMode() || r_DrawDetailProps.GetInt() == 2 )

+	{

+		pMaterial = m_DetailWireframeMaterial;

+	}

+		

+	CMeshBuilder meshBuilder;

+	IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );

+

+	int nMaxVerts, nMaxIndices;

+	pRenderContext->GetMaxToRender( pMesh, false, &nMaxVerts, &nMaxIndices );

+	int nMaxQuadsToDraw = nMaxIndices / 6;

+	if ( nMaxQuadsToDraw > nMaxVerts / 4 ) 

+	{

+		nMaxQuadsToDraw = nMaxVerts / 4;

+	}

+	

+	if ( nMaxQuadsToDraw == 0 )

+		return;

+		

+	int nQuadsToDraw = MIN( nCount, nMaxQuadsToDraw );

+	int nQuadsRemaining = nQuadsToDraw;

+		

+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, nQuadsToDraw );

+

+	SortInfo_t const *pDraw = m_pFastSortInfo + pData->m_nStartSpriteIndex;

+

+	FastSpriteQuadBuildoutBufferNonSIMDView_t const *pQuadBuffer =

+		( FastSpriteQuadBuildoutBufferNonSIMDView_t const *) m_pBuildoutBuffer;

+	

+	while( nCount && ( pDraw->m_flDistance >= flMinDistance ) )

+	{

+		if ( ! nQuadsRemaining )					// no room left?

+		{

+			meshBuilder.End();

+			pMesh->Draw();

+			nQuadsRemaining = nQuadsToDraw;

+			meshBuilder.Begin( pMesh, MATERIAL_QUADS, nQuadsToDraw );

+		}

+		int nToDraw = MIN( nCount, nQuadsRemaining );

+		nCount -= nToDraw;

+		nQuadsRemaining -= nToDraw;

+		while( nToDraw-- )

+		{

+			// draw the sucker

+			int nSIMDIdx = pDraw->m_nIndex >> 2;

+			int nSubIdx = pDraw->m_nIndex & 3;

+

+			FastSpriteQuadBuildoutBufferNonSIMDView_t const *pquad = pQuadBuffer+nSIMDIdx;

+

+			// voodoo - since everything is in 4s, offset structure pointer by a couple of floats to handle sub-index

+			pquad = (FastSpriteQuadBuildoutBufferNonSIMDView_t const *) ( ( (int) ( pquad ) )+ ( nSubIdx << 2 ) );

+			uint8 const *pColorsCasted = reinterpret_cast<uint8 const *> ( pquad->m_Alpha );

+

+			uint8 color[4];

+			color[0] = pquad->m_RGBColor[0][0];

+			color[1] = pquad->m_RGBColor[0][1];

+			color[2] = pquad->m_RGBColor[0][2];

+			color[3] = pColorsCasted[MANTISSA_LSB_OFFSET];

+

+			DetailPropSpriteDict_t *pDict = pquad->m_pSpriteDefs[0];

+

+			meshBuilder.Position3f( pquad->m_flX0[0], pquad->m_flY0[0], pquad->m_flZ0[0] );

+			meshBuilder.Color4ubv( color );

+			meshBuilder.TexCoord2f( 0, pDict->m_TexLR.x, pDict->m_TexLR.y );

+			meshBuilder.AdvanceVertex();

+

+			meshBuilder.Position3f( pquad->m_flX1[0], pquad->m_flY1[0], pquad->m_flZ1[0] );

+			meshBuilder.Color4ubv( color );

+			meshBuilder.TexCoord2f( 0, pDict->m_TexLR.x, pDict->m_TexUL.y );

+			meshBuilder.AdvanceVertex();

+

+			meshBuilder.Position3f( pquad->m_flX2[0], pquad->m_flY2[0], pquad->m_flZ2[0] );

+			meshBuilder.Color4ubv( color );

+			meshBuilder.TexCoord2f( 0, pDict->m_TexUL.x, pDict->m_TexUL.y );

+			meshBuilder.AdvanceVertex();

+

+			meshBuilder.Position3f( pquad->m_flX3[0], pquad->m_flY3[0], pquad->m_flZ3[0] );

+			meshBuilder.Color4ubv( color );

+			meshBuilder.TexCoord2f( 0, pDict->m_TexUL.x, pDict->m_TexLR.y );

+			meshBuilder.AdvanceVertex();

+			pDraw++;

+		}

+	}

+	pData->m_nNumPendingSprites = nCount;

+	pData->m_nStartSpriteIndex = pDraw - m_pFastSortInfo;

+

+	meshBuilder.End();

+	pMesh->Draw();

+	pRenderContext->PopMatrix();

+}

+

+//-----------------------------------------------------------------------------

+// Renders a subset of the detail objects in a particular leaf (for interleaving with other translucent entities)

+//-----------------------------------------------------------------------------

+void CDetailObjectSystem::RenderTranslucentDetailObjectsInLeaf( const Vector &viewOrigin, const Vector &viewForward, const Vector &viewRight, const Vector &viewUp, int nLeaf, const Vector *pVecClosestPoint )

+{

+	VPROF_BUDGET( "CDetailObjectSystem::RenderTranslucentDetailObjectsInLeaf", VPROF_BUDGETGROUP_DETAILPROP_RENDERING );

+

+	RenderFastTranslucentDetailObjectsInLeaf( viewOrigin, viewForward, viewRight, viewUp, nLeaf, pVecClosestPoint );

+	// We may have already sorted this leaf. If not, sort the leaf.

+	if ( m_nSortedLeaf != nLeaf )

+	{

+		m_nSortedLeaf = nLeaf;

+		m_nSpriteCount = 0;

+		m_nFirstSprite = 0;

+

+		// Count the total # of detail sprites we possibly could render

+		LeafIndex_t nLeafIndex = nLeaf;

+		int nSpriteCount = CountSpritesInLeafList( 1, &nLeafIndex );

+		if (nSpriteCount == 0)

+			return;

+

+		// Sort detail sprites in each leaf independently; then render them

+		m_nSpriteCount = SortSpritesBackToFront( nLeaf, viewOrigin, viewForward, m_pSortInfo );

+		Assert( m_nSpriteCount <= nSpriteCount );

+	}

+

+	// No more to draw? Bye!

+	if ( m_nSpriteCount == m_nFirstSprite )

+		return;

+

+	float flMinDistance = 0.0f;

+	if ( pVecClosestPoint )

+	{

+		Vector vecDelta;

+		VectorSubtract( *pVecClosestPoint, viewOrigin, vecDelta );

+		flMinDistance = vecDelta.LengthSqr();

+	}

+

+	if ( m_pSortInfo[m_nFirstSprite].m_flDistance < flMinDistance )

+		return;

+

+	CMatRenderContextPtr pRenderContext( materials );

+	pRenderContext->MatrixMode( MATERIAL_MODEL );

+	pRenderContext->PushMatrix();

+	pRenderContext->LoadIdentity();

+

+	IMaterial *pMaterial = m_DetailSpriteMaterial;

+	if ( ShouldDrawInWireFrameMode() || r_DrawDetailProps.GetInt() == 2 )

+	{

+		pMaterial = m_DetailWireframeMaterial;

+	}

+

+	CMeshBuilder meshBuilder;

+	IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );

+

+	int nMaxVerts, nMaxIndices;

+	pRenderContext->GetMaxToRender( pMesh, false, &nMaxVerts, &nMaxIndices );

+

+	// needs to be * 4 since there are a max of 4 quads per detail object

+	int nQuadCount = ( m_nSpriteCount - m_nFirstSprite ) * 4;

+	int nMaxQuadsToDraw = nMaxIndices/6;

+	if ( nMaxQuadsToDraw > nMaxVerts / 4 )

+	{

+		nMaxQuadsToDraw = nMaxVerts / 4;

+	}

+

+	if ( nMaxQuadsToDraw == 0 )

+		return;

+

+	int nQuadsToDraw = nQuadCount;

+	if ( nQuadsToDraw > nMaxQuadsToDraw )

+	{

+		nQuadsToDraw = nMaxQuadsToDraw;

+	}

+

+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, nQuadsToDraw );

+

+	int nQuadsDrawn = 0;

+	while ( m_nFirstSprite < m_nSpriteCount && m_pSortInfo[m_nFirstSprite].m_flDistance >= flMinDistance )

+	{

+		CDetailModel &model = m_DetailObjects[m_pSortInfo[m_nFirstSprite].m_nIndex];

+		int nQuadsInModel = model.QuadsToDraw();

+		if ( nQuadsDrawn + nQuadsInModel > nQuadsToDraw )

+		{

+			meshBuilder.End();

+			pMesh->Draw();

+

+			nQuadCount = ( m_nSpriteCount - m_nFirstSprite ) * 4;

+			nQuadsToDraw = nQuadCount;

+			if (nQuadsToDraw > nMaxQuadsToDraw)

+			{

+				nQuadsToDraw = nMaxQuadsToDraw;

+			}

+

+			meshBuilder.Begin( pMesh, MATERIAL_QUADS, nQuadsToDraw );

+			nQuadsDrawn = 0;

+		}

+

+		model.DrawSprite( meshBuilder );

+		++m_nFirstSprite;

+		nQuadsDrawn += nQuadsInModel;

+	}

+	meshBuilder.End();

+	pMesh->Draw();

+

+ 	pRenderContext->PopMatrix();

+}

+

+

+//-----------------------------------------------------------------------------

+// Gets called each view

+//-----------------------------------------------------------------------------

+bool CDetailObjectSystem::EnumerateLeaf( int leaf, int context )

+{

+	VPROF_BUDGET( "CDetailObjectSystem::EnumerateLeaf", VPROF_BUDGETGROUP_DETAILPROP_RENDERING );

+	Vector v;

+	int firstDetailObject, detailObjectCount;

+

+	EnumContext_t* pCtx = (EnumContext_t*)context;

+	ClientLeafSystem()->DrawDetailObjectsInLeaf( leaf, pCtx->m_BuildWorldListNumber, 

+		firstDetailObject, detailObjectCount );

+

+	// Compute the translucency. Need to do it now cause we need to

+	// know that when we're rendering (opaque stuff is rendered first)

+	for ( int i = 0; i < detailObjectCount; ++i)

+	{

+		// Calculate distance (badly)

+		CDetailModel& model = m_DetailObjects[firstDetailObject+i];

+		VectorSubtract( model.GetRenderOrigin(), pCtx->m_vViewOrigin, v );

+

+		float sqDist = v.LengthSqr();

+

+		model.SetAlpha( 255 );

+		if ( sqDist < m_flCurMaxSqDist )

+		{

+			if ( sqDist > m_flCurFadeSqDist ) 

+			{

+				model.SetAlpha( m_flCurFalloffFactor * ( m_flCurMaxSqDist - sqDist ) );

+			}

+			else

+			{

+				model.SetAlpha( 255 );

+			}

+			

+			// Perform screen alignment if necessary.

+			model.ComputeAngles();

+		}

+		else

+		{

+			model.SetAlpha( 0 );

+		}

+	}

+	return true;

+}

+

+

+//-----------------------------------------------------------------------------

+// Gets called each view

+//-----------------------------------------------------------------------------

+void CDetailObjectSystem::BuildDetailObjectRenderLists( const Vector &vViewOrigin )

+{

+	VPROF_BUDGET( "CDetailObjectSystem::BuildDetailObjectRenderLists", VPROF_BUDGETGROUP_DETAILPROP_RENDERING );

+	

+	if (!g_pClientMode->ShouldDrawDetailObjects() || (r_DrawDetailProps.GetInt() == 0))

+		return;

+

+	// Don't bother doing any of this if the level doesn't have detail props.

+	if ( ( ! m_pFastSpriteData ) && ( m_DetailObjects.Count() == 0 ) )

+		return;

+

+	EnumContext_t ctx;

+	ctx.m_vViewOrigin = vViewOrigin;

+ 	ctx.m_BuildWorldListNumber = view->BuildWorldListsNumber();

+

+	// We need to recompute translucency information for all detail props

+	for (int i = m_DetailObjectDict.Size(); --i >= 0; )

+	{

+		if (modelinfo->ModelHasMaterialProxy( m_DetailObjectDict[i].m_pModel ))

+		{

+			modelinfo->RecomputeTranslucency( m_DetailObjectDict[i].m_pModel, 0, 0, NULL );

+		}

+	}

+

+	float factor = 1.0f;

+	C_BasePlayer *local = C_BasePlayer::GetLocalPlayer();

+	if ( local )

+	{

+		factor = local->GetFOVDistanceAdjustFactor();

+	}

+

+	// Compute factors to optimize rendering of the detail models

+	m_flCurMaxSqDist = cl_detaildist.GetFloat() * cl_detaildist.GetFloat();

+	m_flCurFadeSqDist = cl_detaildist.GetFloat() - cl_detailfade.GetFloat();

+

+	m_flCurMaxSqDist /= factor;

+	m_flCurFadeSqDist /= factor;

+

+	if ( m_flCurFadeSqDist > 0)

+	{

+		m_flCurFadeSqDist *= m_flCurFadeSqDist;

+	}

+	else 

+	{

+		m_flCurFadeSqDist = 0;

+	}

+	m_flCurFadeSqDist = MIN( m_flCurFadeSqDist, m_flCurMaxSqDist -1  );

+	m_flCurFalloffFactor = 255.0f / ( m_flCurMaxSqDist - m_flCurFadeSqDist );

+

+

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

+	pQuery->EnumerateLeavesInSphere( CurrentViewOrigin(), 

+									 cl_detaildist.GetFloat(), this, (int)&ctx );

+}

+