1HEADmaster

1 files changed, 931 insertions, 0 deletions

diff --git a/studiorender/studiorender.h b/studiorender/studiorender.h
new file mode 100644
index 0000000..50a875a
--- /dev/null
+++ b/studiorender/studiorender.h
@@ -0,0 +1,931 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//===========================================================================//
+
+#ifndef CSTUDIORENDER_H
+#define CSTUDIORENDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "istudiorender.h"
+#include "studio.h"
+#include "materialsystem/imaterialsystem.h" // for LightDesc_t
+// wouldn't have to include these if it weren't for inlines.
+#include "materialsystem/imaterial.h"
+#include "mathlib/mathlib.h"
+#include "utllinkedlist.h"
+#include "utlvector.h"
+#include "tier1/utllinkedlist.h"
+#include "flexrenderdata.h"
+#include "mathlib/compressed_vector.h"
+#include "r_studiolight.h"
+#if defined( _WIN32 ) && !defined( _X360 )
+#include <xmmintrin.h>
+#endif
+#include "tier0/dbg.h"
+
+
+//-----------------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------------
+class ITexture;
+class CPixelWriter;
+class CMeshBuilder;
+class IMaterialVar;
+struct mstudioeyeball_t;
+struct eyeballstate_t;
+struct lightpos_t;
+struct dworldlight_t;
+struct DecalClipState_t;
+class CStudioRender;
+struct StudioRenderContext_t;
+struct FlexWeights_t;
+
+namespace OptimizedModel
+{
+	struct FileHeader_t;
+	struct MeshHeader_t;
+	struct StripGroupHeader_t;
+	struct Vertex_t;
+	struct ModelLODHeader_t;
+}
+
+
+//-----------------------------------------------------------------------------
+// FIXME: Remove
+//-----------------------------------------------------------------------------
+class IStudioDataCache;
+extern IStudioDataCache *g_pStudioDataCache;
+
+
+//-----------------------------------------------------------------------------
+// Singleton
+//-----------------------------------------------------------------------------
+extern CStudioRender g_StudioRender;
+
+
+//-----------------------------------------------------------------------------
+// Defines + structs
+//-----------------------------------------------------------------------------
+#define MAXLOCALLIGHTS 4
+#define MAXLIGHTCOMPUTE 16
+
+enum StudioModelLighting_t
+{
+	LIGHTING_HARDWARE = 0,
+	LIGHTING_SOFTWARE,
+	LIGHTING_MOUTH
+};
+
+struct lightpos_t
+{
+	Vector	delta;		// unit vector from vertex to light
+	float	falloff;	// light distance falloff
+	float	dot;		// light direction * delta;
+
+	lightpos_t() {}
+
+private:
+	// Copy constructors are not allowed
+	lightpos_t( const lightpos_t& src );
+};
+
+struct eyeballstate_t
+{
+	const mstudioeyeball_t *peyeball;
+
+	matrix3x4_t	mat;
+
+	Vector	org;		// world center of eyeball
+	Vector	forward;	
+	Vector	right;
+	Vector	up;
+	
+	Vector	cornea;		// world center of cornea
+
+	eyeballstate_t() {}
+
+private:
+	// Copy constructors are not allowed
+	eyeballstate_t( const eyeballstate_t& src );
+};
+
+
+//-----------------------------------------------------------------------------
+// Store decal vertex data here 
+//-----------------------------------------------------------------------------
+#pragma pack(1)
+struct DecalVertex_t
+{
+	mstudiomesh_t *GetMesh( studiohdr_t *pHdr )
+	{
+		if ((m_Body == 0xFFFF) || (m_Model == 0xFFFF) || (m_Mesh == 0xFFFF))
+			return NULL;
+
+		mstudiobodyparts_t *pBody = pHdr->pBodypart( m_Body );
+		mstudiomodel_t *pModel = pBody->pModel( m_Model );
+		return pModel->pMesh( m_Mesh );
+	}
+
+	IMorph *GetMorph( studiohdr_t *pHdr, studiomeshdata_t *pStudioMeshes )
+	{
+		if ( (m_Body == 0xFFFF) || (m_Model == 0xFFFF) || (m_Mesh == 0xFFFF) || (m_Group == 0xFFFF) )
+			return NULL;
+
+		mstudiobodyparts_t *pBody = pHdr->pBodypart( m_Body );
+		mstudiomodel_t *pModel = pBody->pModel( m_Model );
+		mstudiomesh_t *pMesh = pModel->pMesh( m_Mesh );
+		studiomeshdata_t* pMeshData = &pStudioMeshes[pMesh->meshid];
+		studiomeshgroup_t* pGroup = &pMeshData->m_pMeshGroup[m_Group];
+		return pGroup->m_pMorph;
+	}
+
+	// NOTE: m_Group + m_GroupIndex is necessary only for decals on
+	// hardware morphs. If COMPACT_DECAL_VERT is for console, we
+	// could remove group index + group
+#ifdef COMPACT_DECAL_VERT
+	Vector			m_Position;			// 12
+	Vector2d32		m_TexCoord;			// 16
+	Vector48		m_Normal;			// 22 (packed to m_Body)
+
+	byte			m_Body;				// 24
+	byte			m_Model;
+	unsigned short	m_MeshVertexIndex;	// index into the mesh's vertex list
+	unsigned short	m_Mesh;
+	unsigned short	m_GroupIndex;		// index into the mesh's vertex list
+	unsigned short	m_Group;
+#else
+	Vector m_Position;
+	Vector m_Normal;
+	Vector2D m_TexCoord;
+
+	unsigned short	m_MeshVertexIndex;	// index into the mesh's vertex list
+	unsigned short	m_Body;
+	unsigned short	m_Model;
+	unsigned short	m_Mesh;
+	unsigned short	m_GroupIndex;		// index into the group's index list
+	unsigned short	m_Group;
+#endif
+
+	DecalVertex_t() {}
+	DecalVertex_t( const DecalVertex_t& src )
+	{
+		m_Position = src.m_Position;
+		m_Normal = src.m_Normal;
+		m_TexCoord = src.m_TexCoord;
+		m_MeshVertexIndex = src.m_MeshVertexIndex;
+		m_Body = src.m_Body;
+		m_Model = src.m_Model;
+		m_Mesh = src.m_Mesh;
+		m_GroupIndex = src.m_GroupIndex;
+		m_Group = src.m_Group;
+	}
+};
+#pragma pack()
+
+
+//-----------------------------------------------------------------------------
+// Temporary meshes
+//-----------------------------------------------------------------------------
+struct MeshVertexInfo_t
+{
+	mstudiomesh_t *m_pMesh;
+	int m_nIndex;
+};
+
+
+//-----------------------------------------------------------------------------
+// Vertex prefetch count for software skinning
+//-----------------------------------------------------------------------------
+enum
+{
+	PREFETCH_VERT_COUNT = 4
+};
+
+
+//-----------------------------------------------------------------------------
+// Class that actually renders stuff
+//-----------------------------------------------------------------------------
+class CStudioRender
+{
+public:
+	CStudioRender();
+	~CStudioRender();
+
+	// Init, shutdown
+	InitReturnVal_t Init();
+	void Shutdown( void );
+
+	void EnableScissor( FlashlightState_t *state );
+	void DisableScissor();
+
+	void DrawModel( const DrawModelInfo_t& info, const StudioRenderContext_t& rc, matrix3x4_t *pBoneToWorld, const FlexWeights_t& flex, int flags = STUDIORENDER_DRAW_ENTIRE_MODEL );
+	void DrawModelArray( const DrawModelInfo_t &drawInfo, const StudioRenderContext_t &rc, int arrayCount, model_array_instance_t *pInstanceData, int instanceStride, int flags = STUDIORENDER_DRAW_ENTIRE_MODEL );
+
+	// Static-prop related draw methods
+	void DrawModelStaticProp( const DrawModelInfo_t& info, const StudioRenderContext_t &rc, const matrix3x4_t &modelToWorld, int flags = STUDIORENDER_DRAW_ENTIRE_MODEL );
+	void DrawStaticPropShadows( const DrawModelInfo_t &drawInfo, const StudioRenderContext_t &rc, const matrix3x4_t &modelToWorld, int flags );
+	void DrawStaticPropDecals( const DrawModelInfo_t &drawInfo, const StudioRenderContext_t &rc, const matrix3x4_t &modelToWorld );
+
+	void ModelStats( const DrawModelInfo_t& info, const StudioRenderContext_t &rc, matrix3x4_t *pBoneToWorld, const FlexWeights_t &flex, int flags );
+
+	// Create, destroy list of decals for a particular model
+	StudioDecalHandle_t CreateDecalList( studiohwdata_t *pHardwareData );
+	void DestroyDecalList( StudioDecalHandle_t handle );
+
+	// Add decals to a decal list by doing a planar projection along the ray
+	void AddDecal( StudioDecalHandle_t handle, const StudioRenderContext_t& rc, matrix3x4_t *pBoneToWorld, studiohdr_t *pStudioHdr, 
+			const Ray_t & ray, const Vector& decalUp, IMaterial* pDecalMaterial, 
+			float radius, int body, bool noPokethru, int maxLODToDecal = ADDDECAL_TO_ALL_LODS );
+
+	// Shadow state (affects the models as they are rendered)
+	void AddShadow( IMaterial* pMaterial, void* pProxyData, FlashlightState_t *pFlashlightState, VMatrix *pWorldToTexture, ITexture *pFlashlightDepthTexture );
+	void ClearAllShadows();
+
+	// Release/restore material system objects
+	void PrecacheGlint();
+	void UncacheGlint();
+
+	// Get the config
+	void R_MouthComputeLightingValues( float& fIllum, Vector& forward );
+	void R_MouthLighting( float fIllum, const Vector& normal, const Vector& forward, Vector& light );
+
+	// Performs the lighting computation
+	inline void R_ComputeLightAtPoint3( const Vector &pos, const Vector &norm, Vector &color );
+
+#if defined( _WIN32 ) && !defined( _X360 )
+	// sse-ized lighting pipeline. lights 4 vertices at once
+	inline void R_ComputeLightAtPoints3( const FourVectors &pos, const FourVectors &norm, FourVectors &color );
+	void R_MouthLighting( __m128 fIllum, const FourVectors& normal, const FourVectors& forward, FourVectors& light );
+#endif
+
+private:
+	enum
+	{
+		DECAL_DYNAMIC = 0x1,
+		DECAL_SECONDPASS = 0x2,
+	};
+
+	typedef unsigned short DecalId_t;
+
+	struct Decal_t
+	{
+		int m_IndexCount;
+		int m_VertexCount;
+		float m_FadeStartTime;
+		float m_FadeDuration;
+		int	m_Flags;
+	};
+
+	struct DecalHistory_t
+	{
+		unsigned short m_Material;
+		unsigned short m_Decal;
+		DecalId_t m_nId;
+		unsigned short m_nPad;
+	};
+
+	typedef CUtlLinkedList<DecalVertex_t, unsigned short> DecalVertexList_t;
+
+	typedef CUtlVector<unsigned short> DecalIndexList_t;
+	typedef CUtlLinkedList<Decal_t, unsigned short> DecalList_t;
+	typedef CUtlLinkedList<DecalHistory_t, unsigned short> DecalHistoryList_t;
+
+	struct DecalMaterial_t
+	{
+		IMaterial*			m_pMaterial;
+		DecalIndexList_t	m_Indices;
+		DecalVertexList_t	m_Vertices;
+		DecalList_t			m_Decals;
+	};
+
+	struct DecalLod_t
+	{
+		unsigned short m_FirstMaterial;
+		DecalHistoryList_t	m_DecalHistory;
+	};
+
+	struct DecalModelList_t
+	{
+		studiohwdata_t* m_pHardwareData;
+		DecalLod_t* m_pLod;
+		int m_nLods; // need to retain because hardware data could be flushed
+	};
+
+	// A temporary structure used to figure out new decal verts
+	struct DecalBuildVertexInfo_t
+	{
+		enum
+		{
+			FRONT_FACING = 0x1,
+			VALID_AREA = 0x2,		// If you change this, change ProjectDecalOntoMesh
+		};
+
+		Vector2D		m_UV;
+		unsigned short	m_VertexIndex;	// index into the DecalVertex_t list
+		unsigned char	m_UniqueID;
+		unsigned char	m_Flags;
+
+	private:
+		// No copy constructors
+		DecalBuildVertexInfo_t( const DecalBuildVertexInfo_t &src );
+	};
+
+	struct DecalBuildInfo_t
+	{
+		IMaterial						**m_ppMaterials;
+		studiohdr_t						*m_pStudioHdr;
+		mstudiomesh_t					*m_pMesh;
+		studiomeshdata_t				*m_pMeshData;
+		DecalMaterial_t					*m_pDecalMaterial;
+		MeshVertexInfo_t				*m_pMeshVertices;
+		const mstudio_meshvertexdata_t	*m_pMeshVertexData;
+		const thinModelVertices_t		*m_pMeshThinVertexData;
+		int								m_nGlobalMeshIndex;
+		DecalBuildVertexInfo_t			*m_pVertexBuffer;
+		float							m_Radius;
+		DecalBuildVertexInfo_t			*m_pVertexInfo;
+		int								m_Body;
+		int								m_Model;
+		int								m_Mesh;
+		int								m_Group;
+		DecalVertexList_t::IndexType_t	m_FirstVertex;
+		unsigned short					m_VertexCount;
+		bool							m_UseClipVert;
+		bool							m_NoPokeThru;
+	};
+
+	struct ShadowState_t
+	{
+		IMaterial*			m_pMaterial;
+		void*				m_pProxyData;
+		FlashlightState_t * m_pFlashlightState;
+		VMatrix *			m_pWorldToTexture;
+		ITexture *			m_pFlashlightDepthTexture;
+	};
+
+	struct BodyPartInfo_t
+	{
+		int m_nSubModelIndex;
+		mstudiomodel_t *m_pSubModel;
+	};
+
+	struct GlintRenderData_t
+	{
+		Vector2D m_vecPosition;
+		Vector m_vecIntensity;
+	};
+
+	// Global LRU for model decals
+	struct DecalLRU_t
+	{
+		StudioDecalHandle_t m_hDecalHandle;
+		DecalId_t m_nDecalId;
+	};
+
+	typedef CUtlFixedLinkedList< DecalLRU_t >::IndexType_t DecalLRUListIndex_t;
+
+private:
+	void SetLightingRenderState();
+
+	int R_StudioRenderModel( IMatRenderContext *pRenderContext, int skin, int body, int hitboxset, void /*IClientEntity*/ *pEntity, 
+		IMaterial **ppMaterials, int *pMaterialFlags, int flags, int boneMask, int lod, ColorMeshInfo_t *pColorMeshes = NULL );
+	IMaterial* R_StudioSetupSkinAndLighting( IMatRenderContext *pRenderContext, int index, IMaterial **ppMaterials, int materialFlags,
+		void /*IClientEntity*/ *pClientEntity, ColorMeshInfo_t *pColorMeshes, StudioModelLighting_t &lighting );
+	int R_StudioDrawEyeball( IMatRenderContext *pRenderContext, mstudiomesh_t* pmesh,  studiomeshdata_t* pMeshData,
+		StudioModelLighting_t lighting, IMaterial *pMaterial, int lod );
+	int R_StudioDrawPoints( IMatRenderContext *pRenderContext, int skin, void /*IClientEntity*/ *pClientEntity, 
+		IMaterial **ppMaterials, int *pMaterialFlags, int boneMask, int lod, ColorMeshInfo_t *pColorMeshes );
+	int R_StudioDrawMesh( IMatRenderContext *pRenderContext, mstudiomesh_t* pmesh, studiomeshdata_t* pMeshData,
+		  				   StudioModelLighting_t lighting, IMaterial *pMaterial, ColorMeshInfo_t *pColorMeshes, int lod );
+	int R_StudioRenderFinal( IMatRenderContext *pRenderContext, 
+		int skin, int nBodyPartCount, BodyPartInfo_t *pBodyPartInfo, void /*IClientEntity*/ *pClientEntity,
+		IMaterial **ppMaterials, int *pMaterialFlags, int boneMask, int lod, ColorMeshInfo_t *pColorMeshes = NULL );
+	int R_StudioDrawStaticMesh( IMatRenderContext *pRenderContext, mstudiomesh_t* pmesh, 
+		studiomeshgroup_t* pGroup, StudioModelLighting_t lighting, float r_blend, IMaterial* pMaterial,
+		int lod, ColorMeshInfo_t *pColorMeshes );
+	int R_StudioDrawDynamicMesh( IMatRenderContext *pRenderContext, mstudiomesh_t* pmesh, 
+				studiomeshgroup_t* pGroup, StudioModelLighting_t lighting, 
+				float r_blend, IMaterial* pMaterial, int lod );
+	int R_StudioDrawGroupHWSkin( IMatRenderContext *pRenderContext, studiomeshgroup_t* pGroup, IMesh* pMesh, ColorMeshInfo_t *pColorMeshInfo = NULL );
+	int R_StudioDrawGroupSWSkin( studiomeshgroup_t* pGroup, IMesh* pMesh );
+	void R_StudioDrawHulls( int hitboxset, bool translucent );
+	void R_StudioDrawBones (void);
+	void R_StudioVertBuffer( void );
+	void DrawNormal( const Vector& pos, float scale, const Vector& normal, const Vector& color );
+	void BoneMatToMaterialMat( matrix3x4_t& boneMat, float materialMat[4][4] );
+
+	// Various inner-loop methods
+	void R_StudioSoftwareProcessMesh( mstudiomesh_t* pmesh, CMeshBuilder& meshBuilder, 
+			int numVertices, unsigned short* pGroupToMesh, StudioModelLighting_t lighting, bool doFlex, float r_blend,
+			bool bNeedsTangentSpace, bool bDX8Vertex, IMaterial *pMaterial );
+
+	void R_StudioSoftwareProcessMesh_Normals( mstudiomesh_t* pmesh, CMeshBuilder& meshBuilder, 
+			int numVertices, unsigned short* pGroupToMesh, StudioModelLighting_t lighting, bool doFlex, float r_blend,
+			bool bShowNormals, bool bShowTangentFrame );
+
+	template< class T >
+	void ComputeFlexedVertex_StreamOffset( mstudioflex_t *pflex, T *pvanim, int vertCount, float w1, float w2, float w3, float w4 );
+
+	void R_StudioProcessFlexedMesh_StreamOffset( mstudiomesh_t* pmesh, int lod );
+
+	template <VertexCompressionType_t T> void FillFlexMeshGroupVB( CMeshBuilder & meshBuilder, studiomeshgroup_t *pGroup );
+	void R_StudioFlexMeshGroup( studiomeshgroup_t *pGroup );
+
+	template<VertexCompressionType_t T> void R_StudioRestoreMesh( mstudiomesh_t* pmesh, studiomeshgroup_t* pMeshData );
+	void R_StudioProcessFlexedMesh( mstudiomesh_t* pmesh, CMeshBuilder& meshBuilder, 
+		int numVertices, unsigned short* pGroupToMesh );
+
+	// Eye rendering using vertex shaders
+	void SetEyeMaterialVars( IMaterial* pMaterial, mstudioeyeball_t* peyeball, 
+		const Vector& eyeOrigin, const matrix3x4_t& irisTransform, const matrix3x4_t& glintTransform );
+
+	void ComputeEyelidStateFACS( mstudiomodel_t *pSubModel );
+
+	void R_StudioEyelidFACS( const mstudioeyeball_t *peyeball, const eyeballstate_t *pstate );
+
+	void R_StudioEyeballPosition( const mstudioeyeball_t *peyeball, eyeballstate_t *pstate );
+
+	// Computes the texture projection matrix for the glint texture
+	void ComputeGlintTextureProjection( eyeballstate_t const* pState, 
+		const Vector& vright, const Vector& vup, matrix3x4_t& mat );
+
+	void R_StudioEyeballGlint( const eyeballstate_t *pstate, IMaterialVar *pGlintTextureVar, 
+								const Vector& vright, const Vector& vup, const Vector& r_origin );
+	ITexture* RenderGlintTexture( const eyeballstate_t *pstate,
+		const Vector& vright, const Vector& vup, const Vector& r_origin );
+
+	int BuildGlintRenderData( GlintRenderData_t *pData, int nMaxGlints,
+		const eyeballstate_t *pstate, const Vector& vright, const Vector& vup, const Vector& r_origin );
+	void R_MouthSetupVertexShader( IMaterial* pMaterial );
+
+	// Computes a vertex format to use
+	VertexFormat_t ComputeSWSkinVertexFormat( IMaterial *pMaterial ) const;
+
+	inline bool R_TeethAreVisible( void )
+	{
+		return true;
+		/*
+		// FIXME: commented out until Gary can change them to just draw black
+		mstudiomouth_t *pMouth = m_pStudioHdr->pMouth( 0 ); 
+		float fIllum = m_FlexWeights[pMouth->flexdesc];
+		return fIllum > 0.0f;
+		*/
+	}
+
+	inline StudioModelLighting_t R_StudioComputeLighting( IMaterial *pMaterial, int materialFlags, ColorMeshInfo_t *pColorMeshes );
+	inline void R_StudioTransform( Vector& in1, mstudioboneweight_t *pboneweight, Vector& out1 );
+	inline void R_StudioRotate( Vector& in1, mstudioboneweight_t *pboneweight, Vector& out1 );
+	inline void R_StudioRotate( Vector4D& in1, mstudioboneweight_t *pboneweight, Vector4D& out1 );
+	inline void R_StudioEyeballNormal( mstudioeyeball_t const* peyeball, Vector& org, 
+									Vector& pos, Vector& normal );
+	void MaterialPlanerProjection( const matrix3x4_t& mat, int count, const Vector *psrcverts, Vector2D *pdesttexcoords );
+	void AddGlint( CPixelWriter &pixelWriter, float x, float y, const Vector& color );
+
+	// Methods associated with lighting
+	int R_LightGlintPosition( int index, const Vector& org, Vector& delta, Vector& intensity );
+	void R_LightEffectsWorld( const lightpos_t *light, const Vector& normal, const Vector &src, Vector &dest );
+
+	void R_GatherStats( studiomeshgroup_t *pGroup, CMeshBuilder &MeshBuilder, IMesh *pMesh, IMaterial *pMaterial );
+
+public:
+	// NJS: Messy, but needed for an externally optimized routine to set up the lighting.
+	void R_InitLightEffectsWorld3();
+	void (FASTCALL *R_LightEffectsWorld3)( const LightDesc_t *pLightDesc, const lightpos_t *light, const Vector& normal, Vector &dest );
+
+private:
+	inline float R_WorldLightAngle( const LightDesc_t *wl, const Vector& lnormal, const Vector& snormal, const Vector& delta );
+
+	void InitDebugMaterials( void );
+	void ShutdownDebugMaterials( void );
+	int SortMeshes( int* pIndices, IMaterial **ppMaterials, short* pskinref, const Vector& vforward, const Vector& r_origin );
+
+	// Computes pose to decal space transforms for decal creation 
+	// returns false if it can't for some reason.
+	bool ComputePoseToDecal( Ray_t const& ray, const Vector& up );
+
+	bool AddDecalToModel( DecalBuildInfo_t& buildInfo );
+
+	// Helper methods for decal projection, projects pose space vertex data
+	bool			TransformToDecalSpace( DecalBuildInfo_t& build, const Vector& pos, mstudioboneweight_t *pboneweight, Vector2D& uv );
+	bool			ProjectDecalOntoMesh( DecalBuildInfo_t& build, DecalBuildVertexInfo_t* pVertexInfo, mstudiomesh_t *pMesh );
+	bool			IsFrontFacing( const Vector * norm, const mstudioboneweight_t *pboneweight );
+	int				ComputeClipFlags( DecalBuildVertexInfo_t* pVertexInfo, int i );
+	void			ConvertMeshVertexToDecalVertex( DecalBuildInfo_t& build, int meshIndex, DecalVertex_t& decalVertex, int nGroupIndex = 0xFFFF );
+	unsigned short	AddVertexToDecal( DecalBuildInfo_t& build, int meshIndex, int nGroupIndex = 0xFFFF );
+	unsigned short	AddVertexToDecal( DecalBuildInfo_t& build, DecalVertex_t& vert );
+	void			AddClippedDecalToTriangle( DecalBuildInfo_t& build, DecalClipState_t& clipState );
+	bool			ClipDecal( DecalBuildInfo_t& build, int i1, int i2, int i3, int *pClipFlags );
+	void			AddTriangleToDecal( DecalBuildInfo_t& build, int i1, int i2, int i3, int gi1, int gi2, int gi3 );
+	void			AddDecalToMesh( DecalBuildInfo_t& build );
+	int				GetDecalMaterial( DecalLod_t& decalLod, IMaterial* pDecalMaterial );
+	int				AddDecalToMaterialList( DecalMaterial_t* pMaterial );
+
+	// Total number of meshes we have to deal with
+	int ComputeTotalMeshCount( int iRootLOD, int iMaxLOD, int body ) const;
+
+	// Project decals onto all meshes
+	void ProjectDecalsOntoMeshes( DecalBuildInfo_t& build, int nMeshCount );
+
+	// Set up the locations for vertices to use
+	int ComputeVertexAllocation( int iMaxLOD, int body, studiohwdata_t *pHardwareData, MeshVertexInfo_t *pVertexInfo );
+
+	// Removes a decal and associated vertices + indices from the history list
+	void RetireDecal( DecalModelList_t &list, DecalId_t nDecalID, int iLOD, int iMaxLOD );
+
+	// Helper methods related to drawing decals
+	void DrawSingleBoneDecals( CMeshBuilder& meshBuilder, DecalMaterial_t& decalMaterial );
+	bool DrawMultiBoneDecals( CMeshBuilder& meshBuilder, DecalMaterial_t& decalMaterial, studiohdr_t *pStudioHdr );
+	void DrawSingleBoneFlexedDecals( IMatRenderContext *pRenderContext, CMeshBuilder& meshBuilder, DecalMaterial_t& decalMaterial );
+	bool DrawMultiBoneFlexedDecals( IMatRenderContext *pRenderContext, CMeshBuilder& meshBuilder, DecalMaterial_t& decalMaterial, studiohdr_t *pStudioHdr, studioloddata_t *pStudioLOD );
+	void DrawDecalMaterial( IMatRenderContext *pRenderContext, DecalMaterial_t& decalMaterial, studiohdr_t *pStudioHdr, studioloddata_t *pStudioLOD );
+	void DrawDecal( const DrawModelInfo_t &drawInfo, int lod, int body );
+	bool PreDrawDecal( IMatRenderContext *pRenderContext, const DrawModelInfo_t &drawInfo );
+	
+	// Draw shadows
+	void DrawShadows( const DrawModelInfo_t& info, int flags, int boneMask );
+
+	// Draw flashlight lighting on decals.
+	void DrawFlashlightDecals( const DrawModelInfo_t& info, int lod );
+	
+	// Helper methods related to extracting and balancing
+	float RampFlexWeight( mstudioflex_t &flex, float w );
+
+	// Remove decal from LRU
+	void RemoveDecalListFromLRU( StudioDecalHandle_t h );
+
+	// Helper methods related to flexing vertices
+	void R_StudioFlexVerts( mstudiomesh_t *pmesh, int lod );
+
+	// Flex stats
+	void GetFlexStats( );
+
+	// Sets up the hw flex mesh
+	void ComputeFlexWeights( int nFlexCount, mstudioflex_t *pFlex, MorphWeight_t *pWeights );
+
+	// Generate morph accumulator
+	void GenerateMorphAccumulator( mstudiomodel_t *pSubModel );
+
+	// Computes eyeball state
+	void ComputeEyeballState( mstudiomodel_t *pSubModel );
+
+	// Avoid some warnings...
+	CStudioRender( CStudioRender const& );
+
+public:
+	// Render context (comes from queue)
+	StudioRenderContext_t *m_pRC;
+
+private:
+	// Stores all decals for a particular material and lod
+	CUtlLinkedList< DecalMaterial_t, unsigned short, true >	m_DecalMaterial;
+
+	// Stores all decal lists that have been made
+	CUtlFixedLinkedList< DecalModelList_t >	m_DecalList;
+	CThreadFastMutex m_DecalMutex;
+
+	// Stores all shadows to be cast on the current object
+	CUtlVector<ShadowState_t>	m_ShadowState;
+
+	matrix3x4_t m_StaticPropRootToWorld;
+	matrix3x4_t	*m_pBoneToWorld;	// bone transformation matrix( comes from queue )
+
+	matrix3x4_t *m_PoseToWorld;	// bone transformation matrix
+	matrix3x4_t *m_PoseToDecal;	// bone transformation matrix
+
+	// Flex state, comes from queue
+	float *m_pFlexWeights;
+	float *m_pFlexDelayedWeights;
+
+	studiohdr_t *m_pStudioHdr;
+	mstudiomodel_t *m_pSubModel;
+	studiomeshdata_t *m_pStudioMeshes;
+
+	eyeballstate_t m_pEyeballState[16]; // MAXSTUDIOEYEBALLS
+
+	// debug materials
+	IMaterial		*m_pMaterialMRMWireframe;
+	IMaterial		*m_pMaterialMRMWireframeZBuffer;
+	IMaterial		*m_pMaterialMRMNormals;
+	IMaterial		*m_pMaterialTangentFrame;
+	IMaterial		*m_pMaterialTranslucentModelHulls;
+	IMaterial		*m_pMaterialSolidModelHulls;
+	IMaterial		*m_pMaterialAdditiveVertexColorVertexAlpha;
+	IMaterial		*m_pMaterialModelBones;
+	IMaterial		*m_pMaterialWorldWireframe;
+	IMaterial		*m_pMaterialModelEnvCubemap;
+
+	// Depth override material
+	IMaterial		*m_pDepthWrite[2][2];
+	IMaterial		*m_pSSAODepthWrite[2][2];
+
+	// GLINT data
+	ITexture* m_pGlintTexture;
+	ITexture* m_pGlintLODTexture;
+	IMaterial *m_pGlintBuildMaterial;
+	short	m_GlintWidth;
+	short	m_GlintHeight;
+
+	// Flex data
+	CCachedRenderData	m_VertexCache;
+
+	// Cached variables:
+	bool m_bSkippedMeshes : 1;
+	bool m_bDrawTranslucentSubModels : 1;
+
+	DecalId_t	m_nDecalId;
+	CUtlFixedLinkedList< DecalLRU_t > m_DecalLRU;
+
+	friend class CGlintTextureRegenerator;
+	friend struct mstudiomodel_t;
+	friend class CStudioRenderContext;
+};
+
+
+//-----------------------------------------------------------------------------
+// Converts matrices to a format material system wants
+//-----------------------------------------------------------------------------
+
+/*
+================
+R_StudioTransform
+================
+*/
+inline void CStudioRender::R_StudioTransform( Vector& in1, mstudioboneweight_t *pboneweight, Vector& out1 )
+{
+//	MEASURECODE( "R_StudioTransform" );
+
+	Vector out2;
+	switch( pboneweight->numbones )
+	{
+	case 1:
+		VectorTransform( in1, m_PoseToWorld[(unsigned)pboneweight->bone[0]], out1 );
+		break;
+/*
+	case 2:
+		VectorTransform( in1, m_PoseToWorld[pboneweight->bone[0]], out1 );
+		out1 *= pboneweight->weight[0];
+		VectorTransform( in1, m_PoseToWorld[pboneweight->bone[1]], out2 );
+		VectorMA( out1, pboneweight->weight[1], out2, out1 );
+		break;
+
+	case 3:
+		VectorTransform( in1, m_PoseToWorld[pboneweight->bone[0]], out1 );
+		out1 *= pboneweight->weight[0];
+		VectorTransform( in1, m_PoseToWorld[pboneweight->bone[1]], out2 );
+		VectorMA( out1, pboneweight->weight[1], out2, out1 );
+		VectorTransform( in1, m_PoseToWorld[pboneweight->bone[2]], out2 );
+		VectorMA( out1, pboneweight->weight[2], out2, out1 );
+		break;
+*/
+	default:
+		VectorFill( out1, 0 );
+		for (int i = 0; i < pboneweight->numbones; i++)
+		{
+			VectorTransform( in1, m_PoseToWorld[(unsigned)pboneweight->bone[i]], out2 );
+			VectorMA( out1, pboneweight->weight[i], out2, out1 );
+		}
+		break;
+	}
+}
+
+
+/*
+================
+R_StudioRotate
+================
+*/
+inline void CStudioRender::R_StudioRotate( Vector& in1, mstudioboneweight_t *pboneweight, Vector& out1 )
+{
+	// NOTE: This only works to rotate normals if there's no scale in the
+	// pose to world transforms. If we ever add scale, we'll need to
+	// multiply by the inverse transpose of the pose to world
+
+	if (pboneweight->numbones == 1)
+	{
+		VectorRotate( in1, m_PoseToWorld[(unsigned)pboneweight->bone[0]], out1 );
+	}
+	else
+	{
+		Vector out2;
+
+		VectorFill( out1, 0 );
+
+		for (int i = 0; i < pboneweight->numbones; i++)
+		{
+			VectorRotate( in1, m_PoseToWorld[(unsigned)pboneweight->bone[i]], out2 );
+			VectorMA( out1, pboneweight->weight[i], out2, out1 );
+		}
+		VectorNormalize( out1 );
+	}
+}
+
+inline void CStudioRender::R_StudioRotate( Vector4D& realIn1, mstudioboneweight_t *pboneweight, Vector4D& realOut1 )
+{
+	// garymcthack - god this sucks.
+	Vector in1( realIn1[0], realIn1[1], realIn1[2] );
+	Vector out1;
+	if (pboneweight->numbones == 1)
+	{
+		VectorRotate( in1, m_PoseToWorld[(unsigned)pboneweight->bone[0]], out1 );
+	}
+	else
+	{
+		Vector out2;
+
+		VectorFill( out1, 0 );
+
+		for (int i = 0; i < pboneweight->numbones; i++)
+		{
+			VectorRotate( in1, m_PoseToWorld[(unsigned)pboneweight->bone[i]], out2 );
+			VectorMA( out1, pboneweight->weight[i], out2, out1 );
+		}
+		VectorNormalize( out1 );
+	}
+	realOut1.Init( out1[0], out1[1], out1[2], realIn1[3] );
+}
+
+
+//-----------------------------------------------------------------------------
+// Compute the contribution of a light depending on it's angle
+//-----------------------------------------------------------------------------
+/*
+  light_normal (lights normal translated to same space as other normals)
+  surface_normal
+  light_direction_normal | (light_pos - vertex_pos) |
+*/
+
+template< int nLightType >
+class CWorldLightAngleWrapper
+{
+public:
+	FORCEINLINE static float WorldLightAngle( const LightDesc_t *wl, const Vector& lnormal, const Vector& snormal, const Vector& delta )
+	{
+		float dot, dot2, ratio;
+
+		switch (nLightType)	
+		{
+			case MATERIAL_LIGHT_POINT:
+#if 1
+				// half-lambert
+				dot = DotProduct( snormal, delta );
+				if (dot < 0.f)
+					return 0.f;
+#else
+				dot = DotProduct( snormal, delta ) * 0.5 + 0.5;
+				dot = dot * dot;
+#endif
+				return dot;
+
+			case MATERIAL_LIGHT_SPOT:
+#if 1
+				// half-lambert
+				dot = DotProduct( snormal, delta );
+				if (dot < 0.)
+					return 0.f;
+#else
+				dot = DotProduct( snormal, delta ) * 0.5 + 0.5;
+				dot = dot * dot;
+#endif
+
+ 				dot2 = -DotProduct (delta, lnormal);
+				if (dot2 <= wl->m_PhiDot)
+					return 0.f; // outside light cone
+
+				ratio = dot;
+				if (dot2 >= wl->m_ThetaDot)
+					return ratio;	// inside inner cone
+
+ 				if ((wl->m_Falloff == 1.f) || (wl->m_Falloff == 0.f))
+ 				{
+ 					ratio *= (dot2 - wl->m_PhiDot) / (wl->m_ThetaDot - wl->m_PhiDot);
+ 				}
+ 				else
+ 				{
+ 					ratio *= pow((dot2 - wl->m_PhiDot) / (wl->m_ThetaDot - wl->m_PhiDot), wl->m_Falloff );
+ 				}
+				return ratio;
+
+			case MATERIAL_LIGHT_DIRECTIONAL:
+#if 1
+				// half-lambert
+				dot2 = -DotProduct( snormal, lnormal );
+				if (dot2 < 0.f)
+					return 0.f;
+#else
+				dot2 = -DotProduct( snormal, lnormal ) * 0.5 + 0.5;
+				dot2 = dot2 * dot2;
+#endif
+				return dot2;
+
+			case MATERIAL_LIGHT_DISABLE:
+				return 0.f;
+
+			NO_DEFAULT;
+		} 
+	}
+};
+
+template< int nLightType >
+class CWorldLightAngleWrapperConstDirectional
+{
+public:
+	FORCEINLINE static float WorldLightAngle( const LightDesc_t *wl, const Vector& lnormal, const Vector& snormal, const Vector& delta, float directionalamount )
+	{
+		float dot, dot2, ratio;
+
+		// directional amount is constant
+		dot = directionalamount;
+		if (dot < 0.f)
+			return 0.f;
+
+		switch (nLightType)	
+		{
+		case MATERIAL_LIGHT_POINT:
+		case MATERIAL_LIGHT_DIRECTIONAL:
+			return dot;
+
+		case MATERIAL_LIGHT_SPOT:
+			dot2 = -DotProduct (delta, lnormal);
+			if (dot2 <= wl->m_PhiDot)
+				return 0.f; // outside light cone
+
+			ratio = dot;
+			if (dot2 >= wl->m_ThetaDot)
+				return ratio;	// inside inner cone
+
+			if ((wl->m_Falloff == 1.f) || (wl->m_Falloff == 0.f))
+			{
+				ratio *= (dot2 - wl->m_PhiDot) / (wl->m_ThetaDot - wl->m_PhiDot);
+			}
+			else
+			{
+				ratio *= pow((dot2 - wl->m_PhiDot) / (wl->m_ThetaDot - wl->m_PhiDot), wl->m_Falloff );
+			}
+			return ratio;
+
+		case MATERIAL_LIGHT_DISABLE:
+			return 0.f;
+
+			NO_DEFAULT;
+		} 
+	}
+};
+
+inline float CStudioRender::R_WorldLightAngle( const LightDesc_t *wl, const Vector& lnormal, const Vector& snormal, const Vector& delta )
+{
+	switch (wl->m_Type) 
+	{
+		case MATERIAL_LIGHT_DISABLE:		return CWorldLightAngleWrapper<MATERIAL_LIGHT_DISABLE>::WorldLightAngle( wl, lnormal, snormal, delta );
+		case MATERIAL_LIGHT_POINT:			return CWorldLightAngleWrapper<MATERIAL_LIGHT_POINT>::WorldLightAngle( wl, lnormal, snormal, delta );
+		case MATERIAL_LIGHT_DIRECTIONAL:	return CWorldLightAngleWrapper<MATERIAL_LIGHT_DIRECTIONAL>::WorldLightAngle( wl, lnormal, snormal, delta );
+		case MATERIAL_LIGHT_SPOT:			return CWorldLightAngleWrapper<MATERIAL_LIGHT_SPOT>::WorldLightAngle( wl, lnormal, snormal, delta );
+		NO_DEFAULT;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Draws eyeballs
+//-----------------------------------------------------------------------------
+inline void CStudioRender::R_StudioEyeballNormal( mstudioeyeball_t const* peyeball, Vector& org, 
+									Vector& pos, Vector& normal )
+{
+	// inside of a flattened torus
+	VectorSubtract( pos, org, normal );
+	float flUpAmount =  DotProduct( normal, peyeball->up );
+	VectorMA( normal, -0.5 * flUpAmount, peyeball->up, normal );
+	VectorNormalize( normal );
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// Stateless utility methods
+//
+//-----------------------------------------------------------------------------
+
+// Computes the submodel for a specified body + bodypart
+int R_StudioSetupModel( int nBodyPart, int nBody, mstudiomodel_t **pSubModel, const studiohdr_t *pStudioHdr );
+
+// Computes PoseToWorld from BoneToWorld
+void ComputePoseToWorld( matrix3x4_t *pPoseToWorld, studiohdr_t *pStudioHdr, int boneMask, const Vector& vecViewOrigin, const matrix3x4_t *pBoneToWorld );
+
+// Computes the model LOD
+inline int ComputeModelLODAndMetric( studiohwdata_t *pHardwareData, float flUnitSphereSize, float *pMetric )
+{
+	// NOTE: This function was split off since CStudioRender needs it also.
+	float flMetric = pHardwareData->LODMetric( flUnitSphereSize );
+	if ( pMetric )
+	{
+		*pMetric = flMetric;
+	}
+	return pHardwareData->GetLODForMetric( flMetric );
+}
+
+
+
+#endif // CSTUDIORENDER_H