1HEADmaster

1 files changed, 3599 insertions, 0 deletions

diff --git a/materialsystem/cmaterial.cpp b/materialsystem/cmaterial.cpp
new file mode 100644
index 0000000..90f53d6
--- /dev/null
+++ b/materialsystem/cmaterial.cpp
@@ -0,0 +1,3599 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Implementation of a material
+//
+//===========================================================================//
+
+#include "imaterialinternal.h"
+#include "bitmap/tgaloader.h"
+#include "colorspace.h"
+#include "materialsystem/imaterialvar.h"
+#include "materialsystem/itexture.h"
+#include <string.h>
+#include "materialsystem_global.h"
+#include "shaderapi/ishaderapi.h"
+#include "materialsystem/imaterialproxy.h"							   
+#include "shadersystem.h"
+#include "materialsystem/imaterialproxyfactory.h"
+#include "IHardwareConfigInternal.h"
+#include "utlsymbol.h"
+#include <malloc.h>
+#include "filesystem.h"
+#include <KeyValues.h>
+#include "mempool.h"
+#include "shaderapi/ishaderutil.h"
+#include "vtf/vtf.h"
+#include "tier1/strtools.h"
+#include <ctype.h>
+#include "utlbuffer.h"
+#include "mathlib/vmatrix.h"
+#include "texturemanager.h"
+#include "itextureinternal.h"
+#include "mempool.h"
+#include "tier1/callqueue.h"
+#include "cmaterial_queuefriendly.h"
+#include "ifilelist.h"
+#include "tier0/icommandline.h"
+#include "tier0/minidump.h"
+
+// #define PROXY_TRACK_NAMES
+
+//-----------------------------------------------------------------------------
+// Material implementation
+//-----------------------------------------------------------------------------
+class CMaterial : public IMaterialInternal
+{
+public:
+	// Members of the IMaterial interface
+	const char  *GetName() const;
+	const char  *GetTextureGroupName() const;
+
+	PreviewImageRetVal_t GetPreviewImageProperties( int *width, int *height, 
+				 				ImageFormat *imageFormat, bool* isTranslucent ) const;
+	PreviewImageRetVal_t GetPreviewImage( unsigned char *data, int width, int height,
+								ImageFormat imageFormat ) const;
+
+	int			GetMappingWidth( );
+	int			GetMappingHeight( );
+	int			GetNumAnimationFrames( );
+
+	bool		InMaterialPage( void )						{ return false; }
+	void		GetMaterialOffset( float *pOffset );
+	void		GetMaterialScale( float *pOffset );
+	IMaterial	*GetMaterialPage( void )					{ return NULL; }
+
+	void		IncrementReferenceCount( );
+	void		DecrementReferenceCount( );
+	int 		GetEnumerationID( ) const;
+	void		GetLowResColorSample( float s, float t, float *color ) const;
+	
+	IMaterialVar *		FindVar( char const *varName, bool *found, bool complain = true );
+	IMaterialVar *		FindVarFast( char const *pVarName, unsigned int *pToken );
+
+	// Sets new VMT shader parameters for the material
+	virtual void		SetShaderAndParams( KeyValues *pKeyValues );
+
+	bool				UsesEnvCubemap( void );
+	bool				NeedsSoftwareSkinning( void );
+	virtual bool		NeedsSoftwareLighting( void );
+	bool				NeedsTangentSpace( void );
+	bool				NeedsPowerOfTwoFrameBufferTexture( bool bCheckSpecificToThisFrame = true );
+	bool				NeedsFullFrameBufferTexture( bool bCheckSpecificToThisFrame = true );
+	virtual bool		IsUsingVertexID( ) const;
+
+	// GR - Is lightmap alpha needed?
+	bool	NeedsLightmapBlendAlpha( void );
+	
+	virtual void	AlphaModulate( float alpha );
+	virtual void	ColorModulate( float r, float g, float b );
+	virtual float	GetAlphaModulation();
+	virtual void	GetColorModulation( float *r, float *g, float *b );
+
+	// Gets the morph format
+	virtual MorphFormat_t	GetMorphFormat() const;
+
+	void	SetMaterialVarFlag( MaterialVarFlags_t flag, bool on );
+	bool	GetMaterialVarFlag( MaterialVarFlags_t flag ) const;
+
+	bool	IsTranslucent();
+	bool	IsTranslucentInternal( float fAlphaModulation ) const; //need to centralize the logic without relying on the *current* alpha modulation being that which is stored in m_pShaderParams[ALPHA].
+	bool	IsAlphaTested();
+	bool	IsVertexLit();
+	virtual bool IsSpriteCard();
+
+	void	GetReflectivity( Vector& reflect );
+	bool	GetPropertyFlag( MaterialPropertyTypes_t type );
+
+	// Is the material visible from both sides?
+	bool	IsTwoSided();
+
+	int		GetNumPasses( void );
+	int		GetTextureMemoryBytes( void );
+
+	void	SetUseFixedFunctionBakedLighting( bool bEnable );
+
+	virtual bool IsPrecached( ) const;
+
+public:
+	// stuff that is visible only from within the material system
+
+	// constructor, destructor
+	CMaterial( char const* materialName, const char *pTextureGroupName, KeyValues *pVMTKeyValues );
+	virtual		~CMaterial();
+
+	void		DrawMesh( VertexCompressionType_t vertexCompression );
+	int			GetReferenceCount( ) const;
+	void		Uncache( bool bPreserveVars = false );
+	void		Precache();
+	void		ReloadTextures( void );
+	// If provided, pKeyValues and pPatchKeyValues should come from LoadVMTFile()
+	bool		PrecacheVars( KeyValues *pKeyValues = NULL, KeyValues *pPatchKeyValues = NULL, CUtlVector<FileNameHandle_t> *pIncludes = NULL, int nFindContext = MATERIAL_FINDCONTEXT_NONE );
+	void		SetMinLightmapPageID( int pageID );
+	void		SetMaxLightmapPageID( int pageID );
+	int			GetMinLightmapPageID( ) const;
+	int			GetMaxLightmapPageID( ) const;
+	void		SetNeedsWhiteLightmap( bool val );
+	bool		GetNeedsWhiteLightmap( ) const;
+	bool		IsPrecachedVars( ) const;
+	IShader *	GetShader() const;
+	const char *GetShaderName() const;
+	
+	virtual void			DeleteIfUnreferenced();
+
+	void					SetEnumerationID( int id );
+	void					CallBindProxy( void *proxyData );
+	virtual IMaterial		*CheckProxyReplacement( void *proxyData );
+	bool					HasProxy( void ) const;
+
+	// Sets the shader associated with the material
+	void SetShader( const char *pShaderName );
+
+	// Can we override this material in debug?
+	bool NoDebugOverride() const;
+
+	// Gets the vertex format
+	VertexFormat_t GetVertexFormat() const;
+	
+	// diffuse bump lightmap?
+	bool IsUsingDiffuseBumpedLighting() const;
+
+	// lightmap?
+	bool IsUsingLightmap() const;
+
+	// Gets the vertex usage flags
+	VertexFormat_t GetVertexUsage() const;
+
+	// Debugs this material
+	bool PerformDebugTrace() const;
+
+	// Are we suppressed?
+	bool IsSuppressed() const;
+
+	// Do we use fog?
+	bool UseFog( void ) const;
+	
+	// Should we draw?
+	void ToggleSuppression();
+	void ToggleDebugTrace();
+	
+	// Refresh material based on current var values
+	void Refresh();
+	void RefreshPreservingMaterialVars();
+
+	// This computes the state snapshots for this material
+	void RecomputeStateSnapshots();
+
+	// Gets at the shader parameters
+	virtual int ShaderParamCount() const;
+	virtual IMaterialVar **GetShaderParams( void );
+
+	virtual void AddMaterialVar( IMaterialVar *pMaterialVar );
+
+	virtual bool IsErrorMaterial() const;
+
+	// Was this manually created (not read from a file?)
+	virtual bool IsManuallyCreated() const;
+
+	virtual bool NeedsFixedFunctionFlashlight() const;
+
+	virtual void MarkAsPreloaded( bool bSet );
+	virtual bool IsPreloaded() const;
+
+	virtual void ArtificialAddRef( void );
+	virtual void ArtificialRelease( void );
+
+	virtual void ReportVarChanged( IMaterialVar *pVar )
+	{	
+		m_ChangeID++;
+	}
+	virtual void ClearContextData( void );
+
+	virtual uint32 GetChangeID() const { return m_ChangeID; }
+
+	virtual bool IsRealTimeVersion( void ) const { return true; }
+	virtual IMaterialInternal *GetRealTimeVersion( void ) { return this; }
+	virtual IMaterialInternal *GetQueueFriendlyVersion( void ) { return &m_QueueFriendlyVersion; }
+
+	void DecideShouldReloadFromWhitelist( IFileList *pFilesToReload );
+	void ReloadFromWhitelistIfMarked();
+	bool WasReloadedFromWhitelist();
+
+private:
+	// Initializes, cleans up the shader params
+	void CleanUpShaderParams();
+
+	// Sets up an error shader when we run into problems.
+	void SetupErrorShader();
+
+	// Does this material have a UNC-file name?
+	bool UsesUNCFileName() const;
+
+	// Prints material flags.
+	void PrintMaterialFlags( int flags, int flagsDefined );
+
+	// Parses material flags
+	bool ParseMaterialFlag( KeyValues* pParseValue, IMaterialVar* pFlagVar,
+		IMaterialVar* pFlagDefinedVar, bool parsingOverrides, int& flagMask, int& overrideMask );
+
+	// Computes the material vars for the shader
+	int ParseMaterialVars( IShader* pShader, KeyValues& keyValues, 
+		KeyValues* pOverride, bool modelDefault, IMaterialVar** ppVars, int nFindContext = MATERIAL_FINDCONTEXT_NONE );
+
+	// Figures out the preview image for worldcraft
+	char const*	GetPreviewImageName( );
+	char const* GetPreviewImageFileName( void ) const;
+
+	// Hooks up the shader, returns keyvalues of fallback that was used
+	KeyValues* InitializeShader( KeyValues &keyValues, KeyValues &patchKeyValues, int nFindContext = MATERIAL_FINDCONTEXT_NONE );
+
+	// Finds the flag associated with a particular flag name
+	int FindMaterialVarFlag( char const* pFlagName ) const;
+
+	// Initializes, cleans up the state snapshots
+	bool InitializeStateSnapshots();
+	void CleanUpStateSnapshots();
+
+	// Initializes, cleans up the material proxy
+	void InitializeMaterialProxy( KeyValues* pFallbackKeyValues );
+	void CleanUpMaterialProxy();
+	void DetermineProxyReplacements( KeyValues *pFallbackKeyValues );
+
+	// Creates, destroys snapshots
+	RenderPassList_t *CreateRenderPassList();
+	void DestroyRenderPassList( RenderPassList_t *pPassList );
+
+	// Grabs the texture width and height from the var list for faster access
+	void PrecacheMappingDimensions( );
+
+	// Gets the renderstate
+	virtual ShaderRenderState_t *GetRenderState();
+
+	// Do we have a valid renderstate?
+	bool IsValidRenderState() const;
+
+	// Get the material var flags
+	int	GetMaterialVarFlags() const;
+	void SetMaterialVarFlags( int flags, bool on );
+	int	GetMaterialVarFlags2() const;
+	void SetMaterialVarFlags2( int flags, bool on );
+
+	// Returns a dummy material variable
+	IMaterialVar*	GetDummyVariable();
+
+	IMaterialVar*	GetShaderParam( int id );
+
+	void			FindRepresentativeTexture( void );
+
+	bool ShouldSkipVar( KeyValues *pMaterialVar, bool * pWasConditional );
+
+
+	// Fixed-size allocator
+	DECLARE_FIXEDSIZE_ALLOCATOR( CMaterial );
+
+private:
+	enum
+	{
+		MATERIAL_NEEDS_WHITE_LIGHTMAP = 0x1,
+		MATERIAL_IS_PRECACHED = 0x2,
+		MATERIAL_VARS_IS_PRECACHED = 0x4,
+		MATERIAL_VALID_RENDERSTATE = 0x8,
+		MATERIAL_IS_MANUALLY_CREATED = 0x10,
+		MATERIAL_USES_UNC_FILENAME = 0x20,
+		MATERIAL_IS_PRELOADED = 0x40,
+		MATERIAL_ARTIFICIAL_REFCOUNT = 0x80,
+	};
+
+	int					m_iEnumerationID;
+	
+	int					m_minLightmapPageID;
+	int					m_maxLightmapPageID;
+
+	unsigned short		m_MappingWidth;
+	unsigned short		m_MappingHeight;
+	
+	IShader				*m_pShader;
+
+	CUtlSymbol			m_Name;
+	// Any textures created for this material go under this texture group.
+	CUtlSymbol			m_TextureGroupName;
+
+	CInterlockedInt		m_RefCount;
+	unsigned short		m_Flags;
+
+	unsigned char		m_VarCount;
+
+	CUtlVector< IMaterialProxy * > m_ProxyInfo;
+
+#ifdef PROXY_TRACK_NAMES
+	// Array to track names of above material proxies. Useful for tracking down issues with proxies.
+	CUtlVector< CUtlString > m_ProxyInfoNames;
+#endif
+
+	IMaterialVar**		m_pShaderParams;
+	IMaterialProxy		*m_pReplacementProxy;
+	ShaderRenderState_t m_ShaderRenderState;
+
+	// This remembers filenames of VMTs that we included so we can sv_pure/flush ourselves if any of them need to be reloaded.
+	CUtlVector<FileNameHandle_t> m_VMTIncludes;
+	bool m_bShouldReloadFromWhitelist;	// Tells us if the material decided it should be reloaded due to sv_pure whitelist changes.
+
+	ITextureInternal	*m_representativeTexture;
+	Vector				m_Reflectivity;
+	uint32				m_ChangeID;
+
+	// Used only by procedural materials; it essentially is an in-memory .VMT file
+	KeyValues			*m_pVMTKeyValues;
+
+#if defined( _DEBUG )
+	// Makes it easier to see what's going on
+	char				*m_pDebugName;
+#endif
+
+protected:
+	CMaterial_QueueFriendly m_QueueFriendlyVersion;
+};
+
+
+// NOTE: This must be the last file included
+// Has to exist *after* fixed size allocator declaration
+#include "tier0/memdbgon.h"
+
+// Forward decls of helper functions for dealing with patch vmts.
+static void ApplyPatchKeyValues( KeyValues &keyValues, KeyValues &patchKeyValues );
+static bool AccumulateRecursiveVmtPatches( KeyValues &patchKeyValuesOut, KeyValues **ppBaseKeyValuesOut,
+										   const KeyValues& keyValues, const char *pPathID, CUtlVector<FileNameHandle_t> *pIncludes );
+
+//-----------------------------------------------------------------------------
+// Parser utilities
+//-----------------------------------------------------------------------------
+static inline bool IsWhitespace( char c )
+{
+	return c == ' ' || c == '\t';
+}
+
+static inline bool IsEndline( char c )
+{
+	return c == '\n' || c == '\0';
+}
+
+static inline bool IsVector( char const* v )
+{
+	while (IsWhitespace(*v))
+	{
+		++v;
+		if (IsEndline(*v))
+			return false;
+	}
+	return *v == '[' || *v == '{';
+}
+
+
+//-----------------------------------------------------------------------------
+// Methods to create state snapshots
+//-----------------------------------------------------------------------------
+#include "tier0/memdbgoff.h"
+
+#ifndef _CONSOLE
+struct EditorRenderStateList_t
+{
+	// Store combo of alpha, color, fixed-function baked lighting, flashlight, editor mode
+	RenderPassList_t m_Snapshots[SNAPSHOT_COUNT_EDITOR];
+
+	DECLARE_FIXEDSIZE_ALLOCATOR( EditorRenderStateList_t );
+};
+#endif
+
+struct StandardRenderStateList_t
+{
+	// Store combo of alpha, color, fixed-function baked lighting, flashlight
+	RenderPassList_t m_Snapshots[SNAPSHOT_COUNT_NORMAL];
+
+	DECLARE_FIXEDSIZE_ALLOCATOR( StandardRenderStateList_t );
+};
+
+#include "tier0/memdbgon.h"
+
+#ifndef _CONSOLE
+DEFINE_FIXEDSIZE_ALLOCATOR( EditorRenderStateList_t, 256, true );
+#endif
+DEFINE_FIXEDSIZE_ALLOCATOR( StandardRenderStateList_t, 256, true );
+
+
+//-----------------------------------------------------------------------------
+// class factory methods
+//-----------------------------------------------------------------------------
+DEFINE_FIXEDSIZE_ALLOCATOR( CMaterial, 256, true );
+
+IMaterialInternal* IMaterialInternal::CreateMaterial( char const* pMaterialName, const char *pTextureGroupName, KeyValues *pVMTKeyValues )
+{
+	MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
+	IMaterialInternal *pResult = new CMaterial( pMaterialName, pTextureGroupName, pVMTKeyValues );
+	MaterialSystem()->Unlock( hMaterialLock );
+	return pResult;
+}
+
+void IMaterialInternal::DestroyMaterial( IMaterialInternal* pMaterial )
+{
+	MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
+	if (pMaterial)
+	{
+		Assert( pMaterial->IsRealTimeVersion() );
+		CMaterial* pMatImp = static_cast<CMaterial*>(pMaterial);
+		// Deletion of the error material is deferred until after all other materials have been deleted.
+		// See CMaterialSystem::CleanUpErrorMaterial() in cmaterialsystem.cpp.
+		if ( !pMatImp->IsErrorMaterial() )
+		{
+			delete pMatImp;
+		}
+	}
+	MaterialSystem()->Unlock( hMaterialLock );
+}
+
+//-----------------------------------------------------------------------------
+// constructor, destructor
+//-----------------------------------------------------------------------------
+CMaterial::CMaterial( char const* materialName, const char *pTextureGroupName, KeyValues *pKeyValues )
+{
+	m_Reflectivity.Init( 0.2f, 0.2f, 0.2f );
+	int len = Q_strlen(materialName);
+	char* pTemp = (char*)_alloca( len + 1 );
+
+	// Strip off the extension
+	Q_StripExtension( materialName, pTemp, len+1 );
+	Q_strlower( pTemp );
+
+#if defined( _X360 )
+	// material names are expected to be forward slashed for correct sort and find behavior!
+	// assert now to track alternate or regressed path that is source of inconsistency
+	Assert( strchr( pTemp, '\\' ) == NULL );
+#endif
+
+	// Convert it to a symbol
+	m_Name = pTemp;
+
+#if defined( _DEBUG )
+	m_pDebugName = new char[strlen(pTemp) + 1];
+	Q_strncpy( m_pDebugName, pTemp, strlen(pTemp) + 1 );
+#endif
+
+	m_bShouldReloadFromWhitelist = false;
+	m_Flags = 0;
+	m_pShader = NULL;
+	m_pShaderParams = NULL;
+	m_RefCount = 0;
+	m_representativeTexture = NULL;
+	m_pReplacementProxy = NULL;
+	m_VarCount = 0;
+	m_MappingWidth = m_MappingHeight = 0;
+	m_iEnumerationID = 0;
+	m_minLightmapPageID = m_maxLightmapPageID = 0;
+	m_TextureGroupName = pTextureGroupName;
+	m_pVMTKeyValues = pKeyValues;
+	if (m_pVMTKeyValues)
+	{
+		m_Flags |= MATERIAL_IS_MANUALLY_CREATED; 
+	}
+
+	if ( pTemp[0] == '/' && pTemp[1] == '/' && pTemp[2] != '/' )
+	{
+		m_Flags |= MATERIAL_USES_UNC_FILENAME;
+	}
+
+	// Initialize the renderstate to something indicating nothing should be drawn
+	m_ShaderRenderState.m_Flags = 0;
+	m_ShaderRenderState.m_VertexFormat = m_ShaderRenderState.m_VertexUsage = 0;
+	m_ShaderRenderState.m_MorphFormat = 0;
+	m_ShaderRenderState.m_pSnapshots = CreateRenderPassList(); 
+	m_ChangeID = 0;
+
+	m_QueueFriendlyVersion.SetRealTimeVersion( this );
+}
+
+CMaterial::~CMaterial()
+{
+	MaterialSystem()->UnbindMaterial( this );
+
+	Uncache();
+
+	if ( m_RefCount != 0 )
+	{
+		DevWarning( 2, "Reference Count for Material %s (%d) != 0\n", GetName(), (int) m_RefCount );
+	}
+
+	if ( m_pVMTKeyValues )
+	{
+		m_pVMTKeyValues->deleteThis();
+		m_pVMTKeyValues = NULL;
+	}
+
+	DestroyRenderPassList( m_ShaderRenderState.m_pSnapshots ); 
+
+	m_representativeTexture = NULL;
+
+#if defined( _DEBUG )
+	delete [] m_pDebugName;
+#endif
+
+	// Deliberately stomp our VTable so that we can detect cases where code tries to access freed materials.
+	int *p = (int *)this;
+	*p = 0xc0dedbad;
+}
+
+
+void CMaterial::ClearContextData( void )
+{
+	int nSnapshotCount = SnapshotTypeCount();
+	for( int i = 0 ; i < nSnapshotCount ; i++ )
+		for( int j = 0 ; j < m_ShaderRenderState.m_pSnapshots[i].m_nPassCount; j++ )
+		{
+			if ( m_ShaderRenderState.m_pSnapshots[i].m_pContextData[j] )
+			{
+				delete m_ShaderRenderState.m_pSnapshots[i].m_pContextData[j];
+				m_ShaderRenderState.m_pSnapshots[i].m_pContextData[j] = NULL;
+			}
+			
+		}
+}
+
+//-----------------------------------------------------------------------------
+// Sets new VMT shader parameters for the material
+//-----------------------------------------------------------------------------
+void CMaterial::SetShaderAndParams( KeyValues *pKeyValues )
+{
+	Uncache();
+
+	if ( m_pVMTKeyValues )
+	{
+		m_pVMTKeyValues->deleteThis();
+		m_pVMTKeyValues = NULL;
+	}
+
+	m_pVMTKeyValues = pKeyValues ? pKeyValues->MakeCopy() : NULL;
+	if (m_pVMTKeyValues)
+	{
+		m_Flags |= MATERIAL_IS_MANUALLY_CREATED; 
+	}
+
+	// Apply patches
+	const char *pMaterialName = GetName();
+	char pFileName[MAX_PATH];
+	const char *pPathID = "GAME";
+	if ( !UsesUNCFileName() )
+	{
+		Q_snprintf( pFileName, sizeof( pFileName ), "materials/%s.vmt", pMaterialName );
+	}
+	else
+	{
+		Q_snprintf( pFileName, sizeof( pFileName ), "%s.vmt", pMaterialName );
+		if ( pMaterialName[0] == '/' && pMaterialName[1] == '/' && pMaterialName[2] != '/' )
+		{
+			// UNC, do full search
+			pPathID = NULL;
+		}
+	}
+
+	KeyValues *pLoadedKeyValues = new KeyValues( "vmt" );
+	if ( pLoadedKeyValues->LoadFromFile( g_pFullFileSystem, pFileName, pPathID ) )
+	{
+		// Load succeeded, check if it's a patch file
+		if ( V_stricmp( pLoadedKeyValues->GetName(), "patch" ) == 0 )
+		{
+			// it's a patch file, recursively build up patch keyvalues
+			KeyValues *pPatchKeyValues = new KeyValues( "vmt_patch" );
+			bool bSuccess = AccumulateRecursiveVmtPatches( *pPatchKeyValues, NULL, *pLoadedKeyValues, pPathID, NULL );
+			if ( bSuccess )
+			{
+				// Apply accumulated patches to final vmt
+				ApplyPatchKeyValues( *m_pVMTKeyValues, *pPatchKeyValues );
+			}
+			pPatchKeyValues->deleteThis();
+		}
+	}
+	pLoadedKeyValues->deleteThis();
+
+	if ( g_pShaderDevice->IsUsingGraphics() )
+	{
+		Precache();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates, destroys snapshots
+//-----------------------------------------------------------------------------
+RenderPassList_t *CMaterial::CreateRenderPassList()
+{
+	RenderPassList_t *pRenderPassList;
+	if ( IsConsole() || !MaterialSystem()->CanUseEditorMaterials() )
+	{
+		StandardRenderStateList_t *pList = new StandardRenderStateList_t;
+		pRenderPassList = (RenderPassList_t*)pList->m_Snapshots;
+	}
+#ifndef _CONSOLE
+	else
+	{
+		EditorRenderStateList_t *pList = new EditorRenderStateList_t;
+		pRenderPassList = (RenderPassList_t*)pList->m_Snapshots;
+	}
+#endif
+
+	int nSnapshotCount = SnapshotTypeCount();
+	memset( pRenderPassList, 0, nSnapshotCount * sizeof(RenderPassList_t) );
+	return pRenderPassList;
+}
+
+void CMaterial::DestroyRenderPassList( RenderPassList_t *pPassList )
+{
+	if ( !pPassList )
+		return;
+
+	int nSnapshotCount = SnapshotTypeCount();
+	for( int i = 0 ; i < nSnapshotCount ; i++ )
+		for( int j = 0 ; j < pPassList[i].m_nPassCount; j++ )
+		{
+			if ( pPassList[i].m_pContextData[j] )
+			{
+				delete pPassList[i].m_pContextData[j];
+				pPassList[i].m_pContextData[j] = NULL;
+			}
+			
+		}
+	if ( IsConsole() || !MaterialSystem()->CanUseEditorMaterials() )
+	{
+		StandardRenderStateList_t *pList = (StandardRenderStateList_t*)pPassList;
+		delete pList;
+	}
+#ifndef _CONSOLE
+	else
+	{
+		EditorRenderStateList_t *pList = (EditorRenderStateList_t*)pPassList;
+		delete pList;
+	}
+#endif
+}
+
+	
+//-----------------------------------------------------------------------------
+// Gets the renderstate
+//-----------------------------------------------------------------------------
+ShaderRenderState_t *CMaterial::GetRenderState()
+{
+	Precache();
+	return &m_ShaderRenderState;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns a dummy material variable
+//-----------------------------------------------------------------------------
+IMaterialVar* CMaterial::GetDummyVariable()
+{
+	static IMaterialVar* pDummyVar = 0;
+	if (!pDummyVar)
+		pDummyVar = IMaterialVar::Create( 0, "$dummyVar", 0 );
+
+	return pDummyVar;
+}
+
+
+//-----------------------------------------------------------------------------
+// Are vars precached?
+//-----------------------------------------------------------------------------
+bool CMaterial::IsPrecachedVars( ) const
+{
+	return (m_Flags & MATERIAL_VARS_IS_PRECACHED) != 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Are we precached?
+//-----------------------------------------------------------------------------
+bool CMaterial::IsPrecached( ) const
+{
+	return (m_Flags & MATERIAL_IS_PRECACHED) != 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Cleans up shader parameters
+//-----------------------------------------------------------------------------
+void CMaterial::CleanUpShaderParams()
+{
+	if( m_pShaderParams )
+	{
+		for (int i = 0; i < m_VarCount; ++i)
+		{
+			IMaterialVar::Destroy( m_pShaderParams[i] );
+		}
+
+		free( m_pShaderParams );
+		m_pShaderParams = 0;
+	}
+	m_VarCount = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Initializes the material proxy
+//-----------------------------------------------------------------------------
+void CMaterial::InitializeMaterialProxy( KeyValues* pFallbackKeyValues )
+{
+	IMaterialProxyFactory *pMaterialProxyFactory;
+	pMaterialProxyFactory = MaterialSystem()->GetMaterialProxyFactory();	
+	if( !pMaterialProxyFactory )
+		return;
+
+	DetermineProxyReplacements( pFallbackKeyValues );
+
+	if ( m_pReplacementProxy )
+	{
+		m_ProxyInfo.AddToTail( m_pReplacementProxy );
+#ifdef PROXY_TRACK_NAMES
+		m_ProxyInfoNames.AddToTail( "__replacementproxy" );
+#endif
+	}
+
+	// See if we've got a proxy section; obey fallbacks
+	KeyValues* pProxySection = pFallbackKeyValues->FindKey("Proxies");
+	if ( pProxySection )
+	{
+		// Iterate through the section + create all of the proxies
+		KeyValues* pProxyKey = pProxySection->GetFirstSubKey();
+
+		for ( ; pProxyKey; pProxyKey = pProxyKey->GetNextKey() )
+		{
+			// Each of the proxies should themselves be databases
+			IMaterialProxy* pProxy = pMaterialProxyFactory->CreateProxy( pProxyKey->GetName() );
+			if (!pProxy)
+			{
+				Warning( "Error: Material \"%s\" : proxy \"%s\" not found!\n", GetName(), pProxyKey->GetName() );
+				continue;
+			}
+
+			if (!pProxy->Init( this->GetQueueFriendlyVersion(), pProxyKey ))
+			{
+				pMaterialProxyFactory->DeleteProxy( pProxy );
+				Warning( "Error: Material \"%s\" : proxy \"%s\" unable to initialize!\n", GetName(), pProxyKey->GetName() );
+			}
+			else
+			{
+				m_ProxyInfo.AddToTail( pProxy );
+#ifdef PROXY_TRACK_NAMES
+				m_ProxyInfoNames.AddToTail( pProxyKey->GetName() );
+#endif
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Cleans up the material proxy
+//-----------------------------------------------------------------------------
+void CMaterial::CleanUpMaterialProxy()
+{
+	if ( !m_ProxyInfo.Count() )
+		return;
+
+	IMaterialProxyFactory *pMaterialProxyFactory;
+	pMaterialProxyFactory = MaterialSystem()->GetMaterialProxyFactory();
+	if ( !pMaterialProxyFactory )
+		return;
+
+	// Clean up material proxies
+	for ( int i = m_ProxyInfo.Count() - 1; i >= 0; i-- )
+	{
+		IMaterialProxy *pProxy = m_ProxyInfo[ i ];
+
+		pMaterialProxyFactory->DeleteProxy( pProxy );
+	}
+	
+	m_ProxyInfo.RemoveAll();
+#ifdef PROXY_TRACK_NAMES
+	m_ProxyInfoNames.RemoveAll();
+#endif
+}
+
+
+void CMaterial::DetermineProxyReplacements( KeyValues *pFallbackKeyValues )
+{
+	m_pReplacementProxy = MaterialSystem()->DetermineProxyReplacements( this, pFallbackKeyValues );
+}
+
+
+static char const *GetVarName( KeyValues *pVar )
+{
+	char const *pVarName = pVar->GetName();
+	char const *pQuestion = strchr( pVarName, '?' );
+	if (! pQuestion )
+		return pVarName;
+	else
+		return pQuestion + 1;
+}
+
+//-----------------------------------------------------------------------------
+// Finds the index of the material var associated with a var
+//-----------------------------------------------------------------------------
+static int FindMaterialVar( IShader* pShader, char const* pVarName )
+{
+	if ( !pShader )
+		return -1;
+
+	// Strip preceeding spaces
+	pVarName += strspn( pVarName, " \t" );
+
+	for (int i = pShader->GetNumParams(); --i >= 0; )
+	{
+		// Makes the parser a little more lenient.. strips off bogus spaces in the var name.
+		const char *pParamName = pShader->GetParamName(i);
+		const char *pFound = Q_stristr( pVarName, pParamName );
+
+		// The found string had better start with the first non-whitespace character
+		if ( pFound != pVarName )
+			continue;
+
+		// Strip spaces at the end
+		int nLen = Q_strlen( pParamName );
+		pFound += nLen;
+		while ( true )
+		{
+			if ( !pFound[0] )
+				return i;
+
+			if ( !IsWhitespace( pFound[0] ) )
+				break;
+
+			++pFound;
+		}
+	}
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates a vector material var
+//-----------------------------------------------------------------------------
+int ParseVectorFromKeyValueString( KeyValues *pKeyValue, const char *pMaterialName, float vecVal[4] )
+{
+	char const* pScan = pKeyValue->GetString();
+	bool divideBy255 = false;
+
+	// skip whitespace
+	while( IsWhitespace(*pScan) )
+	{
+		++pScan;
+	}
+
+	if( *pScan == '{' )
+	{
+		divideBy255 = true;
+	}
+	else
+	{
+		Assert( *pScan == '[' );
+	}
+	
+	// skip the '['
+	++pScan;
+	int i;
+	for( i = 0; i < 4; i++ )
+	{
+		// skip whitespace
+		while( IsWhitespace(*pScan) )
+		{
+			++pScan;
+		}
+
+		if( IsEndline(*pScan) || *pScan == ']' || *pScan == '}' )
+		{
+			if (*pScan != ']' && *pScan != '}')
+			{
+				Warning( "Warning in .VMT file (%s): no ']' or '}' found in vector key \"%s\".\n"
+					"Did you forget to surround the vector with \"s?\n", pMaterialName, pKeyValue->GetName() );
+			}
+
+			// allow for vec2's, etc.
+			vecVal[i] = 0.0f;
+			break;
+		}
+
+		char* pEnd;
+
+		vecVal[i] = strtod( pScan, &pEnd );
+		if (pScan == pEnd)
+		{
+			Warning( "Error in .VMT file: error parsing vector element \"%s\" in \"%s\"\n", pKeyValue->GetName(), pMaterialName );
+			return 0;
+		}
+
+		pScan = pEnd;
+	}
+
+	if( divideBy255 )
+	{
+		vecVal[0] *= ( 1.0f / 255.0f );
+		vecVal[1] *= ( 1.0f / 255.0f );
+		vecVal[2] *= ( 1.0f / 255.0f );
+		vecVal[3] *= ( 1.0f / 255.0f );
+	}
+
+	return i;
+}
+
+static IMaterialVar* CreateVectorMaterialVarFromKeyValue( IMaterial* pMaterial, KeyValues* pKeyValue )
+{
+	char const *pszName = GetVarName( pKeyValue );
+	float vecVal[4];
+	int nDim = ParseVectorFromKeyValueString( pKeyValue, pszName, vecVal );
+	if ( nDim == 0 )
+		return NULL;
+
+	// Create the variable!
+	return IMaterialVar::Create( pMaterial, pszName, vecVal, nDim );
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates a vector material var
+//-----------------------------------------------------------------------------
+static IMaterialVar* CreateMatrixMaterialVarFromKeyValue( IMaterial* pMaterial, KeyValues* pKeyValue )
+{
+	char const* pScan = pKeyValue->GetString();
+	char const *pszName = GetVarName( pKeyValue );
+
+	// Matrices can be specified one of two ways:
+	// [ # # # #  # # # #  # # # #  # # # # ]
+	// or
+	// center # # scale # # rotate # translate # #
+
+	VMatrix mat;
+	int count = sscanf( pScan, " [ %f %f %f %f  %f %f %f %f  %f %f %f %f  %f %f %f %f ]",
+		&mat.m[0][0], &mat.m[0][1], &mat.m[0][2], &mat.m[0][3],
+		&mat.m[1][0], &mat.m[1][1], &mat.m[1][2], &mat.m[1][3],
+		&mat.m[2][0], &mat.m[2][1], &mat.m[2][2], &mat.m[2][3],
+		&mat.m[3][0], &mat.m[3][1], &mat.m[3][2], &mat.m[3][3] );
+	if (count == 16)
+	{
+		return IMaterialVar::Create( pMaterial, pszName, mat );
+	}
+
+	Vector2D scale, center;
+	float angle;
+	Vector2D translation;
+	count = sscanf( pScan, " center %f %f scale %f %f rotate %f translate %f %f",
+		&center.x, &center.y, &scale.x, &scale.y, &angle, &translation.x, &translation.y );
+	if (count != 7)
+		return NULL;
+
+	VMatrix temp;
+	MatrixBuildTranslation( mat, -center.x, -center.y, 0.0f );
+	MatrixBuildScale( temp, scale.x, scale.y, 1.0f );
+	MatrixMultiply( temp, mat, mat );
+	MatrixBuildRotateZ( temp, angle );
+	MatrixMultiply( temp, mat, mat );
+	MatrixBuildTranslation( temp, center.x + translation.x, center.y + translation.y, 0.0f );
+	MatrixMultiply( temp, mat, mat );
+
+	// Create the variable!
+	return IMaterialVar::Create( pMaterial, pszName, mat );
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates a material var from a key value
+//-----------------------------------------------------------------------------
+
+static IMaterialVar* CreateMaterialVarFromKeyValue( IMaterial* pMaterial, KeyValues* pKeyValue )
+{
+	char const *pszName = GetVarName( pKeyValue );
+	switch( pKeyValue->GetDataType() )
+	{
+		case KeyValues::TYPE_INT:
+			return IMaterialVar::Create( pMaterial, pszName, pKeyValue->GetInt() );
+			
+		case KeyValues::TYPE_FLOAT:
+			return IMaterialVar::Create( pMaterial, pszName, pKeyValue->GetFloat() );
+			
+		case KeyValues::TYPE_STRING:
+		{
+			char const* pString = pKeyValue->GetString();
+			if (!pString || !pString[0])
+				return 0;
+			
+			// Look for matrices
+			IMaterialVar *pMatrixVar = CreateMatrixMaterialVarFromKeyValue( pMaterial, pKeyValue );
+			if (pMatrixVar)
+				return pMatrixVar;
+			
+			// Look for vectors
+			if (!IsVector(pString))
+				return IMaterialVar::Create( pMaterial, pszName, pString );
+			
+			// Parse the string as a vector...
+			return CreateVectorMaterialVarFromKeyValue( pMaterial, pKeyValue );
+		}
+	}
+	
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Reads out common flags, prevents them from becoming material vars
+//-----------------------------------------------------------------------------
+int CMaterial::FindMaterialVarFlag( char const* pFlagName ) const
+{
+	// Strip preceeding spaces
+	while ( pFlagName[0] )
+	{
+		if ( !IsWhitespace( pFlagName[0] ) )
+			break;
+
+		++pFlagName;
+	}
+
+	for( int i = 0; *ShaderSystem()->ShaderStateString(i); ++i )
+	{
+		const char *pStateString = ShaderSystem()->ShaderStateString(i);
+		const char *pFound = Q_stristr( pFlagName, pStateString );
+
+		// The found string had better start with the first non-whitespace character
+		if ( pFound != pFlagName )
+			continue;
+
+		// Strip spaces at the end
+		int nLen = Q_strlen( pStateString );
+		pFound += nLen;
+		while ( true )
+		{
+			if ( !pFound[0] )
+				return (1 << i);
+
+			if ( !IsWhitespace( pFound[0] ) )
+				break;
+
+			++pFound;
+		}
+	}
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Print material flags
+//-----------------------------------------------------------------------------
+void CMaterial::PrintMaterialFlags( int flags, int flagsDefined )
+{
+	int i;
+	for( i = 0; *ShaderSystem()->ShaderStateString(i); i++ )
+	{
+		if( flags & ( 1<<i ) )
+		{
+			Warning( "%s|", ShaderSystem()->ShaderStateString(i) );
+		}
+	}
+	Warning( "\n" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Parses material flags
+//-----------------------------------------------------------------------------
+bool CMaterial::ParseMaterialFlag( KeyValues* pParseValue, IMaterialVar* pFlagVar,
+	IMaterialVar* pFlagDefinedVar, bool parsingOverrides, int& flagMask, int& overrideMask )
+{
+	// See if the var is a flag...
+	int flagbit = FindMaterialVarFlag( GetVarName( pParseValue ) );
+	if (!flagbit)
+		return false;
+
+	// Allow for flag override
+	int testMask = parsingOverrides ? overrideMask : flagMask;
+	if (testMask & flagbit)
+	{
+		Warning("Error! Flag \"%s\" is multiply defined in material \"%s\"!\n", pParseValue->GetName(), GetName() );
+		return true;
+	}
+
+	// Make sure overrides win
+	if (overrideMask & flagbit)
+		return true;
+
+	if (parsingOverrides)
+		overrideMask |= flagbit;
+	else
+		flagMask |= flagbit;
+
+	// If so, then set the flag bit
+	if (pParseValue->GetInt())
+		pFlagVar->SetIntValue( pFlagVar->GetIntValue() | flagbit );
+	else
+		pFlagVar->SetIntValue( pFlagVar->GetIntValue() & (~flagbit) );
+
+	// Mark the flag as being defined
+	pFlagDefinedVar->SetIntValue( pFlagDefinedVar->GetIntValue() | flagbit );
+
+/*
+	if( stristr( m_pDebugName, "glasswindow064a" ) )
+	{
+		Warning( "flags\n" );
+		PrintMaterialFlags( pFlagVar->GetIntValue(), pFlagDefinedVar->GetIntValue() );
+	}
+*/
+	
+	return true;
+}
+
+
+ConVar mat_reduceparticles( "mat_reduceparticles",  "0", FCVAR_ALLOWED_IN_COMPETITIVE );
+
+bool CMaterial::ShouldSkipVar( KeyValues *pVar, bool *pWasConditional )
+{
+	char const *pVarName = pVar->GetName();
+	char const *pQuestion = strchr( pVarName, '?' );
+	if ( ( ! pQuestion ) || (pQuestion == pVarName ) )
+	{
+		*pWasConditional = false;							// unconditional var
+		return false;
+	}
+	else
+	{
+		bool bShouldSkip = true;
+		*pWasConditional = true;
+		// parse the conditional part
+		char pszConditionName[256];
+		V_strncpy( pszConditionName, pVarName, 1+pQuestion-pVarName );
+		char const *pCond = pszConditionName;
+		bool bToggle = false;
+		if ( pCond[0] == '!' )
+		{
+			pCond++;
+			bToggle = true;
+		}
+
+		if ( ! stricmp( pCond, "lowfill" ) )
+		{
+			bShouldSkip = !mat_reduceparticles.GetBool();
+		}
+		else if ( ! stricmp( pCond, "hdr" ) )
+		{
+			bShouldSkip = ( HardwareConfig()->GetHDRType() == HDR_TYPE_NONE );
+		}
+		else if ( ! stricmp( pCond, "srgb" ) )
+		{
+			bShouldSkip = ( !HardwareConfig()->UsesSRGBCorrectBlending() );
+		}
+		else if ( ! stricmp( pCond, "ldr" ) )
+		{
+			bShouldSkip = ( HardwareConfig()->GetHDRType() != HDR_TYPE_NONE );
+		}
+		else if ( ! stricmp( pCond, "360" ) )
+		{
+			bShouldSkip = !IsX360();
+		}
+		else
+		{
+			Warning( "unrecognized conditional test %s in %s\n", pVarName, GetName() );
+		}
+
+		return bShouldSkip ^ bToggle;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the material vars for the shader
+//-----------------------------------------------------------------------------
+int CMaterial::ParseMaterialVars( IShader* pShader, KeyValues& keyValues, 
+			KeyValues* pOverrideKeyValues, bool modelDefault, IMaterialVar** ppVars, int nFindContext )
+{
+	IMaterialVar* pNewVar;
+	bool pOverride[256];
+	bool bWasConditional[256];
+	int overrideMask = 0;
+	int flagMask = 0;
+
+	memset( ppVars, 0, 256 * sizeof(IMaterialVar*) );
+	memset( pOverride, 0, sizeof( pOverride ) );
+	memset( bWasConditional, 0, sizeof( bWasConditional ) );
+
+	// Create the flag var...
+	// Set model mode if we fell back from a model mode shader
+	int modelFlag = modelDefault ? MATERIAL_VAR_MODEL : 0;
+	ppVars[FLAGS] = IMaterialVar::Create( this, "$flags", modelFlag );
+	ppVars[FLAGS_DEFINED] = IMaterialVar::Create( this, "$flags_defined", modelFlag );
+	ppVars[FLAGS2] = IMaterialVar::Create( this, "$flags2", 0 );
+	ppVars[FLAGS_DEFINED2] = IMaterialVar::Create( this, "$flags_defined2", 0 );
+
+	int numParams = pShader ? pShader->GetNumParams() : 0;
+	int varCount = numParams;
+
+	bool parsingOverrides = (pOverrideKeyValues != 0);
+	KeyValues* pVar = pOverrideKeyValues ? pOverrideKeyValues->GetFirstSubKey() : keyValues.GetFirstSubKey();
+
+	const char *pszMatName = pVar ? pVar->GetString() : "Unknown";
+
+	while( pVar )
+	{
+		bool bProcessThisOne = true;
+
+		bool bIsConditionalVar;
+		
+		const char *pszVarName = GetVarName( pVar );
+
+		if ( (nFindContext == MATERIAL_FINDCONTEXT_ISONAMODEL) && pszVarName && pszVarName[0] )
+		{
+			// Prevent ignorez models
+			// Should we do 'nofog' too? For now, decided not to.
+			if ( Q_stristr(pszVarName,"$ignorez") )
+			{
+				Warning("Ignoring material flag '%s' on material '%s'.\n", pszVarName, pszMatName );
+				goto nextVar;
+			}
+		}
+
+		// See if the var is a flag...
+		if ( 
+			ShouldSkipVar( pVar, &bIsConditionalVar ) ||	// should skip?
+			((pVar->GetName()[0] == '%') && (g_pShaderDevice->IsUsingGraphics()) && (!MaterialSystem()->CanUseEditorMaterials() ) ) || // is an editor var?
+			ParseMaterialFlag( pVar, ppVars[FLAGS], ppVars[FLAGS_DEFINED], parsingOverrides, flagMask, overrideMask ) || // is a flag?
+			ParseMaterialFlag( pVar, ppVars[FLAGS2], ppVars[FLAGS_DEFINED2], parsingOverrides, flagMask, overrideMask )
+			)
+			bProcessThisOne = false;
+
+		if ( bProcessThisOne )
+		{
+			// See if the var is one of the shader params
+			int varIdx = FindMaterialVar( pShader, pszVarName );
+			
+			// Check for multiply defined or overridden
+			if (varIdx >= 0)
+			{
+				if (ppVars[varIdx] && (! bIsConditionalVar ) )
+				{
+					if ( !pOverride[varIdx] || parsingOverrides )
+					{
+						Warning("Error! Variable \"%s\" is multiply defined in material \"%s\"!\n", pVar->GetName(), GetName() );
+					}
+					goto nextVar;
+				}
+			}
+			else
+			{
+				int i;
+				for ( i = numParams; i < varCount; ++i)
+				{
+					Assert( ppVars[i] );
+					if (!stricmp( ppVars[i]->GetName(), pVar->GetName() ))
+						break;
+				}
+				if (i != varCount)
+				{
+					if ( !pOverride[i] || parsingOverrides )
+					{
+						Warning("Error! Variable \"%s\" is multiply defined in material \"%s\"!\n", pVar->GetName(), GetName() );
+					}
+					goto nextVar;
+				}
+			}
+
+			// Create a material var for this dudely dude; could be zero...
+			pNewVar = CreateMaterialVarFromKeyValue( this, pVar );
+			if (!pNewVar) 
+				goto nextVar;
+
+			if (varIdx < 0)
+			{
+				varIdx = varCount++;
+			}
+			if ( ppVars[varIdx] )
+			{
+				IMaterialVar::Destroy( ppVars[varIdx] );
+			}
+			ppVars[varIdx] = pNewVar;
+			if (parsingOverrides)
+				pOverride[varIdx] = true;
+			bWasConditional[varIdx] = bIsConditionalVar;
+
+		}
+
+nextVar:
+		pVar = pVar->GetNextKey();
+		if (!pVar && parsingOverrides)
+		{
+			pVar = keyValues.GetFirstSubKey();
+			parsingOverrides = false;
+		}
+	}
+
+	// Create undefined vars for all the actual material vars
+	for (int i = 0; i < numParams; ++i)
+	{
+		if (!ppVars[i])
+			ppVars[i] = IMaterialVar::Create( this, pShader->GetParamName(i) );
+	}
+
+	return varCount;
+}
+
+
+static KeyValues *CheckConditionalFakeShaderName( char const *pShaderName, char const *pSuffixName,
+												  KeyValues *pKeyValues )
+{
+	KeyValues *pFallbackSection = pKeyValues->FindKey( pSuffixName );
+	if (pFallbackSection)
+		return pFallbackSection;
+
+	char nameBuf[256];
+	V_snprintf( nameBuf, sizeof(nameBuf), "%s_%s", pShaderName, pSuffixName );
+	pFallbackSection = pKeyValues->FindKey( nameBuf );
+
+	if (pFallbackSection)
+		return pFallbackSection;
+
+	return NULL;
+}
+
+
+static KeyValues *FindBuiltinFallbackBlock( char const *pShaderName, KeyValues *pKeyValues )
+{
+	// handle "fake" shader fallbacks which are conditional upon mode. like _hdr_dx9, etc
+	if ( HardwareConfig()->GetDXSupportLevel() < 90 )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"<DX90", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	if ( HardwareConfig()->GetDXSupportLevel() < 95 )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"<DX95", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	if ( HardwareConfig()->GetDXSupportLevel() < 90 || !HardwareConfig()->SupportsPixelShaders_2_b() )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"<DX90_20b", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	if ( HardwareConfig()->GetDXSupportLevel() >= 90 && HardwareConfig()->SupportsPixelShaders_2_b() )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,">=DX90_20b", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	if ( HardwareConfig()->GetDXSupportLevel() <= 90 )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"<=DX90", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	if ( HardwareConfig()->GetDXSupportLevel() >= 90 )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,">=DX90", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	if ( HardwareConfig()->GetDXSupportLevel() > 90 )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,">DX90", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	if ( HardwareConfig()->GetHDRType() != HDR_TYPE_NONE )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"hdr_dx9", pKeyValues );
+		if ( pRet )
+			return pRet;
+		pRet = CheckConditionalFakeShaderName( pShaderName,"hdr", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	else
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"ldr", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	if ( HardwareConfig()->UsesSRGBCorrectBlending() )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"srgb", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	if ( HardwareConfig()->GetDXSupportLevel() >= 90 )
+	{
+		KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"dx9", pKeyValues );
+		if ( pRet )
+			return pRet;
+	}
+	return NULL;
+}
+
+inline const char *MissingShaderName()
+{
+	return (IsWindows() && !IsEmulatingGL()) ? "Wireframe_DX8" : "Wireframe_DX9";
+}
+
+//-----------------------------------------------------------------------------
+// Hooks up the shader
+//-----------------------------------------------------------------------------
+KeyValues* CMaterial::InitializeShader( KeyValues &keyValues, KeyValues &patchKeyValues, int nFindContext )
+{
+	MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
+
+	KeyValues* pCurrentFallback = &keyValues;
+	KeyValues* pFallbackSection = 0;
+
+	char szShaderName[MAX_PATH];
+	char const* pShaderName = pCurrentFallback->GetName();
+	if ( !pShaderName )
+	{
+		// I'm not quite sure how this can happen, but we'll see... 
+		Warning( "Shader not specified in material %s\nUsing wireframe instead...\n", GetName() );
+		Assert( 0 );
+		pShaderName = MissingShaderName();
+	}
+	else
+	{
+		// can't pass a stable reference to the key values name around
+		// naive leaf functions can cause KV system to re-alloc
+		V_strncpy( szShaderName, pShaderName, sizeof( szShaderName ) );
+		pShaderName = szShaderName;
+	}
+
+	IShader* pShader;
+	IMaterialVar* ppVars[256];
+	char pFallbackShaderNameBuf[256];
+	char pFallbackMaterialNameBuf[256];
+	int varCount = 0;
+	bool modelDefault = false;
+
+	// Keep going until there's no more fallbacks...
+	while( true )
+	{
+		// Find the shader for this material. Note that this may not be
+		// the actual shader we use due to fallbacks...
+		pShader = ShaderSystem()->FindShader( pShaderName );
+		if ( !pShader )
+		{
+			if ( g_pShaderDevice->IsUsingGraphics() )
+			{
+				Warning( "Error: Material \"%s\" uses unknown shader \"%s\"\n", GetName(), pShaderName );
+				//hushed Assert( 0 );
+			}
+
+			pShaderName = MissingShaderName();
+			pShader = ShaderSystem()->FindShader( pShaderName );
+
+			if ( !HushAsserts() )
+			{
+				AssertMsg( pShader, "pShader==NULL. Shader: %s", GetName() );
+			}
+
+#ifndef DEDICATED
+			if ( !pShader ) 
+	 		{
+#ifdef LINUX
+				// Exit out here. We're running into issues where this material is returned in a horribly broken
+				//  state and you wind up crashing in LockMesh() because the vertex and index buffer pointers
+				//  are NULL. You can repro this by not dying here and showing the intro movie. This happens on
+				//  Linux when you run from a symlink'd SteamApps directory.
+				Error( "Shader '%s' for material '%s' not found.\n",
+					   pCurrentFallback->GetName() ? pCurrentFallback->GetName() : pShaderName, GetName() );
+#endif
+	 			MaterialSystem()->Unlock( hMaterialLock );
+	 			return NULL;
+	 		}
+#endif
+
+		}
+
+		bool bHasBuiltinFallbackBlock = false;
+		if ( !pFallbackSection )
+		{
+			pFallbackSection = FindBuiltinFallbackBlock( pShaderName, &keyValues );
+			if( pFallbackSection )
+			{
+				bHasBuiltinFallbackBlock = true;
+				pFallbackSection->ChainKeyValue( &keyValues );
+				pCurrentFallback = pFallbackSection;
+			}
+		}
+
+		// Here we must set up all flags + material vars that the shader needs
+		// because it may look at them when choosing shader fallback.
+		varCount = ParseMaterialVars( pShader, keyValues, pFallbackSection, modelDefault, ppVars, nFindContext );
+
+		if ( !pShader )
+			break;
+
+		// Make sure we set default values before the fallback is looked for
+		ShaderSystem()->InitShaderParameters( pShader, ppVars, GetName() );
+
+		// Now that the material vars are parsed, see if there's a fallback
+		// But only if we're not in the tools
+/*
+		if (!g_pShaderAPI->IsUsingGraphics())
+			break;
+*/
+
+		// Check for a fallback; if not, we're done
+		pShaderName = pShader->GetFallbackShader( ppVars );
+		if (!pShaderName)
+		{
+			break;
+		}
+		// Copy off the shader name, as it may be in a materialvar in the shader
+		// because we're about to delete all materialvars
+		Q_strncpy( pFallbackShaderNameBuf, pShaderName, 256 );
+		pShaderName = pFallbackShaderNameBuf;
+
+		// Remember the model flag if we're on dx7 or higher...
+		if (HardwareConfig()->SupportsVertexAndPixelShaders())
+		{
+			modelDefault = ( ppVars[FLAGS]->GetIntValue() & MATERIAL_VAR_MODEL ) != 0;
+		}
+
+		// Try to get the section associated with the fallback shader
+		// Then chain it to the base data so it can override the 
+		// values if it wants to
+		if( !bHasBuiltinFallbackBlock )
+		{
+			pFallbackSection = keyValues.FindKey( pShaderName );
+			if (pFallbackSection)
+			{
+				pFallbackSection->ChainKeyValue( &keyValues );
+				pCurrentFallback = pFallbackSection;
+			}
+		}
+
+		// Now, blow away all of the material vars + try again...
+		for (int i = 0; i < varCount; ++i)
+		{
+			Assert( ppVars[i] );
+			IMaterialVar::Destroy( ppVars[i] );
+		}
+
+		// Check the KeyValues for '$fallbackmaterial'
+		// Note we have to do this *after* we chain the keyvalues 
+		// based on the fallback shader	since the names of the fallback material
+		// must lie within the shader-specific block usually.
+		const char *pFallbackMaterial = pCurrentFallback->GetString( "$fallbackmaterial" );
+		if ( pFallbackMaterial[0] )
+		{
+			// Don't fallback to ourselves
+			if ( Q_stricmp( GetName(), pFallbackMaterial ) )
+			{
+				// Gotta copy it off; clearing the keyvalues will blow the string away
+				Q_strncpy( pFallbackMaterialNameBuf, pFallbackMaterial, 256 );
+				keyValues.Clear();
+				if( !LoadVMTFile( keyValues, patchKeyValues, pFallbackMaterialNameBuf, UsesUNCFileName(), NULL ) )
+				{
+					Warning( "CMaterial::PrecacheVars: error loading vmt file %s for %s\n", pFallbackMaterialNameBuf, GetName() );
+					keyValues = *(((CMaterial *)g_pErrorMaterial)->m_pVMTKeyValues);
+				}
+			}
+			else
+			{
+				Warning( "CMaterial::PrecacheVars: fallback material for vmt file %s is itself!\n", GetName() );
+				keyValues = *(((CMaterial *)g_pErrorMaterial)->m_pVMTKeyValues);
+			}
+			pCurrentFallback = &keyValues;
+			pFallbackSection = NULL;
+
+			// I'm not quite sure how this can happen, but we'll see... 
+			pShaderName = pCurrentFallback->GetName();
+			if (!pShaderName)
+			{
+				Warning("Shader not specified in material %s (fallback %s)\nUsing wireframe instead...\n", GetName(), pFallbackMaterialNameBuf );
+				pShaderName = MissingShaderName();
+			}
+		}
+	}
+
+	// Store off the shader
+	m_pShader = pShader;
+
+	// Store off the material vars + flags
+	m_VarCount = varCount;
+	m_pShaderParams = (IMaterialVar**)malloc( varCount * sizeof(IMaterialVar*) );
+	memcpy( m_pShaderParams, ppVars, varCount * sizeof(IMaterialVar*) );
+
+#ifdef _DEBUG
+	for (int i = 0; i < varCount; ++i)
+	{
+		Assert( ppVars[i] );
+	}
+#endif
+
+	MaterialSystem()->Unlock( hMaterialLock );
+	return pCurrentFallback;
+}
+
+//-----------------------------------------------------------------------------
+// Gets the texturemap size
+//-----------------------------------------------------------------------------
+
+void CMaterial::PrecacheMappingDimensions( )
+{
+	// Cache mapping width and mapping height
+	if (!m_representativeTexture)
+	{
+#ifdef PARANOID
+		Warning( "No representative texture on material: \"%s\"\n", GetName() );
+#endif
+		m_MappingWidth = 64;
+		m_MappingHeight = 64;
+	}
+	else
+	{
+		m_MappingWidth = m_representativeTexture->GetMappingWidth();
+		m_MappingHeight = m_representativeTexture->GetMappingHeight();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialize the state snapshot
+//-----------------------------------------------------------------------------
+bool CMaterial::InitializeStateSnapshots()
+{
+	if (IsPrecached())
+	{
+		if ( MaterialSystem()->GetCurrentMaterial() == this)
+		{
+			g_pShaderAPI->FlushBufferedPrimitives();
+		}
+
+		// Default state
+		CleanUpStateSnapshots();
+
+		if ( m_pShader && !ShaderSystem()->InitRenderState( m_pShader, m_VarCount, m_pShaderParams, &m_ShaderRenderState, GetName() ))
+		{
+			m_Flags &= ~MATERIAL_VALID_RENDERSTATE;
+			return false;
+		}
+
+		m_Flags |= MATERIAL_VALID_RENDERSTATE;
+	}
+
+	return true;
+}
+
+void CMaterial::CleanUpStateSnapshots()
+{
+	if (IsValidRenderState())
+	{
+		ShaderSystem()->CleanupRenderState(&m_ShaderRenderState);
+		// -- THIS CANNOT BE HERE: m_Flags &= ~MATERIAL_VALID_RENDERSTATE;
+		// -- because it will cause a crash when main thread asks for material
+		// -- sort group it can temporarily see material in invalid render state
+		// -- and crash in DecalSurfaceAdd(msurface2_t*, int)
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// This sets up a debugging/error shader...
+//-----------------------------------------------------------------------------
+void CMaterial::SetupErrorShader()
+{
+	// Preserve the model flags
+	int flags = 0;
+	if ( m_pShaderParams && m_pShaderParams[FLAGS] )
+	{
+		flags = (m_pShaderParams[FLAGS]->GetIntValue() & MATERIAL_VAR_MODEL);
+	}
+
+	CleanUpShaderParams();
+	CleanUpMaterialProxy();
+
+	// We had a failure; replace it with a valid shader...
+
+	m_pShader = ShaderSystem()->FindShader( MissingShaderName() );
+	Assert( m_pShader );
+
+	// Create undefined vars for all the actual material vars
+	m_VarCount = m_pShader->GetNumParams();
+	m_pShaderParams = (IMaterialVar**)malloc( m_VarCount * sizeof(IMaterialVar*) );
+
+	for (int i = 0; i < m_VarCount; ++i)
+	{
+		m_pShaderParams[i] = IMaterialVar::Create( this, m_pShader->GetParamName(i) );
+	}
+
+	// Store the model flags
+	SetMaterialVarFlags( flags, true );
+
+	// Set the default values
+	ShaderSystem()->InitShaderParameters( m_pShader, m_pShaderParams, "Error" );
+
+	// Invokes the SHADER_INIT block in the various shaders,
+	ShaderSystem()->InitShaderInstance( m_pShader, m_pShaderParams, "Error", GetTextureGroupName() );
+
+#ifdef DBGFLAG_ASSERT
+	bool ok = 
+#endif
+		InitializeStateSnapshots();
+
+	m_QueueFriendlyVersion.UpdateToRealTime();
+
+	Assert(ok);
+}
+
+
+//-----------------------------------------------------------------------------
+// This computes the state snapshots for this material
+//-----------------------------------------------------------------------------
+void CMaterial::RecomputeStateSnapshots()
+{
+	CMatCallQueue *pCallQueue = MaterialSystem()->GetRenderCallQueue();
+	if ( pCallQueue )
+	{
+		pCallQueue->QueueCall( this, &CMaterial::RecomputeStateSnapshots );
+		return;
+	}
+
+	bool ok = InitializeStateSnapshots();
+
+	// compute the state snapshots
+	if (!ok)
+	{
+		SetupErrorShader();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Are we valid
+//-----------------------------------------------------------------------------
+inline bool CMaterial::IsValidRenderState() const
+{
+	return (m_Flags & MATERIAL_VALID_RENDERSTATE) != 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Gets/sets material var flags
+//-----------------------------------------------------------------------------
+inline int CMaterial::GetMaterialVarFlags() const
+{
+	if ( m_pShaderParams && m_pShaderParams[FLAGS] )
+	{
+		return m_pShaderParams[FLAGS]->GetIntValueFast();
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+inline void CMaterial::SetMaterialVarFlags( int flags, bool on )
+{
+	if ( !m_pShaderParams )
+	{
+		Assert( 0 );	// are we hanging onto a material that has been cleaned up or isn't ready?
+		return;
+	}
+
+	if (on)
+	{
+		m_pShaderParams[FLAGS]->SetIntValue( GetMaterialVarFlags() | flags );
+	}
+	else
+	{
+		m_pShaderParams[FLAGS]->SetIntValue( GetMaterialVarFlags() & (~flags) );
+	}
+
+	// Mark it as being defined...
+	m_pShaderParams[FLAGS_DEFINED]->SetIntValue( m_pShaderParams[FLAGS_DEFINED]->GetIntValueFast() | flags );
+}
+
+inline int CMaterial::GetMaterialVarFlags2() const
+{
+	if ( m_pShaderParams && m_VarCount > FLAGS2 && m_pShaderParams[FLAGS2] )
+	{
+		return m_pShaderParams[FLAGS2]->GetIntValueFast();
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+inline void CMaterial::SetMaterialVarFlags2( int flags, bool on )
+{
+	if ( m_pShaderParams && m_VarCount > FLAGS2 && m_pShaderParams[FLAGS2] )
+	{
+		if (on)
+			m_pShaderParams[FLAGS2]->SetIntValue( GetMaterialVarFlags2() | flags );
+		else
+			m_pShaderParams[FLAGS2]->SetIntValue( GetMaterialVarFlags2() & (~flags) );
+	}
+
+	if ( m_pShaderParams && m_VarCount > FLAGS_DEFINED2 && m_pShaderParams[FLAGS_DEFINED2] )
+	{
+		// Mark it as being defined...
+		m_pShaderParams[FLAGS_DEFINED2]->SetIntValue( 
+			m_pShaderParams[FLAGS_DEFINED2]->GetIntValueFast() | flags );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Gets the morph format
+//-----------------------------------------------------------------------------
+MorphFormat_t CMaterial::GetMorphFormat() const
+{
+	const_cast<CMaterial*>(this)->Precache();
+	Assert( IsValidRenderState() );
+	return m_ShaderRenderState.m_MorphFormat;
+}
+
+//-----------------------------------------------------------------------------
+// Gets the vertex format
+//-----------------------------------------------------------------------------
+VertexFormat_t CMaterial::GetVertexFormat() const
+{
+	Assert( IsValidRenderState() );
+	return m_ShaderRenderState.m_VertexFormat;
+}
+
+VertexFormat_t CMaterial::GetVertexUsage() const
+{
+	Assert( IsValidRenderState() );
+	return m_ShaderRenderState.m_VertexUsage;
+}
+
+bool CMaterial::PerformDebugTrace() const
+{
+	return IsValidRenderState() && ((GetMaterialVarFlags() & MATERIAL_VAR_DEBUG ) != 0);
+}
+
+
+//-----------------------------------------------------------------------------
+// Are we suppressed?
+//-----------------------------------------------------------------------------
+bool  CMaterial::IsSuppressed() const
+{
+	if ( !IsValidRenderState() )
+		return true;
+
+	return ((GetMaterialVarFlags() & MATERIAL_VAR_NO_DRAW) != 0);
+}
+
+void CMaterial::ToggleSuppression()
+{
+	if (IsValidRenderState())
+	{
+		if ((GetMaterialVarFlags() & MATERIAL_VAR_NO_DEBUG_OVERRIDE) != 0)
+			return;
+
+		SetMaterialVarFlags( MATERIAL_VAR_NO_DRAW, 
+			(GetMaterialVarFlags() & MATERIAL_VAR_NO_DRAW) == 0 );
+	}
+}
+
+void CMaterial::ToggleDebugTrace()
+{
+	if (IsValidRenderState())
+	{
+		SetMaterialVarFlags( MATERIAL_VAR_DEBUG, 
+			(GetMaterialVarFlags() & MATERIAL_VAR_DEBUG) == 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Can we override this material in debug?
+//-----------------------------------------------------------------------------
+
+bool CMaterial::NoDebugOverride() const
+{
+	return IsValidRenderState() && (GetMaterialVarFlags() & MATERIAL_VAR_NO_DEBUG_OVERRIDE) != 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Material Var flags
+//-----------------------------------------------------------------------------
+void CMaterial::SetMaterialVarFlag( MaterialVarFlags_t flag, bool on )
+{
+	CMatCallQueue *pCallQueue = MaterialSystem()->GetRenderCallQueue();
+	if ( pCallQueue )
+	{
+		pCallQueue->QueueCall( this, &CMaterial::SetMaterialVarFlag, flag, on );
+		return;
+	}
+
+	bool oldOn = (GetMaterialVarFlags( ) & flag) != 0;
+	if (oldOn != on)
+	{
+		SetMaterialVarFlags( flag, on );
+
+		// This is going to be called from client code; recompute snapshots!
+		RecomputeStateSnapshots();
+	}
+}
+
+bool CMaterial::GetMaterialVarFlag( MaterialVarFlags_t flag ) const
+{
+	return (GetMaterialVarFlags() & flag) != 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Do we use the env_cubemap entity to get cubemaps from the level?
+//-----------------------------------------------------------------------------
+bool CMaterial::UsesEnvCubemap( void )
+{
+	Precache();
+
+	if( !m_pShader )
+	{
+		if ( !HushAsserts() )
+		{
+			AssertMsg( m_pShader, "m_pShader==NULL. Shader: %s", GetName() );
+		}
+		return false;
+	}
+
+	Assert( m_pShaderParams );
+	return IsFlag2Set( m_pShaderParams, MATERIAL_VAR2_USES_ENV_CUBEMAP );
+}
+
+
+//-----------------------------------------------------------------------------
+// Do we need a tangent space at the vertex level?
+//-----------------------------------------------------------------------------
+bool CMaterial::NeedsTangentSpace( void )
+{
+	Precache();
+
+	if( !m_pShader )
+	{
+		if ( !HushAsserts() )
+		{
+			AssertMsg( m_pShader, "m_pShader==NULL. Shader: %s", GetName() );
+		}
+		return false;
+	}
+
+	Assert( m_pShaderParams );
+	return IsFlag2Set( m_pShaderParams, MATERIAL_VAR2_NEEDS_TANGENT_SPACES );
+}
+
+bool CMaterial::NeedsPowerOfTwoFrameBufferTexture( bool bCheckSpecificToThisFrame )
+{
+	PrecacheVars();
+	if( !m_pShader )
+	{
+		if ( !HushAsserts() )
+		{
+			AssertMsg( m_pShader, "m_pShader==NULL. Shader: %s", GetName() );
+		}
+		return false;
+	}
+
+	Assert( m_pShaderParams );
+	return m_pShader->NeedsPowerOfTwoFrameBufferTexture( m_pShaderParams, bCheckSpecificToThisFrame );
+}
+
+bool CMaterial::NeedsFullFrameBufferTexture( bool bCheckSpecificToThisFrame )
+{
+	PrecacheVars();
+	if( !m_pShader )
+	{
+		if ( !HushAsserts() )
+		{
+			AssertMsg( m_pShader, "m_pShader==NULL. Shader: %s", GetName() );
+		}
+		return false;
+	}
+
+	Assert( m_pShaderParams );
+	return m_pShader->NeedsFullFrameBufferTexture( m_pShaderParams, bCheckSpecificToThisFrame );
+}
+
+// GR - Is lightmap alpha needed?
+bool CMaterial::NeedsLightmapBlendAlpha( void )
+{
+	Precache();
+	return (GetMaterialVarFlags2() & MATERIAL_VAR2_BLEND_WITH_LIGHTMAP_ALPHA ) != 0;
+}
+
+//-----------------------------------------------------------------------------
+// Do we need software skinning?
+//-----------------------------------------------------------------------------
+bool CMaterial::NeedsSoftwareSkinning( void )
+{
+	Precache();
+	Assert( m_pShader );
+	if( !m_pShader )
+	{
+		return false;
+	}
+
+	Assert( m_pShaderParams );
+	return IsFlagSet( m_pShaderParams, MATERIAL_VAR_NEEDS_SOFTWARE_SKINNING );
+}
+
+
+//-----------------------------------------------------------------------------
+// Do we need software lighting?
+//-----------------------------------------------------------------------------
+bool CMaterial::NeedsSoftwareLighting( void )
+{
+	Precache();
+	Assert( m_pShader );
+	if( !m_pShader )
+	{
+		return false;
+	}
+	Assert( m_pShaderParams );
+	return IsFlag2Set( m_pShaderParams, MATERIAL_VAR2_NEEDS_SOFTWARE_LIGHTING );
+}
+
+//-----------------------------------------------------------------------------
+// Alpha/color modulation
+//-----------------------------------------------------------------------------
+void CMaterial::AlphaModulate( float alpha )
+{
+	Precache();
+	if ( m_VarCount > ALPHA )
+		m_pShaderParams[ALPHA]->SetFloatValue(alpha);
+}
+
+void CMaterial::ColorModulate( float r, float g, float b )
+{
+	Precache();
+	if ( m_VarCount > COLOR )
+		m_pShaderParams[COLOR]->SetVecValue( r, g, b );
+}
+
+float CMaterial::GetAlphaModulation()
+{
+	Precache();
+	if ( m_VarCount > ALPHA )
+		return m_pShaderParams[ALPHA]->GetFloatValue();
+	return 0.0f;
+}
+
+void CMaterial::GetColorModulation( float *r, float *g, float *b )
+{
+	Precache();
+
+	float pColor[3] = { 0.0f, 0.0f, 0.0f };
+	if ( m_VarCount > COLOR )
+		m_pShaderParams[COLOR]->GetVecValue( pColor, 3 );
+	*r = pColor[0];
+	*g = pColor[1];
+	*b = pColor[2];
+}
+
+
+//-----------------------------------------------------------------------------
+// Do we use fog?
+//-----------------------------------------------------------------------------
+bool CMaterial::UseFog() const
+{
+	Assert( m_VarCount > 0 );
+	return IsValidRenderState() && ((GetMaterialVarFlags() & MATERIAL_VAR_NOFOG) == 0);
+}
+
+
+//-----------------------------------------------------------------------------
+// diffuse bump?
+//-----------------------------------------------------------------------------
+bool CMaterial::IsUsingDiffuseBumpedLighting() const
+{
+	return (GetMaterialVarFlags2() & MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP ) != 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// lightmap?
+//-----------------------------------------------------------------------------
+bool CMaterial::IsUsingLightmap() const
+{
+	return (GetMaterialVarFlags2() & MATERIAL_VAR2_LIGHTING_LIGHTMAP ) != 0;
+}
+
+bool CMaterial::IsManuallyCreated() const
+{
+	return (m_Flags & MATERIAL_IS_MANUALLY_CREATED) != 0;
+}
+
+bool CMaterial::UsesUNCFileName() const
+{
+	return (m_Flags & MATERIAL_USES_UNC_FILENAME) != 0;
+}
+
+
+void CMaterial::DecideShouldReloadFromWhitelist( IFileList *pFilesToReload )
+{
+	m_bShouldReloadFromWhitelist = false;
+	if ( IsManuallyCreated() || !IsPrecached() )
+		return;
+
+	// Materials loaded with an absolute pathname are usually debug materials.
+	if ( V_IsAbsolutePath( GetName() ) )
+		return;
+
+	char vmtFilename[MAX_PATH];
+	V_ComposeFileName( "materials", GetName(), vmtFilename, sizeof( vmtFilename ) );
+	V_strncat( vmtFilename, ".vmt", sizeof( vmtFilename ) );
+
+	// Check if either this file or any of the files it included need to be reloaded.
+	bool bShouldReload = pFilesToReload->IsFileInList( vmtFilename );
+	if ( !bShouldReload )
+	{
+		for ( int i=0; i < m_VMTIncludes.Count(); i++ )
+		{
+			g_pFullFileSystem->String( m_VMTIncludes[i], vmtFilename, sizeof( vmtFilename ) );
+			if ( pFilesToReload->IsFileInList( vmtFilename ) )
+			{
+				bShouldReload = true;
+				break;
+			}
+		}
+	}
+
+	m_bShouldReloadFromWhitelist = bShouldReload;
+}
+
+void CMaterial::ReloadFromWhitelistIfMarked()
+{
+	if ( !m_bShouldReloadFromWhitelist )
+		return;
+
+	#ifdef PURE_SERVER_DEBUG_SPEW
+	{
+		char vmtFilename[MAX_PATH];
+		V_ComposeFileName( "materials", GetName(), vmtFilename, sizeof( vmtFilename ) );
+		V_strncat( vmtFilename, ".vmt", sizeof( vmtFilename ) );
+		Msg( "Reloading %s due to pure server whitelist change\n", GetName() );
+	}
+	#endif
+
+	Uncache();
+	Precache();
+	if ( !GetShader() )
+	{
+		// We can get in here if we previously loaded this material off disk and now the whitelist 
+		// says to get it out of Steam but it's not in Steam. So just setup a wireframe thingy
+		// to draw the material with.
+		m_Flags |= MATERIAL_IS_PRECACHED | MATERIAL_VARS_IS_PRECACHED;
+		#if DEBUG
+		if (IsOSX())
+		{
+			printf("\n ##### CMaterial::ReloadFromWhitelistIfMarked: GetShader failed on %s, calling SetupErrorShader", m_pDebugName );
+		}
+		#endif
+		
+		SetupErrorShader();
+	}
+}
+
+bool CMaterial::WasReloadedFromWhitelist()
+{
+	return m_bShouldReloadFromWhitelist;
+}
+
+//-----------------------------------------------------------------------------
+// Loads the material vars
+//-----------------------------------------------------------------------------
+bool CMaterial::PrecacheVars( KeyValues *pVMTKeyValues, KeyValues *pPatchKeyValues, CUtlVector<FileNameHandle_t> *pIncludes, int nFindContext )
+{
+	// We should get both parameters or neither
+	Assert( ( pVMTKeyValues == NULL ) ? ( pPatchKeyValues == NULL ) : ( pPatchKeyValues != NULL ) );
+
+	// Don't bother if we're already precached
+	if( IsPrecachedVars() )
+		return true;
+
+	if ( pIncludes )
+		m_VMTIncludes = *pIncludes;
+	else
+		m_VMTIncludes.Purge();
+
+	MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
+
+	bool bOk = false;
+	bool bError = false;
+	KeyValues *vmtKeyValues = NULL;
+	KeyValues *patchKeyValues = NULL;
+	if ( m_pVMTKeyValues )
+	{
+		// Use the procedural KeyValues
+		vmtKeyValues = m_pVMTKeyValues;
+		patchKeyValues = new KeyValues( "vmt_patches" );
+
+		// The caller should not be passing in KeyValues if we have procedural ones
+		Assert( ( pVMTKeyValues == NULL ) && ( pPatchKeyValues == NULL ) );
+	}
+	else if ( pVMTKeyValues )
+	{
+		// Use the passed-in (already-loaded) KeyValues
+		vmtKeyValues = pVMTKeyValues;
+		patchKeyValues = pPatchKeyValues;
+	}
+	else
+	{
+		m_VMTIncludes.Purge();
+
+		// load data from the vmt file
+		vmtKeyValues = new KeyValues( "vmt" );
+		patchKeyValues = new KeyValues( "vmt_patches" );
+		if( !LoadVMTFile( *vmtKeyValues, *patchKeyValues, GetName(), UsesUNCFileName(), &m_VMTIncludes ) )
+		{
+			Warning( "CMaterial::PrecacheVars: error loading vmt file for %s\n", GetName() );
+			bError = true;
+		}
+	}
+
+	if ( ! bError )
+	{
+		// Needed to prevent re-entrancy
+		m_Flags |= MATERIAL_VARS_IS_PRECACHED;
+
+		// Create shader and the material vars...
+		KeyValues *pFallbackKeyValues = InitializeShader( *vmtKeyValues, *patchKeyValues, nFindContext );
+		if ( pFallbackKeyValues )
+		{
+			// Gotta initialize the proxies too, using the fallback proxies
+			InitializeMaterialProxy(pFallbackKeyValues);
+			bOk = true;
+		}
+	}
+
+	// Clean up
+	if ( ( vmtKeyValues != m_pVMTKeyValues ) && ( vmtKeyValues != pVMTKeyValues ) )
+	{
+		vmtKeyValues->deleteThis();
+	}
+	if ( patchKeyValues != pPatchKeyValues )
+	{
+		patchKeyValues->deleteThis();
+	}
+
+	MaterialSystem()->Unlock( hMaterialLock );
+
+	return bOk;
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the material info from the VMT file
+//-----------------------------------------------------------------------------
+void CMaterial::Precache()
+{
+	// Don't bother if we're already precached
+	if ( IsPrecached() )
+		return;
+
+	// load data from the vmt file
+	if ( !PrecacheVars() )
+		return;
+
+	MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
+
+	m_Flags |= MATERIAL_IS_PRECACHED;
+
+	// Invokes the SHADER_INIT block in the various shaders,
+	if ( m_pShader ) 
+	{
+		ShaderSystem()->InitShaderInstance( m_pShader, m_pShaderParams, GetName(), GetTextureGroupName() );
+	}
+
+	// compute the state snapshots
+	RecomputeStateSnapshots();
+
+	FindRepresentativeTexture();
+
+	// Reads in the texture width and height from the material var
+	PrecacheMappingDimensions();
+
+	Assert( IsValidRenderState() );
+
+	if( m_pShaderParams )
+		m_QueueFriendlyVersion.UpdateToRealTime();
+
+	MaterialSystem()->Unlock( hMaterialLock );
+}
+
+
+//-----------------------------------------------------------------------------
+// Unloads the material data from memory
+//-----------------------------------------------------------------------------
+void CMaterial::Uncache( bool bPreserveVars )
+{
+	MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
+
+	// Don't bother if we're not cached
+	if ( IsPrecached() )
+	{
+		// Clean up the state snapshots
+		CleanUpStateSnapshots();
+		m_Flags &= ~MATERIAL_VALID_RENDERSTATE;
+		m_Flags &= ~MATERIAL_IS_PRECACHED;
+	}
+
+	if ( !bPreserveVars )
+	{
+		if ( IsPrecachedVars() )
+		{
+			// Clean up the shader + params
+			CleanUpShaderParams();
+			m_pShader = 0;
+
+			// Clean up the material proxy
+			CleanUpMaterialProxy();
+
+			m_Flags &= ~MATERIAL_VARS_IS_PRECACHED;
+		}
+	}
+
+	MaterialSystem()->Unlock( hMaterialLock );
+
+	// Whether we just now did it, or we were already unloaded,
+	// notify the pure system that the material is unloaded,
+	// so it doesn't caue us to fail sv_pure checks
+	if ( ( m_Flags & ( MATERIAL_VARS_IS_PRECACHED | MATERIAL_IS_MANUALLY_CREATED | MATERIAL_USES_UNC_FILENAME ) ) == 0 )
+	{
+		char szName[ MAX_PATH ];
+		V_sprintf_safe( szName, "materials/%s.vmt", GetName() );
+		g_pFullFileSystem->NotifyFileUnloaded( szName, "GAME" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// reload all textures used by this materals
+//-----------------------------------------------------------------------------
+void CMaterial::ReloadTextures( void )
+{
+	Precache();
+	int i;
+	int nParams = ShaderParamCount();
+	IMaterialVar **ppVars = GetShaderParams();
+	for( i = 0; i < nParams; i++ )
+	{
+		if( ppVars[i] )		
+		{
+			if( ppVars[i]->IsTexture() )
+			{
+				ITextureInternal *pTexture = ( ITextureInternal * )ppVars[i]->GetTextureValue();
+				if( !IsTextureInternalEnvCubemap( pTexture ) )
+				{
+					pTexture->Download();
+				}
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Meant to be used with materials created using CreateMaterial
+// It updates the materials to reflect the current values stored in the material vars
+//-----------------------------------------------------------------------------
+void CMaterial::Refresh()
+{
+	if ( g_pShaderDevice->IsUsingGraphics() )
+	{
+		Uncache();
+		Precache();
+	}
+}
+
+void CMaterial::RefreshPreservingMaterialVars()
+{
+	if ( g_pShaderDevice->IsUsingGraphics() )
+	{
+		Uncache( true );
+		Precache();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Gets the material name
+//-----------------------------------------------------------------------------
+char const* CMaterial::GetName() const
+{
+	return m_Name.String();
+}
+
+
+char const* CMaterial::GetTextureGroupName() const
+{
+	return m_TextureGroupName.String();
+}
+
+
+//-----------------------------------------------------------------------------
+// Material dimensions
+//-----------------------------------------------------------------------------
+int	CMaterial::GetMappingWidth( )
+{
+	Precache();
+	return m_MappingWidth;
+}
+
+int	CMaterial::GetMappingHeight( )
+{
+	Precache();
+	return m_MappingHeight;
+}
+
+
+//-----------------------------------------------------------------------------
+// Animated material info
+//-----------------------------------------------------------------------------
+
+int CMaterial::GetNumAnimationFrames( )
+{
+	Precache();
+	if( m_representativeTexture )
+	{
+		return m_representativeTexture->GetNumAnimationFrames();
+	}
+	else
+	{
+#ifndef POSIX
+		Warning( "CMaterial::GetNumAnimationFrames:\nno representative texture for material %s\n", GetName() );
+#endif
+		return 1;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CMaterial::GetMaterialOffset( float *pOffset )
+{
+	// Identity.
+	pOffset[0] = 0.0f;
+	pOffset[1] = 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CMaterial::GetMaterialScale( float *pScale )
+{
+	// Identity.
+	pScale[0] = 1.0f;
+	pScale[1] = 1.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Reference count
+//-----------------------------------------------------------------------------
+void CMaterial::IncrementReferenceCount( )
+{
+	++m_RefCount;
+}
+
+void CMaterial::DecrementReferenceCount( )
+{
+	--m_RefCount;
+}
+
+int CMaterial::GetReferenceCount( )	const
+{
+	return m_RefCount;
+}
+
+//-----------------------------------------------------------------------------
+// Sets the shader associated with the material
+//-----------------------------------------------------------------------------
+void CMaterial::SetShader( const char *pShaderName )
+{
+	Assert( pShaderName );
+
+	int i;
+	IShader* pShader;
+	IMaterialVar* ppVars[256];
+	int iVarCount = 0;
+
+	// Clean up existing state
+	Uncache();
+
+	// Keep going until there's no more fallbacks...
+	while( true )
+	{
+		// Find the shader for this material. Note that this may not be
+		// the actual shader we use due to fallbacks...
+		pShader = ShaderSystem()->FindShader( pShaderName );
+		if (!pShader)
+		{
+			// Couldn't find the shader we wanted to use; it's not defined...
+			Warning( "SetShader: Couldn't find shader %s for material %s!\n", pShaderName, GetName() );
+			pShaderName = MissingShaderName();
+			pShader = ShaderSystem()->FindShader( pShaderName );
+			Assert( pShader );
+		}
+
+		// Create undefined vars for all the actual material vars
+		iVarCount = pShader->GetNumParams();
+		for (i = 0; i < iVarCount; ++i)
+		{
+			ppVars[i] = IMaterialVar::Create( this, pShader->GetParamName(i) );
+		}
+
+		// Make sure we set default values before the fallback is looked for
+		ShaderSystem()->InitShaderParameters( pShader, ppVars, pShaderName );
+
+		// Now that the material vars are parsed, see if there's a fallback
+		// But only if we're not in the tools
+		if (!g_pShaderDevice->IsUsingGraphics())
+			break;
+
+		// Check for a fallback; if not, we're done
+		pShaderName = pShader->GetFallbackShader( ppVars );
+		if (!pShaderName)
+			break;
+
+		// Now, blow away all of the material vars + try again...
+		for (i = 0; i < iVarCount; ++i)
+		{
+			Assert( ppVars[i] );
+			IMaterialVar::Destroy( ppVars[i] );
+		}
+	}
+
+	// Store off the shader
+	m_pShader = pShader;
+
+	// Store off the material vars + flags
+	m_VarCount = iVarCount;
+	m_pShaderParams = (IMaterialVar**)malloc( iVarCount * sizeof(IMaterialVar*) );
+	memcpy( m_pShaderParams, ppVars, iVarCount * sizeof(IMaterialVar*) );
+
+	// Invokes the SHADER_INIT block in the various shaders,
+	ShaderSystem()->InitShaderInstance( m_pShader, m_pShaderParams, GetName(), GetTextureGroupName() );
+
+	// Precache our initial state...
+	// NOTE: What happens here for textures???
+
+	// Pretend that we precached our material vars; we certainly don't have any!
+	m_Flags |= MATERIAL_VARS_IS_PRECACHED;
+
+	// NOTE: The caller has to call 'Refresh' for the shader to be ready...
+}
+
+const char *CMaterial::GetShaderName() const
+{
+	const_cast< CMaterial* >( this )->PrecacheVars();
+	return m_pShader ? m_pShader->GetName() : "shader_error";
+}
+
+
+//-----------------------------------------------------------------------------
+// Enumeration ID
+//-----------------------------------------------------------------------------
+int CMaterial::GetEnumerationID( ) const
+{
+	return m_iEnumerationID;
+}
+
+void CMaterial::SetEnumerationID( int id )
+{
+	m_iEnumerationID = id;
+}
+
+//-----------------------------------------------------------------------------
+// Preview image
+//-----------------------------------------------------------------------------
+char const* CMaterial::GetPreviewImageName( void )
+{
+	if ( IsConsole() )
+	{
+		// not supporting
+		return NULL;
+	}
+
+	PrecacheVars();
+
+	bool found;
+	IMaterialVar *pRepresentativeTextureVar;
+	
+	FindVar( "%noToolTexture", &found, false );
+	if (found)
+		return NULL;
+
+	pRepresentativeTextureVar = FindVar( "%toolTexture", &found, false );
+	if( found )
+	{
+		if (pRepresentativeTextureVar->GetType() == MATERIAL_VAR_TYPE_STRING )
+			return pRepresentativeTextureVar->GetStringValue();
+		if (pRepresentativeTextureVar->GetType() == MATERIAL_VAR_TYPE_TEXTURE )
+			return pRepresentativeTextureVar->GetTextureValue()->GetName();
+	}
+	pRepresentativeTextureVar = FindVar( "$baseTexture", &found, false );
+	if( found )
+	{
+		if (pRepresentativeTextureVar->GetType() == MATERIAL_VAR_TYPE_STRING )
+			return pRepresentativeTextureVar->GetStringValue();
+		if (pRepresentativeTextureVar->GetType() == MATERIAL_VAR_TYPE_TEXTURE )
+			return pRepresentativeTextureVar->GetTextureValue()->GetName();
+	}
+	return GetName();
+}
+
+char const* CMaterial::GetPreviewImageFileName( void ) const
+{
+	char const* pName = const_cast<CMaterial*>(this)->GetPreviewImageName();
+	if( !pName )
+		return NULL;
+
+	static char vtfFilename[MATERIAL_MAX_PATH];
+	if( Q_strlen( pName ) >= MATERIAL_MAX_PATH - 5 )
+	{
+		Warning( "MATERIAL_MAX_PATH to short for %s.vtf\n", pName );
+		return NULL;
+	}
+
+	if ( !UsesUNCFileName() )
+	{
+		Q_snprintf( vtfFilename, sizeof( vtfFilename ), "materials/%s.vtf", pName );
+	}
+	else
+	{
+		Q_snprintf( vtfFilename, sizeof( vtfFilename ), "%s.vtf", pName );
+	}
+
+	return vtfFilename;
+}
+
+PreviewImageRetVal_t CMaterial::GetPreviewImageProperties( int *width, int *height, 
+				 		ImageFormat *imageFormat, bool* isTranslucent ) const
+{	
+	char const* pFileName = GetPreviewImageFileName();
+	if ( IsX360() || !pFileName )
+	{
+		*width = *height = 0;
+		*imageFormat = IMAGE_FORMAT_RGBA8888;
+		*isTranslucent = false;
+		return MATERIAL_NO_PREVIEW_IMAGE;
+	}
+
+	int nHeaderSize = VTFFileHeaderSize( VTF_MAJOR_VERSION );
+	unsigned char *pMem = (unsigned char *)stackalloc( nHeaderSize );
+	CUtlBuffer buf( pMem, nHeaderSize );
+	if( !g_pFullFileSystem->ReadFile( pFileName, NULL, buf, nHeaderSize ) )
+	{
+		Warning( "\"%s\" - \"%s\": cached version doesn't exist\n", GetName(), pFileName );
+		return MATERIAL_PREVIEW_IMAGE_BAD;
+	}
+	
+	IVTFTexture *pVTFTexture = CreateVTFTexture();
+	if (!pVTFTexture->Unserialize( buf, true ))
+	{
+		Warning( "Error reading material \"%s\"\n", pFileName );
+		DestroyVTFTexture( pVTFTexture );
+		return MATERIAL_PREVIEW_IMAGE_BAD;
+	}
+
+	*width = pVTFTexture->Width();
+	*height = pVTFTexture->Height();
+	*imageFormat = pVTFTexture->Format();
+	*isTranslucent = (pVTFTexture->Flags() & (TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA)) != 0;
+	DestroyVTFTexture( pVTFTexture );
+	return MATERIAL_PREVIEW_IMAGE_OK;
+}
+
+PreviewImageRetVal_t CMaterial::GetPreviewImage( unsigned char *pData, int width, int height,
+					             ImageFormat imageFormat ) const
+{
+	CUtlBuffer buf;
+	int nHeaderSize;
+	int nImageOffset, nImageSize;
+
+	char const* pFileName = GetPreviewImageFileName();
+	if ( IsX360() || !pFileName )
+	{
+		return MATERIAL_NO_PREVIEW_IMAGE;
+	}
+
+	IVTFTexture *pVTFTexture = CreateVTFTexture();
+	FileHandle_t fileHandle = g_pFullFileSystem->Open( pFileName, "rb" );
+	if( !fileHandle )
+	{
+		Warning( "\"%s\": cached version doesn't exist\n", pFileName );
+		goto fail;
+	}
+
+	nHeaderSize = VTFFileHeaderSize( VTF_MAJOR_VERSION );
+	buf.EnsureCapacity( nHeaderSize );
+	
+	// read the header first.. it's faster!!
+	int nBytesRead; // GCC won't let this be initialized right away
+	nBytesRead = g_pFullFileSystem->Read( buf.Base(), nHeaderSize, fileHandle );
+	buf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );
+		
+	// Unserialize the header
+	if (!pVTFTexture->Unserialize( buf, true ))
+	{
+		Warning( "Error reading material \"%s\"\n", pFileName );
+		goto fail;
+	}
+		
+	// FIXME: Make sure the preview image size requested is the same
+	// size as mip level 0 of the texture
+	Assert( (width == pVTFTexture->Width()) && (height == pVTFTexture->Height()) );
+		
+	// Determine where in the file to start reading (frame 0, face 0, mip 0)
+	pVTFTexture->ImageFileInfo( 0, 0, 0, &nImageOffset, &nImageSize );
+
+	if ( nImageSize == 0 )
+	{
+		Warning( "Couldn't determine offset and size of material \"%s\"\n", pFileName );
+		goto fail;
+	}
+		
+	// Prep the utlbuffer for reading
+	buf.EnsureCapacity( nImageSize );
+	buf.SeekPut( CUtlBuffer::SEEK_HEAD, 0 );
+		
+	// Read in the bits at the specified location
+	g_pFullFileSystem->Seek( fileHandle, nImageOffset, FILESYSTEM_SEEK_HEAD );
+	g_pFullFileSystem->Read( buf.Base(), nImageSize, fileHandle );
+	g_pFullFileSystem->Close( fileHandle );
+		
+	// Convert from the format read in to the requested format
+	ImageLoader::ConvertImageFormat( (unsigned char*)buf.Base(), pVTFTexture->Format(), 
+		pData, imageFormat, width, height );
+
+	DestroyVTFTexture( pVTFTexture );
+	return MATERIAL_PREVIEW_IMAGE_OK;
+
+fail:
+	if( fileHandle )
+	{
+		g_pFullFileSystem->Close( fileHandle );
+	}
+	int nSize = ImageLoader::GetMemRequired( width, height, 1, imageFormat, false );
+	memset( pData, 0xff, nSize );
+	DestroyVTFTexture( pVTFTexture );
+	return MATERIAL_PREVIEW_IMAGE_BAD;
+}
+
+//-----------------------------------------------------------------------------
+// Material variables
+//-----------------------------------------------------------------------------
+IMaterialVar *CMaterial::FindVar( char const *pVarName, bool *pFound, bool complain )
+{
+	PrecacheVars();
+
+	// FIXME: Could look for flags here too...
+
+	MaterialVarSym_t sym = IMaterialVar::FindSymbol(pVarName);
+	if ( sym != UTL_INVAL_SYMBOL )
+	{
+		for (int i = m_VarCount; --i >= 0; )
+		{
+			if (m_pShaderParams[i]->GetNameAsSymbol() == sym)
+			{
+				if( pFound )
+					*pFound = true;					  
+				return m_pShaderParams[i];
+			}
+		}
+	}
+
+	if( pFound )
+		*pFound = false;
+
+	if( complain )
+	{
+		static int complainCount = 0;
+		if( complainCount < 100 )
+		{
+			Warning( "No such variable \"%s\" for material \"%s\"\n", pVarName, GetName() );
+			complainCount++;
+		}
+	}
+	return GetDummyVariable();
+}
+
+struct tokencache_t
+{
+	unsigned short symbol;
+	unsigned char varIndex;
+	unsigned char cached;
+};
+
+IMaterialVar *CMaterial::FindVarFast( char const *pVarName, unsigned int *pCacheData )
+{
+	tokencache_t *pToken = reinterpret_cast<tokencache_t *>(pCacheData);
+	PrecacheVars();
+
+	if ( pToken->cached )
+	{
+		if ( pToken->varIndex < m_VarCount && m_pShaderParams[pToken->varIndex]->GetNameAsSymbol() == pToken->symbol )
+			return m_pShaderParams[pToken->varIndex];
+		// FIXME: Could look for flags here too...
+		if ( !IMaterialVar::SymbolMatches(pVarName, pToken->symbol) )
+		{
+			pToken->symbol = IMaterialVar::FindSymbol(pVarName);
+		}
+	}
+	else
+	{
+		pToken->cached = true;
+		pToken->symbol = IMaterialVar::FindSymbol(pVarName);
+	}
+
+	if ( pToken->symbol != UTL_INVAL_SYMBOL )
+	{
+		for (int i = m_VarCount; --i >= 0; )
+		{
+			if (m_pShaderParams[i]->GetNameAsSymbol() == pToken->symbol)
+			{
+				pToken->varIndex = i;
+				return m_pShaderParams[i];
+			}
+		}
+	}
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Lovely material properties
+//-----------------------------------------------------------------------------
+void CMaterial::GetReflectivity( Vector& reflect )
+{
+	Precache();
+
+	reflect = m_Reflectivity;
+}
+
+
+bool CMaterial::GetPropertyFlag( MaterialPropertyTypes_t type )
+{
+	Precache();
+
+	if (!IsValidRenderState())
+		return false;
+
+	switch( type )
+	{
+	case MATERIAL_PROPERTY_NEEDS_LIGHTMAP:
+		return IsUsingLightmap();
+
+	case MATERIAL_PROPERTY_NEEDS_BUMPED_LIGHTMAPS:
+		return IsUsingDiffuseBumpedLighting();
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Is the material visible from both sides?
+//-----------------------------------------------------------------------------
+bool CMaterial::IsTwoSided()
+{
+	PrecacheVars();
+	return GetMaterialVarFlag(MATERIAL_VAR_NOCULL);
+}
+
+
+//-----------------------------------------------------------------------------
+// Are we translucent?
+//-----------------------------------------------------------------------------
+bool CMaterial::IsTranslucent()
+{
+	Precache();
+	if ( m_VarCount > ALPHA )
+		return IsTranslucentInternal( m_pShaderParams? m_pShaderParams[ALPHA]->GetFloatValue() : 0.0  );
+	return false;
+}
+
+
+bool CMaterial::IsTranslucentInternal( float fAlphaModulation ) const
+{
+	if (m_pShader && IsValidRenderState())
+	{
+		// I have to check for alpha modulation here because it isn't
+		// factored into the shader's notion of whether or not it's transparent
+		return ::IsTranslucent(&m_ShaderRenderState) || 
+			(fAlphaModulation < 1.0f) ||
+			m_pShader->IsTranslucent( m_pShaderParams );
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Are we alphatested?
+//-----------------------------------------------------------------------------
+bool CMaterial::IsAlphaTested()
+{
+	Precache();
+	if (m_pShader && IsValidRenderState())
+	{
+		return ::IsAlphaTested(&m_ShaderRenderState) || 
+				GetMaterialVarFlag( MATERIAL_VAR_ALPHATEST );
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Are we vertex lit?
+//-----------------------------------------------------------------------------
+bool CMaterial::IsVertexLit()
+{
+	Precache();
+	if (IsValidRenderState())
+	{
+		return ( GetMaterialVarFlags2() & MATERIAL_VAR2_LIGHTING_VERTEX_LIT ) != 0;
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Is the shader a sprite card shader?
+//-----------------------------------------------------------------------------
+bool CMaterial::IsSpriteCard()
+{
+	Precache();
+	if (IsValidRenderState())
+	{
+		return ( GetMaterialVarFlags2() & MATERIAL_VAR2_IS_SPRITECARD ) != 0;
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Proxies
+//-----------------------------------------------------------------------------
+void CMaterial::CallBindProxy( void *proxyData )
+{
+	CMatCallQueue *pCallQueue = MaterialSystem()->GetRenderCallQueue();
+	bool bIsThreaded = ( pCallQueue != NULL );
+	switch (g_config.proxiesTestMode)
+	{
+	case 0:
+		{
+			// Make sure we call the proxies in the order in which they show up
+			// in the .vmt file
+			if ( m_ProxyInfo.Count() )
+			{
+				if ( bIsThreaded )
+				{
+					EnableThreadedMaterialVarAccess( true, m_pShaderParams, m_VarCount );
+				}
+				for( int i = 0; i < m_ProxyInfo.Count(); ++i )
+				{
+					m_ProxyInfo[i]->OnBind( proxyData );
+				}
+				if ( bIsThreaded )
+				{
+					EnableThreadedMaterialVarAccess( false, m_pShaderParams, m_VarCount );
+				}
+			}
+		}
+		break;
+
+	case 2:
+		// alpha mod all....
+		{
+			float value = ( sin( 2.0f * M_PI * Plat_FloatTime() / 10.0f ) * 0.5f ) + 0.5f;
+			m_pShaderParams[ALPHA]->SetFloatValue( value );
+		}
+		break;
+
+	case 3:
+		// color mod all...
+		{
+			float value = ( sin( 2.0f * M_PI * Plat_FloatTime() / 10.0f ) * 0.5f ) + 0.5f;
+			m_pShaderParams[COLOR]->SetVecValue( value, 1.0f, 1.0f );
+		}
+		break;
+	}
+}
+
+
+IMaterial *CMaterial::CheckProxyReplacement( void *proxyData )
+{
+	if ( m_pReplacementProxy != NULL )
+	{
+		IMaterial	*pReplaceMaterial = m_pReplacementProxy->GetMaterial();
+
+		if ( pReplaceMaterial )
+		{
+			return pReplaceMaterial;
+		}
+	}
+
+	return this;
+}
+
+
+bool CMaterial::HasProxy( )	const
+{
+	const_cast< CMaterial* >( this )->PrecacheVars();
+	return m_ProxyInfo.Count() > 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Main draw method
+//-----------------------------------------------------------------------------
+
+#ifdef _WIN32
+#pragma warning (disable: 4189)
+#endif
+
+void CMaterial::DrawMesh( VertexCompressionType_t vertexCompression )
+{
+	if ( m_pShader )
+	{
+#ifdef _DEBUG
+		if ( GetMaterialVarFlags() & MATERIAL_VAR_DEBUG )
+		{
+			// Putcher breakpoint here to catch the rendering of a material
+			// marked for debugging ($debug = 1 in a .vmt file) dynamic state version
+			int x = 0;
+		}
+#endif
+		if ((GetMaterialVarFlags() & MATERIAL_VAR_NO_DRAW) == 0)
+		{
+			const char *pName = m_pShader->GetName();
+			ShaderSystem()->DrawElements( m_pShader, m_pShaderParams, &m_ShaderRenderState, vertexCompression, m_ChangeID ^ g_nDebugVarsSignature );
+		}
+	}
+	else
+	{
+		Warning( "CMaterial::DrawElements: No bound shader\n" );
+	}
+}
+
+#ifdef _WIN32
+#pragma warning (default: 4189)
+#endif
+
+IShader *CMaterial::GetShader( ) const
+{
+	return m_pShader;
+}
+
+IMaterialVar *CMaterial::GetShaderParam( int id )
+{
+	return m_pShaderParams[id];
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a material variable to the material
+//-----------------------------------------------------------------------------
+void CMaterial::AddMaterialVar( IMaterialVar *pMaterialVar )
+{
+	++m_VarCount;
+	m_pShaderParams = (IMaterialVar**)realloc( m_pShaderParams, m_VarCount * sizeof( IMaterialVar*) );
+	m_pShaderParams[m_VarCount-1] = pMaterialVar;
+}
+
+
+bool CMaterial::IsErrorMaterial() const
+{
+	extern IMaterialInternal *g_pErrorMaterial;
+	const IMaterialInternal *pThis = this;
+	return g_pErrorMaterial == pThis;
+}
+
+
+void CMaterial::FindRepresentativeTexture( void )
+{
+	Precache();
+	
+	// First try to find the base texture...
+	bool found;
+	IMaterialVar *textureVar = FindVar( "$baseTexture", &found, false );
+	if( found && textureVar->GetType() == MATERIAL_VAR_TYPE_TEXTURE )
+	{
+		ITextureInternal *pTexture = ( ITextureInternal * )textureVar->GetTextureValue();
+		if( pTexture )
+		{
+			pTexture->GetReflectivity( m_Reflectivity );
+		}
+	}
+	if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
+	{
+		// Try the env map mask if the base texture doesn't work...
+		// this is needed for specular decals
+		textureVar = FindVar( "$envmapmask", &found, false );
+		if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
+		{
+			// Try the bumpmap
+			textureVar = FindVar( "$bumpmap", &found, false );
+			if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
+			{
+				textureVar = FindVar( "$dudvmap", &found, false );
+				if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
+				{
+					textureVar = FindVar( "$normalmap", &found, false );
+					if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
+					{
+						//				Warning( "Can't find representative texture for material \"%s\"\n",	GetName() );
+						m_representativeTexture = TextureManager()->ErrorTexture();
+						return;
+					}
+				}
+			}
+		}
+	}
+
+	m_representativeTexture = static_cast<ITextureInternal *>( textureVar->GetTextureValue() );
+	if (m_representativeTexture)
+	{
+		m_representativeTexture->Precache();
+	}
+	else
+	{
+		m_representativeTexture = TextureManager()->ErrorTexture();
+		Assert( m_representativeTexture );
+	}
+}
+
+
+void CMaterial::GetLowResColorSample( float s, float t, float *color ) const
+{
+	if( !m_representativeTexture )
+	{
+		return;
+	}
+	m_representativeTexture->GetLowResColorSample( s, t, color);
+}
+
+
+//-----------------------------------------------------------------------------
+// Lightmap-related methods
+//-----------------------------------------------------------------------------
+
+void CMaterial::SetMinLightmapPageID( int pageID )
+{
+	m_minLightmapPageID = pageID;
+}
+
+void CMaterial::SetMaxLightmapPageID( int pageID )
+{
+	m_maxLightmapPageID = pageID;
+}
+
+int CMaterial::GetMinLightmapPageID( ) const
+{
+	return m_minLightmapPageID;
+}
+
+int	CMaterial::GetMaxLightmapPageID( ) const
+{
+	return m_maxLightmapPageID;
+}
+
+void CMaterial::SetNeedsWhiteLightmap( bool val )
+{
+	if ( val )
+		m_Flags |= MATERIAL_NEEDS_WHITE_LIGHTMAP;
+	else
+		m_Flags &= ~MATERIAL_NEEDS_WHITE_LIGHTMAP;
+}
+
+bool CMaterial::GetNeedsWhiteLightmap( ) const
+{
+	return (m_Flags & MATERIAL_NEEDS_WHITE_LIGHTMAP) != 0;
+}
+
+void CMaterial::MarkAsPreloaded( bool bSet )
+{
+	if ( bSet )
+	{
+		m_Flags |= MATERIAL_IS_PRELOADED;
+	}
+	else
+	{
+		m_Flags &= ~MATERIAL_IS_PRELOADED;
+	}
+}
+
+bool CMaterial::IsPreloaded() const
+{
+	return ( m_Flags & MATERIAL_IS_PRELOADED ) != 0;
+}
+
+void CMaterial::ArtificialAddRef( void )
+{
+	if ( m_Flags & MATERIAL_ARTIFICIAL_REFCOUNT )
+	{
+		// already done
+		return;
+	}
+
+	m_Flags |= MATERIAL_ARTIFICIAL_REFCOUNT;
+	m_RefCount++;
+}
+
+void CMaterial::ArtificialRelease( void )
+{
+	if ( !( m_Flags & MATERIAL_ARTIFICIAL_REFCOUNT ) )
+	{
+		return;
+	}
+
+	m_Flags &= ~MATERIAL_ARTIFICIAL_REFCOUNT;
+	m_RefCount--;
+}
+
+//-----------------------------------------------------------------------------
+// Return the shader params
+//-----------------------------------------------------------------------------
+IMaterialVar **CMaterial::GetShaderParams( void )
+{
+	return m_pShaderParams;
+}
+
+int CMaterial::ShaderParamCount() const
+{
+	return m_VarCount;
+}
+
+
+//-----------------------------------------------------------------------------
+// VMT parser
+//-----------------------------------------------------------------------------
+void InsertKeyValues( KeyValues& dst, KeyValues& src, bool bCheckForExistence, bool bRecursive )
+{
+	KeyValues *pSrcVar = src.GetFirstSubKey();
+	while( pSrcVar )
+	{
+		if ( !bCheckForExistence || dst.FindKey( pSrcVar->GetName() ) )
+		{
+			switch( pSrcVar->GetDataType() )
+			{
+			case KeyValues::TYPE_STRING:
+				dst.SetString( pSrcVar->GetName(), pSrcVar->GetString() );
+				break;
+			case KeyValues::TYPE_INT:
+				dst.SetInt( pSrcVar->GetName(), pSrcVar->GetInt() );
+				break;
+			case KeyValues::TYPE_FLOAT:
+				dst.SetFloat( pSrcVar->GetName(), pSrcVar->GetFloat() );
+				break;
+			case KeyValues::TYPE_PTR:
+				dst.SetPtr( pSrcVar->GetName(), pSrcVar->GetPtr() );
+				break;
+			case KeyValues::TYPE_NONE:
+				{
+					// Subkey. Recurse.
+					KeyValues *pNewDest = dst.FindKey( pSrcVar->GetName(), true );
+					Assert( pNewDest );
+					InsertKeyValues( *pNewDest, *pSrcVar, bCheckForExistence, true );
+				}
+				break;
+			}
+		}
+		pSrcVar = pSrcVar->GetNextKey();
+	}
+	
+	if ( bRecursive && !dst.GetFirstSubKey() )
+	{
+		// Insert a dummy key to an empty subkey to make sure it doesn't get removed
+		dst.SetInt( "__vmtpatchdummy", 1 );
+	}
+
+	if( bCheckForExistence )
+	{
+		for( KeyValues *pScan = dst.GetFirstTrueSubKey(); pScan; pScan = pScan->GetNextTrueSubKey() )
+		{
+			KeyValues *pTmp = src.FindKey( pScan->GetName() );
+			if( !pTmp )
+				continue;
+			// make sure that this is a subkey.
+			if( pTmp->GetDataType() != KeyValues::TYPE_NONE )
+				continue;
+			InsertKeyValues( *pScan, *pTmp, bCheckForExistence );
+		}
+	}
+}
+
+void WriteKeyValuesToFile( const char *pFileName, KeyValues& keyValues )
+{
+	keyValues.SaveToFile( g_pFullFileSystem, pFileName );
+}
+
+void ApplyPatchKeyValues( KeyValues &keyValues, KeyValues &patchKeyValues )
+{
+	KeyValues *pInsertSection = patchKeyValues.FindKey( "insert" );
+	KeyValues *pReplaceSection = patchKeyValues.FindKey( "replace" );
+
+	if ( pInsertSection )
+	{
+		InsertKeyValues( keyValues, *pInsertSection, false );
+	}
+
+	if ( pReplaceSection )
+	{
+		InsertKeyValues( keyValues, *pReplaceSection, true );
+	}
+
+	// Could add other commands here, like "delete", "rename", etc.
+}
+
+//-----------------------------------------------------------------------------
+// Adds keys from srcKeys to destKeys, overwriting any keys that are already
+// there.
+//-----------------------------------------------------------------------------
+void MergeKeyValues( KeyValues &srcKeys, KeyValues &destKeys )
+{
+	for( KeyValues *pKV = srcKeys.GetFirstValue(); pKV; pKV = pKV->GetNextValue() )
+	{
+		switch( pKV->GetDataType() )
+		{
+		case KeyValues::TYPE_STRING:
+			destKeys.SetString( pKV->GetName(), pKV->GetString() );
+			break;
+		case KeyValues::TYPE_INT:
+			destKeys.SetInt( pKV->GetName(), pKV->GetInt() );
+			break;
+		case KeyValues::TYPE_FLOAT:
+			destKeys.SetFloat( pKV->GetName(), pKV->GetFloat() );
+			break;
+		case KeyValues::TYPE_PTR:
+			destKeys.SetPtr( pKV->GetName(), pKV->GetPtr() );
+			break;
+		}
+	}
+	for( KeyValues *pKV = srcKeys.GetFirstTrueSubKey(); pKV; pKV = pKV->GetNextTrueSubKey() )
+	{
+		KeyValues *pDestKV = destKeys.FindKey( pKV->GetName(), true );
+		MergeKeyValues( *pKV, *pDestKV );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void AccumulatePatchKeyValues( KeyValues &srcKeyValues, KeyValues &patchKeyValues )
+{
+	KeyValues *pDestInsertSection = patchKeyValues.FindKey( "insert" );
+	if ( pDestInsertSection == NULL )
+	{
+		pDestInsertSection = new KeyValues( "insert" );
+		patchKeyValues.AddSubKey( pDestInsertSection );
+	}
+
+	KeyValues *pDestReplaceSection = patchKeyValues.FindKey( "replace" );
+	if ( pDestReplaceSection == NULL )
+	{
+		pDestReplaceSection = new KeyValues( "replace" );
+		patchKeyValues.AddSubKey( pDestReplaceSection );
+	}
+
+	KeyValues *pSrcInsertSection = srcKeyValues.FindKey( "insert" );
+	if ( pSrcInsertSection )
+	{
+		MergeKeyValues( *pSrcInsertSection, *pDestInsertSection );
+	}
+
+	KeyValues *pSrcReplaceSection = srcKeyValues.FindKey( "replace" );
+	if ( pSrcReplaceSection )
+	{
+		MergeKeyValues( *pSrcReplaceSection, *pDestReplaceSection );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool AccumulateRecursiveVmtPatches( KeyValues &patchKeyValuesOut, KeyValues **ppBaseKeyValuesOut, const KeyValues& keyValues, const char *pPathID, CUtlVector<FileNameHandle_t> *pIncludes )
+{
+	if ( pIncludes )
+	{
+		pIncludes->Purge();
+	}
+
+	patchKeyValuesOut.Clear();
+
+	if ( V_stricmp( keyValues.GetName(), "patch" ) != 0 )
+	{
+		// Not a patch file, nothing to do
+		if ( ppBaseKeyValuesOut )
+		{
+			// flag to the caller that the passed in keyValues are in fact final non-patch values
+			*ppBaseKeyValuesOut = NULL;
+		}
+		return true;
+	}
+
+	KeyValues *pCurrentKeyValues = keyValues.MakeCopy();
+
+	// Recurse down through all patch files:
+	int nCount = 0;
+	while( ( nCount < 10 ) && ( V_stricmp( pCurrentKeyValues->GetName(), "patch" ) == 0 ) )
+	{
+		// Accumulate the new patch keys from this file
+		AccumulatePatchKeyValues( *pCurrentKeyValues, patchKeyValuesOut );
+		
+		// Load the included file
+		const char *pIncludeFileName = pCurrentKeyValues->GetString( "include" );
+
+		if ( pIncludeFileName == NULL )
+		{
+			// A patch file without an include key? Not good...
+			Warning( "VMT patch file has no include key - invalid!\n" );
+			Assert( pIncludeFileName );
+			break;
+		}
+
+		CUtlString includeFileName( pIncludeFileName ); // copy off the string before we clear the keyvalues it lives in
+		pCurrentKeyValues->Clear();
+		bool bSuccess = pCurrentKeyValues->LoadFromFile( g_pFullFileSystem, includeFileName, pPathID );
+		if( bSuccess )
+		{
+			if ( pIncludes )
+			{
+				// Remember that we included this file for the pure server stuff.
+				pIncludes->AddToTail( g_pFullFileSystem->FindOrAddFileName( includeFileName ) );
+			}
+		}
+		else
+		{
+			pCurrentKeyValues->deleteThis();
+#ifndef DEDICATED
+			Warning( "Failed to load $include VMT file (%s)\n", includeFileName.String() );
+#endif
+			if ( !HushAsserts() )
+			{
+				AssertMsg( false, "Failed to load $include VMT file (%s)", includeFileName.String() );
+			}
+			return false;
+		}
+
+		nCount++;
+	}
+
+	if ( ppBaseKeyValuesOut )
+	{
+		*ppBaseKeyValuesOut = pCurrentKeyValues;
+	}
+	else
+	{
+		pCurrentKeyValues->deleteThis();
+	}
+
+	if( nCount >= 10 )
+	{
+		Warning( "Infinite recursion in patch file?\n" );
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void ExpandPatchFile( KeyValues& keyValues, KeyValues &patchKeyValues, const char *pPathID, CUtlVector<FileNameHandle_t> *pIncludes )
+{
+	KeyValues *pNonPatchKeyValues = NULL;
+	if ( !patchKeyValues.IsEmpty() )
+	{
+		pNonPatchKeyValues = keyValues.MakeCopy();
+	}
+	else
+	{
+		bool bSuccess = AccumulateRecursiveVmtPatches( patchKeyValues, &pNonPatchKeyValues, keyValues, pPathID, pIncludes );
+		if ( !bSuccess )
+		{
+			return;
+		}
+	}
+
+	if ( pNonPatchKeyValues != NULL )
+	{
+		// We're dealing with a patch file. Apply accumulated patches to final vmt
+		ApplyPatchKeyValues( *pNonPatchKeyValues, patchKeyValues );
+		keyValues = *pNonPatchKeyValues;
+		pNonPatchKeyValues->deleteThis();
+	}
+}
+
+bool LoadVMTFile( KeyValues &vmtKeyValues, KeyValues &patchKeyValues, const char *pMaterialName, bool bAbsolutePath, CUtlVector<FileNameHandle_t> *pIncludes )
+{
+	char pFileName[MAX_PATH];
+	const char *pPathID = "GAME";
+	if ( !bAbsolutePath )
+	{
+		Q_snprintf( pFileName, sizeof( pFileName ), "materials/%s.vmt", pMaterialName );
+	}
+	else
+	{
+		Q_snprintf( pFileName, sizeof( pFileName ), "%s.vmt", pMaterialName );
+		if ( pMaterialName[0] == '/' && pMaterialName[1] == '/' && pMaterialName[2] != '/' )
+		{
+			// UNC, do full search
+			pPathID = NULL;
+		}
+	}
+
+	if ( !vmtKeyValues.LoadFromFile( g_pFullFileSystem, pFileName, pPathID ) )
+	{
+		return false;
+	}
+	ExpandPatchFile( vmtKeyValues, patchKeyValues, pPathID, pIncludes );
+
+	return true;
+}
+
+int CMaterial::GetNumPasses( void )
+{
+	Precache();
+//	int mod = m_ShaderRenderState.m_Modulation;
+	int mod = 0;
+	return m_ShaderRenderState.m_pSnapshots[mod].m_nPassCount;
+}
+
+int CMaterial::GetTextureMemoryBytes( void )
+{
+	Precache();
+	int bytes = 0;
+	int i;
+	for( i = 0; i < m_VarCount; i++ )
+	{
+		IMaterialVar *pVar = m_pShaderParams[i];
+		if( pVar->GetType() == MATERIAL_VAR_TYPE_TEXTURE )
+		{
+			ITexture *pTexture = pVar->GetTextureValue();
+			if( pTexture && pTexture != ( ITexture * )0xffffffff )
+			{
+				bytes += pTexture->GetApproximateVidMemBytes();
+			}
+		}
+	}
+	return bytes;
+}
+
+void CMaterial::SetUseFixedFunctionBakedLighting( bool bEnable )
+{
+	SetMaterialVarFlags2( MATERIAL_VAR2_USE_FIXED_FUNCTION_BAKED_LIGHTING, bEnable );
+}
+
+bool CMaterial::NeedsFixedFunctionFlashlight() const
+{
+	return ( GetMaterialVarFlags2() & MATERIAL_VAR2_NEEDS_FIXED_FUNCTION_FLASHLIGHT ) &&
+		MaterialSystem()->InFlashlightMode();
+}
+
+bool CMaterial::IsUsingVertexID( ) const
+{
+	return ( GetMaterialVarFlags2() & MATERIAL_VAR2_USES_VERTEXID ) != 0;
+}
+
+void CMaterial::DeleteIfUnreferenced()
+{
+	if ( m_RefCount > 0 )
+		return;
+	IMaterialVar::DeleteUnreferencedTextures( true );
+	IMaterialInternal::DestroyMaterial( this );
+	IMaterialVar::DeleteUnreferencedTextures( false );
+}