//========= 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 );
}