csgo/cstrike15_src/materialsystem/mat_stub.cpp

//========= Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=====================================================================================//

#include "materialsystem/imesh.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "materialsystem/imorph.h"
#include "materialsystem/imaterialsystemstub.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/itexture.h"
#include "materialsystem/imaterialvar.h"
#include "bitmap/imageformat.h"
#include "mathlib/vmatrix.h"
#include "utlvector.h"
// GR
#include "imaterialinternal.h"
#include "materialsystem/materialsystem_config.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

// ---------------------------------------------------------------------------------------- //
// IMaterialSystem and IMesh stub classes.
// ---------------------------------------------------------------------------------------- //
CUtlVector<unsigned short> g_DummyIndices;

class CDummyMesh : public IMesh
{
public:
	// Locks/ unlocks the mesh, providing space for nVertexCount and nIndexCount.
	// nIndexCount of -1 means don't lock the index buffer...
	virtual void LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc, MeshBuffersAllocationSettings_t *pSettings = 0 )
	{
		Lock( nVertexCount, false, *static_cast< VertexDesc_t* >( &desc ) );
		Lock( nIndexCount, false, *static_cast< IndexDesc_t* >( &desc ) );
	}

	virtual void UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc )
	{
	}

	virtual void ModifyBeginEx( bool bReadOnly, int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc )
	{
		ModifyBegin( bReadOnly, nFirstIndex, nIndexCount, *static_cast< IndexDesc_t* >( &desc ) );
	}

	virtual void ModifyBegin( int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc )
	{
		ModifyBegin( false, nFirstIndex, nIndexCount, *static_cast< IndexDesc_t* >( &desc ) );
	}

	virtual void ModifyEnd( MeshDesc_t &desc )
	{
	}

	// FIXME: Make this work! Unsupported methods of IIndexBuffer
	virtual bool Lock( int nMaxIndexCount, bool bAppend, IndexDesc_t& desc ) 
	{
		static unsigned short dummyIndex;
		desc.m_pIndices = &dummyIndex;
		desc.m_nIndexSize = 0;
		desc.m_nFirstIndex = 0;
		desc.m_nOffset = 0;
		return true;
	}

	virtual void Unlock( int nWrittenIndexCount, IndexDesc_t& desc ) {}

	virtual void ModifyBegin( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc ) 
	{
		static unsigned short dummyIndex;
		desc.m_pIndices = &dummyIndex;
		desc.m_nIndexSize = 0;
		desc.m_nFirstIndex = 0;
		desc.m_nOffset = 0;
	}

	virtual void ModifyEnd( IndexDesc_t &desc ) {}
	virtual void Spew( int nIndexCount, const IndexDesc_t & desc ) {} 
	virtual void ValidateData( int nIndexCount, const IndexDesc_t &desc ) {}
	virtual bool IsDynamic() const 
	{
		return false;
	}

	virtual void BeginCastBuffer( MaterialIndexFormat_t format ) {}
	virtual void BeginCastBuffer( VertexFormat_t format ) {}
	virtual void EndCastBuffer( ) {}

	// Returns the number of vertices that can still be written into the buffer
	virtual int GetRoomRemaining() const { return 0; }

	virtual int IndexCount() const
	{
		return 0;
	}

	// returns the # of vertices (static meshes only)
	virtual int VertexCount() const
	{
		return 0;
	}

	// returns the vertex format
	virtual bool Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc )
	{
		static float dummyFloat[32];
		static unsigned char dummyChar[32];

		memset( &desc, 0, sizeof( desc ) );

		// Pointers to our current vertex data
		desc.m_pPosition = dummyFloat;
		desc.m_pBoneWeight = dummyFloat;
#ifdef NEW_SKINNING
		desc.m_pBoneMatrixIndex = dummyFloat;
#else
		desc.m_pBoneMatrixIndex = dummyChar;
#endif

		desc.m_pNormal = dummyFloat;
		desc.m_pColor = dummyChar;
		desc.m_pSpecular = dummyChar;
		for( int i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; i++ )
		{
			desc.m_pTexCoord[i] = dummyFloat;
		}

		desc.m_pTangentS = dummyFloat;
		desc.m_pTangentT = dummyFloat;
		desc.m_pWrinkle = dummyFloat;

		// user data
		desc.m_pUserData = dummyFloat;
		desc.m_nFirstVertex = 0;
		desc.m_nOffset = 0;
		return true;
	}

	virtual void Unlock( int nVertexCount, VertexDesc_t &desc ) {}
	virtual void Spew( int nVertexCount, const VertexDesc_t &desc ) {}
	virtual void ValidateData( int nVertexCount, const VertexDesc_t & desc ) {}

	// Sets/gets the primitive type
	virtual void SetPrimitiveType( MaterialPrimitiveType_t type )
	{
	}
	
	// Draws the mesh
	virtual void Draw( int nFirstIndex = -1, int nIndexCount = 0 )
	{
	}
	void DrawInstances( int nCount, const MeshInstanceData_t *pInstanceData )
	{
	}

	virtual void DrawModulated( const Vector4D &vecDiffuseModulation, int nFirstIndex = -1, int nIndexCount = 0 )
	{
	}

	virtual void SetColorMesh( IMesh *pColorMesh, int nVertexOffset )
	{
	}

	virtual void SetFlexMesh( IMesh *pMesh, int nVertexOffset )
	{
	}

	virtual void DisableFlexMesh( )
	{
	}

	// Draw a list of (lists of) primitives. Batching your lists together that use
	// the same lightmap, material, vertex and index buffers with multipass shaders
	// can drastically reduce state-switching overhead.
	// NOTE: this only works with STATIC meshes.
	virtual void Draw( CPrimList *pLists, int nLists )
	{
	}

	// Copy verts and/or indices to a mesh builder. This only works for temp meshes!
	virtual void CopyToMeshBuilder( 
		int iStartVert,		// Which vertices to copy.
		int nVerts, 
		int iStartIndex,	// Which indices to copy.
		int nIndices, 
		int indexOffset,	// This is added to each index.
		CMeshBuilder &builder )
	{
	}

	// Spews the mesh data
	virtual void Spew( int nVertexCount, int nIndexCount, const MeshDesc_t& desc )
	{
	}

	// Call this in debug mode to make sure our data is good.
	virtual void ValidateData( int nVertexCount, int nIndexCount, const MeshDesc_t& desc )
	{
	}

	virtual void MarkAsDrawn() {}

	virtual unsigned int ComputeMemoryUsed() { return 0; }

	virtual VertexFormat_t GetVertexFormat() const	
	{	
		return VERTEX_POSITION;
	}
	virtual MaterialIndexFormat_t IndexFormat() const	
	{	
		return MATERIAL_INDEX_FORMAT_16BIT;
	}
	virtual IMesh *GetMesh()
	{
		return this;
	}

	virtual void * AccessRawHardwareDataStream( uint8 nRawStreamIndex, uint32 numBytes, uint32 uiFlags, void *pvContext ) { return NULL; }

	virtual ICachedPerFrameMeshData *GetCachedPerFrameMeshData() { return NULL; }
	virtual void ReconstructFromCachedPerFrameMeshData( ICachedPerFrameMeshData *pData ) {}
};

// We allocate this dynamically because it uses a bunch of memory and we don't want to
// waste the memory unless we need to.
CDummyMesh *g_pDummyMesh = NULL;
CDummyMesh* GetDummyMesh()
{
	if ( !g_pDummyMesh )
	{
		g_pDummyMesh = new CDummyMesh;
	}

	return g_pDummyMesh;
}


// ---------------------------------------------------------------------------------------- //
// ITexture dummy implementation.
// ---------------------------------------------------------------------------------------- //

class CDummyTexture : public ITexture
{
public:
	// Various texture polling methods
	virtual const char *GetName( void ) const { return "DummyTexture"; }
	virtual int GetMappingWidth() const { return 512; }
	virtual int GetMappingHeight() const { return 512; }
	virtual int GetActualWidth() const { return 512; }
	virtual int GetActualHeight() const { return 512; }
	virtual int GetNumAnimationFrames() const { return 0; }
	virtual bool IsTranslucent() const { return false; }
	virtual bool IsMipmapped() const { return false; }

	virtual void GetLowResColorSample( float s, float t, float *color ) const {}

	// Gets texture resource data of the specified type.
	// Params:
	//		eDataType		type of resource to retrieve.
	//		pnumBytes		on return is the number of bytes available in the read-only data buffer or is undefined
	// Returns:
	//		pointer to the resource data, or NULL
	virtual void *GetResourceData( uint32 eDataType, size_t *pNumBytes ) const
	{
		return NULL;
	}


	// Methods associated with reference count
	virtual void IncrementReferenceCount( void ) {}
	virtual void DecrementReferenceCount( void ) {}

	// Used to modify the texture bits (procedural textures only)
	virtual void SetTextureRegenerator( ITextureRegenerator *pTextureRegen, bool releaseExisting = true ) {}

	// Reconstruct the texture bits in HW memory

	// If rect is not specified, reconstruct all bits, otherwise just reconstruct a subrect.
	virtual void Download( Rect_t *pRect = 0, int nAdditionalCreationFlags = 0 ) {}

	// Fast download without intermediate vtf texture copy
	virtual void Download( int nXOffset, int nYOffset, unsigned char *pData, int nWidth, int nHeight, ImageFormat srcFormat ) {}

	// Uses for stats. . .get the approximate size of the texture in it's current format.
	virtual int GetApproximateVidMemBytes( void ) const { return 64; }

	virtual bool IsError() const { return false; }

	virtual ITexture *GetEmbeddedTexture( int nIndex ) { return NULL; }

	// For volume textures
	virtual bool IsVolumeTexture() const { return false; }
	virtual int GetMappingDepth() const { return 1; }
	virtual int GetActualDepth() const { return 1; }

	virtual ImageFormat GetImageFormat() const { return IMAGE_FORMAT_RGBA8888; }

	// Various information about the texture
	virtual bool IsRenderTarget() const { return false; }
	virtual bool IsCubeMap() const { return false; }
	virtual bool IsNormalMap() const { return false; }
	virtual bool IsProcedural() const { return false; }
	virtual void DeleteIfUnreferenced() {}
	virtual bool IsDefaultPool() const { return false; }

	virtual void SwapContents( ITexture *pOther ) {}

	virtual unsigned int GetFlags( void ) const { return 0; }
	virtual void ForceLODOverride( int iNumLodsOverrideUpOrDown ) { NULL; }
	virtual void ForceExcludeOverride( int iExcludeOverride ) { NULL; }

	virtual void AddDownsizedSubTarget( const char *szName, int iDownsizePow2, MaterialRenderTargetDepth_t depth ) { NULL; }
	virtual void SetActiveSubTarget( const char *szName ) { NULL; }

#if defined( _X360 )
	virtual bool ClearTexture( int r, int g, int b, int a ) { return true; }
	virtual bool CreateRenderTargetSurface( int width, int height, ImageFormat format, bool bSameAsTexture, RTMultiSampleCount360_t multiSampleCount = RT_MULTISAMPLE_NONE ) { return true; }
#endif

	virtual int GetReferenceCount() const { return 0; }

	virtual bool IsTempExcluded() const { return false; }
	virtual bool CanBeTempExcluded() const { return false; }

	virtual bool FinishAsyncDownload( AsyncTextureContext_t *pContext, void *pData, int nNumReadBytes, bool bAbort, float flMaxTimeMs ) { return true; }

	virtual bool IsForceExcluded() const { return false; }
	virtual bool ClearForceExclusion() { return false; }
};

CDummyTexture g_DummyTexture;


// ---------------------------------------------------------------------------------------- //
// Dummy implementation of IMaterialVar.
// ---------------------------------------------------------------------------------------- //
static VMatrix g_DummyMatrix( 1,0,0,0,   0,1,0,0,   0,0,1,0,   0,0,0,1 );

class CDummyMaterialVar : public IMaterialVar
{
public:
	virtual char const *	GetName( void ) const { return "DummyMaterialVar"; }
	virtual MaterialVarSym_t	GetNameAsSymbol() const { return 0; }

	virtual void			SetFloatValue( float val ) {}
	virtual float			GetFloatValueInternal( void ) const { return 1; }
	
	virtual void			SetIntValue( int val ) {}
	virtual int				GetIntValueInternal( void ) const { return 1; }
	
	virtual void			SetStringValue( char const *val ) {}
	virtual char const *	GetStringValue( void ) const { return ""; }

	// Use FourCC values to pass app-defined data structures between
	// the proxy and the shader. The shader should ignore the data if
	// its FourCC type not correct.	
	virtual void			SetFourCCValue( FourCC type, void *pData ) {}
	virtual void			GetFourCCValue( FourCC *type, void **ppData ) {}

	// Vec (dim 2-4)
	virtual void			SetVecValue( float const* val, int numcomps ) {}
	virtual void			SetVecValue( float x, float y ) {}
	virtual void			SetVecValue( float x, float y, float z ) {}
	virtual void			SetVecValue( float x, float y, float z, float w ) {}
	virtual void			SetVecComponentValue( float fVal, int nComponent ) {}
	virtual void			GetVecValueInternal( float *val, int numcomps ) const
	{
		for ( int i=0; i < numcomps; i++ )
			val[i] = 1;
	}
	virtual void			GetLinearVecValue( float *val, int numcomps ) const
	{
		for ( int i=0; i < numcomps; i++ )
			val[i] = 1;
	}

	virtual float const*	GetVecValueInternal( ) const
	{
		static float val[4] = {1,1,1,1};
		return val;
	}

	virtual int				VectorSizeInternal() const
	{
		return 3;
	}

	// revisit: is this a good interface for textures?
	virtual ITexture *		GetTextureValue( void )
	{
		return &g_DummyTexture;
	}

	virtual bool IsTextureValueInternalEnvCubemap( void ) const
	{
		return false;
	}

	virtual void			SetTextureValue( ITexture * ) {}
	virtual					operator ITexture*()
	{
		return GetTextureValue();
	}

	virtual IMaterial *		GetMaterialValue( void )
	{
		extern IMaterial *g_pDummyMaterial;
		return g_pDummyMaterial;
	}

	virtual void			SetMaterialValue( IMaterial * ) {}

	virtual MaterialVarType_t	GetType() const { return MATERIAL_VAR_TYPE_INT; }
	virtual bool			IsDefined() const { return true; }
	virtual void			SetUndefined() {}

	// Matrix
	virtual void			SetMatrixValue( VMatrix const& matrix ) {}
	virtual const VMatrix  &GetMatrixValue( )
	{
		return g_DummyMatrix;
	}
	virtual bool			MatrixIsIdentity() const
	{
		return false;
	}

	// Copy....
	virtual void			CopyFrom( IMaterialVar *pMaterialVar ) {}

	virtual void			SetValueAutodetectType( char const *val ) {}

	virtual IMaterial *		GetOwningMaterial()
	{
		extern IMaterial *g_pDummyMaterial;
		return g_pDummyMaterial;
	}
};
CDummyMaterialVar g_DummyMaterialVar;


// ---------------------------------------------------------------------------------------- //
// Dummy implementation of IMaterialSystemHardwareConfig
// ---------------------------------------------------------------------------------------- //

class CDummyHardwareConfig : public IMaterialSystemHardwareConfig
{
public:
	virtual bool HasDestAlphaBuffer() const			{ return false; }
	virtual bool HasStencilBuffer() const			{ return false; }
	virtual int  StencilBufferBits() const			{ return 0;		}
	virtual int	 GetFrameBufferColorDepth() const	{ return 0; }
	virtual int  GetVertexSamplerCount() const		{ return 0; }
	virtual int  GetSamplerCount() const			{ return 0; }
	virtual bool HasSetDeviceGammaRamp() const		{ return false; }
	virtual bool SupportsCompressedTextures() const	{ return false; }
	virtual bool SupportsStaticControlFlow() const { return false; }
	virtual VertexCompressionType_t SupportsCompressedVertices() const { return VERTEX_COMPRESSION_NONE; }
	virtual int  MaximumAnisotropicLevel() const	{ return 1; }
	virtual int  MaxTextureWidth() const			{ return 0; }
	virtual int  MaxTextureHeight() const			{ return 0; }
	virtual int  MaxTextureDepth() const			{ return 0; }
	virtual int	 TextureMemorySize() const			{ return 0; }
	virtual bool SupportsMipmappedCubemaps() const	{ return 0; }

	// The number of texture stages represents the number of computations
	// we can do in the pixel pipeline, it is *not* related to the
	// simultaneous number of textures we can use
	virtual int	 NumVertexShaderConstants() const	{ return 0; }
	virtual int	 NumBooleanVertexShaderConstants() const	{ return 0; }
	virtual int	 NumIntegerVertexShaderConstants() const	{ return 0; }
	virtual int	 NumPixelShaderConstants() const	{ return 0; }
	virtual int	 MaxNumLights() const				{ return 0; }
	virtual int	 MaxTextureAspectRatio() const		{ return 0; }
	virtual int	 MaxVertexShaderBlendMatrices() const	{ return 0; }
	virtual int	 MaxUserClipPlanes() const			{ return 0; }
	virtual bool UseFastClipping() const			{ return false; }

	// This here should be the major item looked at when checking for compat
	// from anywhere other than the material system	shaders
	virtual int	 GetDXSupportLevel() const			{ return 90; }
	virtual const char *GetShaderDLLName() const	{ return NULL; }

	virtual bool ReadPixelsFromFrontBuffer() const	{ return false; }

	// Are dx dynamic textures preferred?
	virtual bool PreferDynamicTextures() const		{ return false; }

#ifdef _GAMECONSOLE
	// Vitaliy: need HDR to run with -noshaderapi on console
	virtual bool SupportsHDR() const				{ return true; }
	virtual HDRType_t GetHDRType() const			{ return HDR_TYPE_INTEGER; }
	virtual HDRType_t GetHardwareHDRType() const	{ return HDR_TYPE_INTEGER; }
#else
	virtual bool SupportsHDR() const				{ return false; }
	virtual HDRType_t GetHDRType() const			{ return HDR_TYPE_NONE; }
	virtual HDRType_t GetHardwareHDRType() const	{ return HDR_TYPE_NONE; }
#endif

	virtual bool NeedsAAClamp() const				{ return false; }
	virtual bool NeedsATICentroidHack() const		{ return false; }
	virtual bool SupportsStreamOffset() const		{ return false; }
	virtual int	 GetMaxDXSupportLevel() const		{ return 90; }
	virtual bool SpecifiesFogColorInLinearSpace() const { return false; }
	virtual bool SupportsSRGB() const				{ return false; }
	virtual bool FakeSRGBWrite() const				{ return false; }
	virtual bool CanDoSRGBReadFromRTs() const		{ return true; }
	virtual bool SupportsGLMixedSizeTargets() const	{ return false; }
	virtual bool IsAAEnabled() const				{ return false; }
	virtual int GetMaxVertexTextureDimension() const { return 0; }
	virtual int MaxViewports() const { return 1; }
	virtual void OverrideStreamOffsetSupport( bool bOverrideEnabled, bool bEnableSupport ) {}
	virtual ShadowFilterMode_t GetShadowFilterMode( bool bForceLowQualityShadows, bool bPS30 ) const { bForceLowQualityShadows; bPS30; return SHADOWFILTERMODE_DEFAULT; }
	virtual int NeedsShaderSRGBConversion() const { return 0; }
	bool UsesSRGBCorrectBlending() const { return false; }
	virtual bool HasFastVertexTextures() const { return false; }
	virtual bool ActualHasFastVertexTextures() const { return false; }
	virtual int MaxHWMorphBatchCount() const { return 0; }
#ifdef _GAMECONSOLE
	// Vitaliy: need HDR to run with -noshaderapi on console
	virtual bool SupportsHDRMode( HDRType_t nMode ) const { return nMode == HDR_TYPE_NONE || nMode == HDR_TYPE_INTEGER; }
#else
	virtual bool SupportsHDRMode( HDRType_t nMode ) const { return 0; }
#endif
	virtual bool IsDX10Card() const { return 0; }
	virtual bool GetHDREnabled( void ) const { return true; }
	virtual void SetHDREnabled( bool bEnable ) {}
	virtual bool SupportsBorderColor( void ) const { return true; }
	virtual bool SupportsFetch4( void ) const { return false; }
	virtual float GetShadowDepthBias() const { return 0.0f; }
	virtual float GetShadowSlopeScaleDepthBias() const { return 0.0f; }
	virtual bool PreferZPrepass( void ) const { return false; }
	virtual bool SuppressPixelShaderCentroidHackFixup() const { return true; }
	virtual bool PreferTexturesInHWMemory() const { return false; }
	virtual bool PreferHardwareSync() const { return false; }
	virtual bool SupportsShadowDepthTextures( void ) const { return false; }
	virtual ImageFormat GetShadowDepthTextureFormat( void ) const { return IMAGE_FORMAT_D16_SHADOW; }
	virtual ImageFormat GetHighPrecisionShadowDepthTextureFormat( void ) const { return IMAGE_FORMAT_D24X8_SHADOW; }
	virtual ImageFormat GetNullTextureFormat( void ) const  { return IMAGE_FORMAT_RGBA8888; }
	virtual int	GetMinDXSupportLevel() const { return 90; }
	virtual bool IsUnsupported() const { return false; }
	virtual float GetLightMapScaleFactor() const { return 1.0f; }
	virtual bool SupportsCascadedShadowMapping() const { return false; }
	virtual CSMQualityMode_t GetCSMQuality() const { return CSMQUALITY_VERY_LOW; }
	virtual bool SupportsBilinearPCFSampling() const { return true; }
	virtual CSMShaderMode_t GetCSMShaderMode( CSMQualityMode_t nQualityLevel ) const { nQualityLevel; return CSMSHADERMODE_LOW_OR_VERY_LOW; }
	virtual void SetCSMAccurateBlending( bool bEnable ) {}
	virtual bool GetCSMAccurateBlending( void ) const { return true; }
	virtual bool SupportsResolveDepth() const	{ return false; }
	virtual bool HasFullResolutionDepthTexture() const { return false; }

};
CDummyHardwareConfig g_DummyHardwareConfig;


// ---------------------------------------------------------------------------------------- //
// CDummyMaterial.
// ---------------------------------------------------------------------------------------- //

class CDummyMaterial : public IMaterial
{
public:
	virtual const char *	GetName() const { return "dummy material"; }
	virtual const char *	GetTextureGroupName() const { return "dummy group"; }

	virtual PreviewImageRetVal_t GetPreviewImageProperties( int *width, int *height, 
				 			ImageFormat *imageFormat, bool* isTranslucent ) const
	{
		if ( width )
			*width = 4;

		if ( height )
			*height = 4;

		if ( imageFormat )
			*imageFormat = IMAGE_FORMAT_RGBA8888;

		if ( isTranslucent )
			*isTranslucent = false;

		return MATERIAL_PREVIEW_IMAGE_OK;
	}
	
	virtual PreviewImageRetVal_t GetPreviewImage( unsigned char *data, 
												 int width, int height,
												 ImageFormat imageFormat ) const
	{
		return MATERIAL_PREVIEW_IMAGE_OK;
	}
											    
	// 
	virtual int				GetMappingWidth( )
	{
		return 512;
	}

	virtual int				GetMappingHeight( )
	{
		return 512;
	}

	virtual int				GetNumAnimationFrames( )
	{
		return 0;
	}

	virtual bool			InMaterialPage( void ) 
	{
		return false;
	}

	virtual void			GetMaterialOffset( float *pOffset  )
	{
		pOffset[0] = 0.0f;
		pOffset[1] = 0.0f;
	}

	virtual void			GetMaterialScale( float *pScale )
	{
		pScale[0] = 1.0f;
		pScale[1] = 1.0f;
	}

	virtual IMaterial			*GetMaterialPage( void )
	{
		return NULL;
	}

	virtual IMaterialVar *	FindVar( const char *varName, bool *found, bool complain = true )
	{
		if ( found )
			*found = true;

		return &g_DummyMaterialVar;
	}
	virtual IMaterialVar *	FindVarFast( const char *varName, unsigned int *pToken )
	{
		return NULL;
	}

	virtual void			IncrementReferenceCount( void )
	{
	}

	virtual void			DecrementReferenceCount( void )
	{
	}

	virtual int 			GetEnumerationID( void ) const
	{
		return 0;
	}

	virtual void			GetLowResColorSample( float s, float t, float *color ) const
	{
	}

	virtual void			RecomputeStateSnapshots()
	{
	}


	// Are we translucent?
	virtual bool			IsTranslucent()
	{
		return false;
	}
	virtual bool IsTranslucentUnderModulation( float flAlphaModulation ) const { return false; }

	// Are we alphatested?
	virtual bool			IsAlphaTested()
	{
		return false;
	}

	// Are we vertex lit?
	virtual bool			IsVertexLit()
	{
		return false;
	}

	// Gets the vertex format
	virtual VertexFormat_t	GetVertexFormat() const
	{
		return 0;
	}

	// returns true if this material uses a material proxy
	virtual bool			HasProxy( void ) const
	{
		return false;
	}
	virtual void			CallBindProxy( void*, ICallQueue * ) {}

	virtual bool			UsesEnvCubemap( void )
	{
		return false;
	}

	virtual bool			NeedsTangentSpace( void )
	{
		return false;
	}

	virtual bool			NeedsPowerOfTwoFrameBufferTexture( bool bCheckSpecificToThisFrame )
	{
		return false;
	}

	virtual bool			NeedsFullFrameBufferTexture( bool bCheckSpecificToThisFrame )
	{
		return false;
	}

	virtual bool			NeedsSoftwareSkinning( void )
	{
		return false;
	}

	// Apply constant color or alpha modulation
	virtual void			AlphaModulate( float alpha )
	{
	}

	virtual void			ColorModulate( float r, float g, float b )
	{
	}

	float					GetAlphaModulation( )
	{ 
		return 1;
	}

	void					GetColorModulation( float *r, float *g, float *b )
	{ 
		*r = *g = *b = 1;
	}

	// Material Var flags...
	virtual void			SetMaterialVarFlag( MaterialVarFlags_t flag, bool on )
	{
	}

	virtual bool			GetMaterialVarFlag( MaterialVarFlags_t flag ) const
	{
		return true;
	}


	// Gets material reflectivity
	virtual void			GetReflectivity( Vector& reflect )
	{
		reflect.Init(1,0,0);
	}


	// Gets material property flags
	virtual bool			GetPropertyFlag( MaterialPropertyTypes_t type )
	{
		return true;
	}

	// Is the material visible from both sides?
	virtual bool			IsTwoSided()
	{
		return false;
	}

	// Sets the shader associated with the material
	virtual void			SetShader( const char *pShaderName )
	{
	}

	// Can't be const because the material might have to precache itself.
	virtual int				GetNumPasses( void )
	{
		return 1;
	}

	// Can't be const because the material might have to precache itself.
	virtual int				GetTextureMemoryBytes( void )
	{
		return 64;
	}

	// Meant to be used with materials created using CreateMaterial
	// It updates the materials to reflect the current values stored in the material vars
	virtual void			Refresh()
	{
	}

	// GR - returns true is material uses lightmap alpha for blending
	virtual bool			NeedsLightmapBlendAlpha( void )
	{
		return false;
	}

	// returns true if the shader doesn't do lighting itself and requires
	// the data that is sent to it to be prelighted
	virtual bool			NeedsSoftwareLighting( void )
	{
		return false;
	}

	// Gets at the shader parameters
	virtual int				ShaderParamCount() const
	{
		return 0;
	}

	virtual IMaterialVar	**GetShaderParams( void )
	{
		return 0;
	}

	virtual bool IsErrorMaterial() const
	{
		return false;
	}
	virtual MorphFormat_t GetMorphFormat() const
	{
		return 0;
	}
	virtual void SetShaderAndParams( KeyValues *pKeyValues )
	{
	}
	virtual const char *GetShaderName() const { return "Wireframe"; }
		
	virtual void		DeleteIfUnreferenced() {}
	virtual bool IsSpriteCard() { return false; }

	virtual void			RefreshPreservingMaterialVars() {};

	virtual bool			WasReloadedFromWhitelist() {return false;}

	virtual bool			SetTempExcluded( bool bSet, int nExcludedDimensionLimit ) { return false; }

	virtual int				GetReferenceCount() const { return 0; }
};

CDummyMaterial g_DummyMaterial;
IMaterial *g_pDummyMaterial = &g_DummyMaterial;


void* DummyMaterialSystemFactory( const char *pName, int *pReturnCode )
{
	if ( stricmp( pName, MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION ) == 0 )
		return &g_DummyHardwareConfig;

	else
		return NULL;
}


// ---------------------------------------------------------------------------------------- //
// Dummy morph
// ---------------------------------------------------------------------------------------- //
class CDummyMorph : public IMorph
{
public:
	virtual void Lock( float flFloatToFixedScale ) {}
	virtual void AddMorph( const MorphVertexInfo_t &info ) {}
	virtual void Unlock(  ) {}
	virtual void AccumulateMorph( int nWeightCount, const MorphWeight_t* pWeights ) {}
};


// ---------------------------------------------------------------------------------------- //
// CDummyMaterialSystem.
// ---------------------------------------------------------------------------------------- //
class CDummyMaterialSystem : public IMaterialSystemStub, public CRefCounted1<IMatRenderContext, CRefCountServiceNull>
{
private:
	IMaterialSystem *m_pRealMaterialSystem;
public:
	CDummyMaterialSystem()
	{
		m_pRealMaterialSystem = 0;
	}

	virtual void	SetRealMaterialSystem( IMaterialSystem *pSys )
	{
		m_pRealMaterialSystem = pSys;
	}

	
	// Call this to initialize the material system
	// returns a method to create interfaces in the shader dll
	virtual CreateInterfaceFn	Init( char const* pShaderDLL, 
									  IMaterialProxyFactory *pMaterialProxyFactory,
									  CreateInterfaceFn fileSystemFactory,
									  CreateInterfaceFn cvarFactory )
	{
		return DummyMaterialSystemFactory;
	}

	virtual void				Shutdown( )
	{
	}

	virtual IMaterialSystemHardwareConfig *GetHardwareConfig( const char *pVersion, int *returnCode )
	{
		if ( returnCode )
			*returnCode = 1;

		return &g_DummyHardwareConfig;
	}

	// Gets the number of adapters...
	virtual int					GetDisplayAdapterCount() const
	{
		return 0;
	}

	// Returns info about each adapter
	virtual void				GetDisplayAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const
	{
	}

	// Returns the number of modes
	virtual int					GetModeCount( int adapter ) const
	{
		return 0;
	}

	// Returns mode information..
	virtual void				GetModeInfo( int adapter, int mode, MaterialVideoMode_t& info ) const
	{
	}

	// Returns the mode info for the current display device
	virtual void				GetDisplayMode( MaterialVideoMode_t& mode ) const
	{
	}
 
	// Sets the mode...
	virtual bool				SetMode( void* hwnd, const MaterialSystem_Config_t &config )
	{
		return true;
	}

	// Creates/ destroys a child window
	virtual bool				AddView( void* hwnd )
	{
		return false;
	}
	virtual void				RemoveView( void* hwnd )
	{
	}

	// Sets the view
	virtual void				SetView( void* hwnd )
	{
	}

	// return true if lightmaps need to be redownloaded
	// Call this before rendering each frame with the current config
	// for the material system.
	// Will do whatever is necessary to get the material system into the correct state
	// upon configuration change. .doesn't much else otherwise.
	virtual bool				UpdateConfig( bool forceUpdate )
	{
		return false;
	}
	
	virtual bool				OverrideConfig( const MaterialSystem_Config_t &config, bool bForceUpdate )
	{
		return false;
	}

	// This is the interface for knowing what materials are available
	// is to use the following functions to get a list of materials.  The
	// material names will have the full path to the material, and that is the 
	// only way that the directory structure of the materials will be seen through this
	// interface.
	// NOTE:  This is mostly for worldcraft to get a list of materials to put
	// in the "texture" browser.in Worldcraft
	virtual MaterialHandle_t	FirstMaterial() const
	{
		return 0;
	}

	// returns InvalidMaterial if there isn't another material.
	// WARNING: you must call GetNextMaterial until it returns NULL, 
	// otherwise there will be a memory leak.
	virtual MaterialHandle_t	NextMaterial( MaterialHandle_t h ) const
	{
		return 0;
	}

	// This is the invalid material
	virtual MaterialHandle_t	InvalidMaterial() const
	{
		if ( m_pRealMaterialSystem )
			return m_pRealMaterialSystem->InvalidMaterial();
		else
			return 0;
	}

	// Returns a particular material
	virtual IMaterial*			GetMaterial( MaterialHandle_t h ) const
	{
		if ( m_pRealMaterialSystem )
			return m_pRealMaterialSystem->GetMaterial( h );
		else
			return &g_DummyMaterial;
	}

	// Find a material by name.
	// The name of a material is a full path to 
	// the vmt file starting from "hl2/materials" (or equivalent) without
	// a file extension.
	// eg. "dev/dev_bumptest" refers to somethign similar to:
	// "d:/hl2/hl2/materials/dev/dev_bumptest.vmt"
	virtual IMaterial *FindMaterial( char const* pMaterialName, const char *pTextureGroupName, bool complain = true, const char *pComplainPrefix = NULL )
	{
		if ( m_pRealMaterialSystem )
			return m_pRealMaterialSystem->FindMaterial( pMaterialName, pTextureGroupName, complain, pComplainPrefix );
		return &g_DummyMaterial;
	}

	virtual IMaterial *FindProceduralMaterial( const char *pMaterialName, const char *pTextureGroupName, KeyValues *pVMTKeyValues )
	{
		if ( m_pRealMaterialSystem )
			return m_pRealMaterialSystem->FindProceduralMaterial( pMaterialName, pTextureGroupName, pVMTKeyValues );
		return &g_DummyMaterial;
	}

	virtual bool LoadKeyValuesFromVMTFile( KeyValues &vmtKeyValues, const char *pMaterialName, bool bUsesUNCFilename  )
	{
		if ( m_pRealMaterialSystem )
			return m_pRealMaterialSystem->LoadKeyValuesFromVMTFile( vmtKeyValues, pMaterialName, bUsesUNCFilename );
		return true;
	}


	virtual ITexture *FindTexture( char const* pTextureName, const char *pTextureGroupName, bool complain = true, int nAdditionalCreationFlags = 0)
	{
		if ( m_pRealMaterialSystem )
			return m_pRealMaterialSystem->FindTexture( pTextureName, pTextureGroupName, complain, nAdditionalCreationFlags );
		return &g_DummyTexture;
	}

	virtual void BindLocalCubemap( ITexture *pTexture )
	{
	}
	virtual ITexture *GetLocalCubemap( )
	{
		return &g_DummyTexture;
	}
	
	// pass in an ITexture (that is build with "rendertarget" "1") or
	// pass in NULL for the regular backbuffer.
	virtual void				SetRenderTarget( ITexture *pTexture )
	{
	}
	
	virtual ITexture *			GetRenderTarget( void )
	{
		return &g_DummyTexture;
	}
	
	virtual void				SetRenderTargetEx( int nRenderTargetID, ITexture *pTexture )
	{
	}
	
	virtual ITexture *			GetRenderTargetEx( int nRenderTargetID )
	{
		return &g_DummyTexture;
	}
	virtual void				GetRenderTargetDimensions( int &width, int &height) const
	{
		width = 256;
		height = 256;
	}
	
	// Get the total number of materials in the system.  These aren't just the used
	// materials, but the complete collection.
	virtual int					GetNumMaterials( ) const
	{
		return m_pRealMaterialSystem->GetNumMaterials();
	}

	// Remove any materials from memory that aren't in use as determined
	// by the IMaterial's reference count.
	virtual void				UncacheUnusedMaterials( bool bRecomputeStateSnapshots )
	{
		if ( m_pRealMaterialSystem )
		{
			m_pRealMaterialSystem->UncacheUnusedMaterials( bRecomputeStateSnapshots );
		}
	}

	// uncache all materials. .  good for forcing reload of materials.
	virtual void				UncacheAllMaterials( )
	{
		if ( m_pRealMaterialSystem )
			m_pRealMaterialSystem->UncacheAllMaterials();
	}

	// Load any materials into memory that are to be used as determined
	// by the IMaterial's reference count.
	virtual void				CacheUsedMaterials( )
	{
		if ( m_pRealMaterialSystem )
			m_pRealMaterialSystem->CacheUsedMaterials( );
	}
	
	// Force all textures to be reloaded from disk.
	virtual void				ReloadTextures( )
	{
	}
	
	// Allows us to override the depth buffer setting of a material
	virtual void	OverrideDepthEnable( bool bEnable, bool bDepthWriteEnable, bool bDepthTestEnable = true )
	{
	}

	virtual void	OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable )
	{
	}

	virtual void	OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable )
	{
	}

	//
	// lightmap allocation stuff
	//

	// To allocate lightmaps, sort the whole world by material twice.
	// The first time through, call AllocateLightmap for every surface.
	// that has a lightmap.
	// The second time through, call AllocateWhiteLightmap for every 
	// surface that expects to use shaders that expect lightmaps.
	virtual void				BeginLightmapAllocation( )
	{
	}
	// returns the sorting id for this surface
	virtual int 				AllocateLightmap( int width, int height, 
		                                          int offsetIntoLightmapPage[2],
												  IMaterial *pMaterial )
	{
		return 0;
	}
	// returns a lightmap page ID for this allocation, -1 if none available
	virtual int	AllocateDynamicLightmap( int lightmapSize[2], int *pOutOffsetIntoPage, int frameID )
	{
		return -1;
	}

	// returns the sorting id for this surface
	virtual int					AllocateWhiteLightmap( IMaterial *pMaterial )
	{
		return 0;
	}
	virtual void				EndLightmapAllocation( )
	{
	}

	virtual void				CleanupLightmaps()
	{
	}

	// lightmaps are in linear color space
	// lightmapPageID is returned by GetLightmapPageIDForSortID
	// lightmapSize and offsetIntoLightmapPage are returned by AllocateLightmap.
	// You should never call UpdateLightmap for a lightmap allocated through
	// AllocateWhiteLightmap.
	virtual void				UpdateLightmap( int lightmapPageID, int lightmapSize[2],
												int offsetIntoLightmapPage[2], 
												float *pFloatImage, float *pFloatImageBump1,
												float *pFloatImageBump2, float *pFloatImageBump3 )
	{
	}
	// Force the lightmaps updated with UpdateLightmap to be sent to the hardware.
	virtual void				FlushLightmaps( )
	{
	}

	// fixme: could just be an array of ints for lightmapPageIDs since the material
	// for a surface is already known.
	virtual int					GetNumSortIDs( )
	{
		return 10;
	}
//	virtual int					GetLightmapPageIDForSortID( int sortID ) = 0;
	virtual void				GetSortInfo( MaterialSystem_SortInfo_t *pSortInfoArray )
	{
	}

	virtual void				BeginFrame( float )
	{
	}
	virtual void				EndFrame( )
	{
	}
	virtual bool				IsInFrame() const { return false; }

	virtual uint32				GetCurrentFrameCount() { return 0; }

	// Bind a material is current for rendering.
	virtual void				Bind( IMaterial *material, void *proxyData = 0 )
	{
	}
	// Bind a lightmap page current for rendering.  You only have to 
	// do this for materials that require lightmaps.
	virtual void				BindLightmapPage( int lightmapPageID )
	{
	}

	// inputs are between 0 and 1
	virtual void				DepthRange( float zNear, float zFar )
	{
	}

	virtual void				ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil )
	{
	}

	virtual void				ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth )
	{
	}

	virtual void				ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth )
	{
	}

	virtual void				PerformFullScreenStencilOperation( void )
	{
	}

	// read to a unsigned char rgb image.
	virtual void				ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat, ITexture *pRenderTargetTexture = NULL )
	{
	}

	virtual void				ReadPixelsAsync( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat, ITexture *pRenderTargetTexture = NULL, CThreadEvent *pPixelsReadEvent = NULL )
	{
	}

	virtual void				ReadPixelsAsyncGetResult( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat, CThreadEvent *pGetResultEvent = NULL )
	{
	}

	// Read w/ stretch to a host-memory buffer
	virtual void				ReadPixelsAndStretch( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *pBuffer, ImageFormat dstFormat, int nDstStride )
	{
	}

	// Sets lighting
	virtual void				SetLightingState( const MaterialLightingState_t &state )
	{
	}
	virtual void				SetLights( int nCount, const LightDesc_t *pDesc )
	{
	}
	virtual void				SetLightingOrigin( Vector vLightingOrigin )
	{
	}

	// The faces of the cube are specified in the same order as cubemap textures
	virtual void				SetAmbientLightCube( Vector4D cube[6] )
	{
	}
	
	// Blit the backbuffer to the framebuffer texture
	virtual void				CopyRenderTargetToTexture( ITexture * )
	{
	}
	
	virtual void				SetFrameBufferCopyTexture( ITexture *pTexture, int textureIndex )
	{
	}

	virtual	ITexture *          GetFrameBufferCopyTexture( int textureIndex )
	{
		return &g_DummyTexture;
	}

	// do we need this?
	virtual void				Flush( bool flushHardware = false )
	{
	}

	//
	// end vertex array api
	//

	//
	// Debugging tools
	//
	virtual void				DebugPrintUsedMaterials( const char *pSearchSubString, bool bVerbose )
	{
	}
	virtual void				DebugPrintAspectRatioInfo( const char *pSearchSubString, bool bVerbose )
	{
	}
	virtual void				DebugPrintUsedTextures( void )
	{
	}
	virtual void				ToggleSuppressMaterial( char const* pMaterialName )
	{
	}
	virtual void				ToggleDebugMaterial( char const* pMaterialName )
	{
	}

	// matrix api
	virtual void				MatrixMode( MaterialMatrixMode_t matrixMode )
	{
	}
	virtual void				PushMatrix( void )
	{
	}
	virtual void				PopMatrix( void )
	{
	}
/*
	virtual void				LoadMatrix( float * )
	{
	}
*/
	// Methods that use VMatrix
	virtual void		LoadMatrix( const VMatrix& matrix )
	{
	}

	virtual void		LoadMatrix( const matrix3x4_t& matrix )
	{
	}

	virtual void		LoadBoneMatrix( int boneIndex, const matrix3x4_t& matrix )
	{
	}

	virtual void		MultMatrix( const VMatrix& matrix )
	{
	}

	virtual void		MultMatrix( const matrix3x4_t& matrix )
	{
	}
	virtual void		MultMatrixLocal( const VMatrix& matrix )
	{
	}

	virtual void		MultMatrixLocal( const matrix3x4_t& matrix )
	{
	}
	virtual void				GetMatrix( MaterialMatrixMode_t matrixMode, VMatrix *pMatrix )
	{
		pMatrix->Identity();
	}
	virtual void				GetMatrix( MaterialMatrixMode_t matrixMode, matrix3x4_t *pMatrix )
	{
		SetIdentityMatrix( *pMatrix );
	}
	virtual void				LoadIdentity( void )
	{
	}
	virtual void				Ortho( double left, double top, double right, double bottom, double zNear, double zFar )
	{
	}
	virtual void				PerspectiveX( double fovx, double aspect, double zNear, double zFar )
	{
	}
	virtual void				PickMatrix( int x, int y, int width, int height )
	{
	}
	virtual void				Rotate( float angle, float x, float y, float z )
	{
	}
	virtual void				Translate( float x, float y, float z )
	{
	}
	virtual void				Scale( float x, float y, float z )
	{
	}
	// end matrix api

	// Sets/gets the viewport
	virtual void				Viewport( int x, int y, int width, int height )
	{
	}
	virtual void				GetViewport( int& x, int& y, int& width, int& height ) const
	{
		x = y = 0;
		width = height = 640;
	}

	// The cull mode
	virtual void				CullMode( MaterialCullMode_t cullMode )
	{
	}

	virtual void				FlipCullMode( void )
	{
	}

	virtual void BeginGeneratingCSMs()
	{
	}

	virtual void EndGeneratingCSMs()
	{

	}

	virtual void PerpareForCascadeDraw( int cascade, float fShadowSlopeScaleDepthBias, float fShadowDepthBias )
	{		
	}

	// end matrix api

	// Force writes only when z matches. . . useful for stenciling things out
	// by rendering the desired Z values ahead of time.
//	virtual void				ForceDepthFuncEquals( bool bEnable ) = 0;
//	virtual void				RenderZOnlyWithHeightClip( bool bEnable ) = 0;
	// This could easily be extended to a general user clip plane
	virtual void				SetHeightClipMode( MaterialHeightClipMode_t nClipMode )
	{
	}
	virtual MaterialHeightClipMode_t GetHeightClipMode( )
	{
		return MATERIAL_HEIGHTCLIPMODE_DISABLE;
	}
	// garymcthack : fog z is always used for heightclipz for now.
	virtual void				SetHeightClipZ( float z )
	{
	}
	
	// Fog methods...
	virtual void				FogMode( MaterialFogMode_t fogMode )
	{
	}
	MaterialFogMode_t			GetFogMode( void )
	{
		return MATERIAL_FOG_NONE;
	}
	virtual void				FogStart( float fStart )
	{
	}
	virtual void				FogEnd( float fEnd )
	{
	}
	virtual void				FogMaxDensity( float flMaxDensity )
	{
	}

	virtual void				SetFogZ( float fogZ )
	{
	}
	virtual void				GetFogDistances( float *fStart, float *fEnd, float *fFogZ )
	{
	}

	virtual void				FogColor3f( float r, float g, float b )
	{
	}
	virtual void				FogColor3fv( float const* rgb )
	{
	}
	virtual void				FogColor3ub( unsigned char r, unsigned char g, unsigned char b )
	{
	}
	virtual void				FogColor3ubv( unsigned char const* rgb )
	{
	}

	virtual void				GetFogColor( unsigned char *rgb )
	{
	}

	// Sets the number of bones for skinning
	virtual void				SetNumBoneWeights( int numBones ) 
	{
	}
	virtual IMaterialProxyFactory *GetMaterialProxyFactory()
	{
		return NULL;
	}
	
	virtual void	SetMaterialProxyFactory( IMaterialProxyFactory* pFactory )
	{
	}

	virtual IClientMaterialSystem*	GetClientMaterialSystemInterface()
	{
		return NULL;
	}

	// Read the page size of an existing lightmap by sort id (returned from AllocateLightmap())
	virtual void				GetLightmapPageSize( int lightmap, int *width, int *height ) const
	{
		if ( m_pRealMaterialSystem )
			m_pRealMaterialSystem->GetLightmapPageSize( lightmap, width, height );
		else
			*width = *height = 32;
	}
	
	virtual int					GetNumLightmapPages() const
	{
		return 0;
	}

	/// FIXME: This stuff needs to be cleaned up and abstracted.
	// Stuff that gets exported to the launcher through the engine
	virtual void				SwapBuffers( )
	{
	}

	// Use this to spew information about the 3D layer 
	virtual void				SpewDriverInfo() const
	{
	}

	// Creates/destroys Mesh
	virtual IMesh* CreateStaticMesh( VertexFormat_t fmt, const char *pTextureBudgetGroup, IMaterial * pMaterial, VertexStreamSpec_t *pStreamSpec )
	{
		return GetDummyMesh();
	}
	virtual void DestroyStaticMesh( IMesh* mesh )
	{
	}

	// Gets the dynamic mesh associated with the currently bound material
	// note that you've got to render the mesh before calling this function 
	// a second time. Clients should *not* call DestroyStaticMesh on the mesh 
	// returned by this call.
	// Use buffered = false if you want to not have the mesh be buffered,
	// but use it instead in the following pattern:
	//		meshBuilder.Begin
	//		meshBuilder.End
	//		Draw partial
	//		Draw partial
	//		Draw partial
	//		meshBuilder.Begin
	//		meshBuilder.End
	//		etc
	// Use Vertex or Index Override to supply a static vertex or index buffer
	// to use in place of the dynamic buffers.
	//
	// If you pass in a material in pAutoBind, it will automatically bind the
	// material. This can be helpful since you must bind the material you're
	// going to use BEFORE calling GetDynamicMesh.
	virtual IMesh* GetDynamicMesh( bool bBuffered = true, IMesh* pVertexOverride = 0,	
		IMesh* pIndexOverride = 0, IMaterial *pAutoBind = 0 )
	{
		return GetDummyMesh();
	}

	virtual IMesh* GetDynamicMeshEx( VertexFormat_t vertexFormat, bool bBuffered = true, 
		IMesh* pVertexOverride = 0,	IMesh* pIndexOverride = 0, IMaterial *pAutoBind = 0 )
	{
		return GetDummyMesh();
	}

	virtual IMesh *GetFlexMesh()
	{
		return GetDummyMesh();
	}
		
	// Selection mode methods
	virtual int  SelectionMode( bool selectionMode )
	{
		return 0;
	}
	virtual void SelectionBuffer( unsigned int* pBuffer, int size )
	{
	}
	virtual void ClearSelectionNames( )
	{
	}
	virtual void LoadSelectionName( int name )
	{
	}
	virtual void PushSelectionName( int name )
	{
	}
	virtual void PopSelectionName()
	{
	}
	
	// Installs a function to be called when we need to release vertex buffers + textures
	virtual void AddReleaseFunc( MaterialBufferReleaseFunc_t func )
	{
	}
	virtual void RemoveReleaseFunc( MaterialBufferReleaseFunc_t func )
	{
	}

	// Installs a function to be called when we need to restore vertex buffers
	virtual void AddRestoreFunc( MaterialBufferRestoreFunc_t func )
	{
	}
	virtual void RemoveRestoreFunc( MaterialBufferRestoreFunc_t func )
	{
	}

	// Installs a function to be called when we need to delete objects at the end of the render frame
	virtual void AddEndFrameCleanupFunc( EndFrameCleanupFunc_t func )
	{
	}

	virtual void RemoveEndFrameCleanupFunc( EndFrameCleanupFunc_t func )
	{
	}

	// Gets called when the level is shuts down, will call the registered callback
	virtual void				OnLevelShutdown()
	{
	}

	// Installs a function to be called when the level is shuts down
	virtual bool				AddOnLevelShutdownFunc( OnLevelShutdownFunc_t func, void * pUserData )
	{
		return false;
	}
	virtual bool				RemoveOnLevelShutdownFunc( OnLevelShutdownFunc_t func, void * pUserData )
	{
		return false;
	}

	virtual void				OnLevelLoadingComplete()
	{
	}

	virtual void				AddEndFramePriorToNextContextFunc( EndFramePriorToNextContextFunc_t func )
	{

	}

	virtual void				RemoveEndFramePriorToNextContextFunc( EndFramePriorToNextContextFunc_t func )
	{

	}

	// Stuff for probing properties of shaders.
	virtual int					GetNumShaders( void ) const 
	{
		return 0;
	}
	virtual const char *		GetShaderName( int shaderID ) const
	{
		return NULL;
	}
	virtual int					GetNumShaderParams( int shaderID ) const
	{
		return 0;
	}
	virtual const char *		GetShaderParamName( int shaderID, int paramID ) const
	{
		return NULL;
	}
	virtual const char *		GetShaderParamHelp( int shaderID, int paramID ) const
	{
		return NULL;
	}
	virtual ShaderParamType_t	GetShaderParamType( int shaderID, int paramID ) const
	{
		return ( enum ShaderParamType_t )0;
	}
	virtual const char *		GetShaderParamDefault( int shaderID, int paramID ) const
	{
		return NULL;
	}

	// Reloads materials
	virtual void	ReloadMaterials( const char *pSubString = NULL )
	{
	}

	virtual void	ResetMaterialLightmapPageInfo()
	{
	}

	// -----------------------------------------------------------
	// Stereo
	// -----------------------------------------------------------
	virtual bool IsStereoSupported()
	{
		return false;
	}

	virtual bool IsStereoActiveThisFrame() const
	{
		return false;
	}

	virtual void NVStereoUpdate()
	{
	}

	virtual ITexture* CreateRenderTargetTexture( 
		int w, 
		int h, 
		RenderTargetSizeMode_t sizeMode,	// Controls how size is generated (and regenerated on video mode change).
		ImageFormat format, 
		MaterialRenderTargetDepth_t depth )
	{
		return &g_DummyTexture;
	}

	virtual ITexture *CreateProceduralTexture( 
		const char			*pTextureName, 
		const char			*pTextureGroupName, 
		int					w, 
		int					h, 
		ImageFormat			fmt, 
		int					nFlags )
	{
		return &g_DummyTexture;
	}

	virtual ICustomMaterialManager *GetCustomMaterialManager()
	{
		return m_pRealMaterialSystem->GetCustomMaterialManager();
	}

	virtual ICompositeTextureGenerator *GetCompositeTextureGenerator()
	{
		return m_pRealMaterialSystem->GetCompositeTextureGenerator();
	}

#if defined( _X360 )

	virtual ITexture *CreateGamerpicTexture(
		const char			*pTextureName,
		const char			*pTextureGroupName,
		int					nFlags )
	{
		return &g_DummyTexture;
	}

	virtual bool UpdateLocalGamerpicTexture(
		ITexture			*pTexture,
		DWORD				userIndex )
	{
		return true;
	}

	virtual bool UpdateRemoteGamerpicTexture(
		ITexture			*pTexture,
		XUID				xuid )
	{
		return true;
	}

#endif // _X360

	// Sets the Clear Color for ClearBuffer....
	virtual void ClearColor3ub( unsigned char r, unsigned char g, unsigned char b )
	{
	}
	virtual void ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a )
	{
	}
	virtual void SetInStubMode( bool b )
	{
	}

	// Create new materials
	virtual IMaterial	*CreateMaterial( const char *pMaterialName, KeyValues *pVMTKeyValues )
	{
		return &g_DummyMaterial;
	}

	void GetBackBufferDimensions( int &w, int &h ) const
	{
		if ( IsPC() )
		{
			w = 1024;
			h = 768;
		}
		else
		{
			w = 640;
			h = 480;
		}
	}
	
	ImageFormat GetBackBufferFormat( void ) const
	{
		return IMAGE_FORMAT_RGBA8888;
	}
	
	virtual const AspectRatioInfo_t &GetAspectRatioInfo( void ) const
	{ 
		static AspectRatioInfo_t dummy;
		return dummy; 
	}

	// FIXME: This is a hack required for NVidia/XBox, can they fix in drivers?
	virtual void	DrawScreenSpaceQuad( IMaterial* pMaterial ) {}

	// FIXME: Test interface
	virtual bool Connect( CreateInterfaceFn factory ) { return true; }
	virtual void Disconnect() {}
	virtual void *QueryInterface( const char *pInterfaceName ) { return NULL; }
	virtual const AppSystemInfo_t *GetDependencies( ) { return NULL; }
	virtual AppSystemTier_t GetTier() { return APP_SYSTEM_TIER2; }
	virtual InitReturnVal_t Init() { return INIT_OK; }
	virtual void Reconnect( CreateInterfaceFn factory, const char *pInterfaceName ) {}
	virtual void SetShaderAPI( const char *pShaderAPIDLL ) {}
	virtual void SetAdapter( int nAdapter, int nFlags ) {}

	// Release temporary HW memory...
	virtual void ResetTempHWMemory( bool bExitingLevel ) {}
	virtual ITexture*	CreateNamedRenderTargetTextureEx( 
		const char *pRTName,				// Pass in NULL here for an unnamed render target.
		int w, 
		int h, 
		RenderTargetSizeMode_t sizeMode,	// Controls how size is generated (and regenerated on video mode change).
		ImageFormat format, 
		MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED, 
		unsigned int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT,
		unsigned int renderTargetFlags = 0
		)
	{
		return &g_DummyTexture;
	}
	virtual ITexture* CreateNamedRenderTargetTexture( 
		const char *pRTName, 
		int w, 
		int h, 
		RenderTargetSizeMode_t sizeMode,	// Controls how size is generated (and regenerated on video mode change).
		ImageFormat format, 
		MaterialRenderTargetDepth_t depth,
		bool bClampTexCoords, 
		bool bAutoMipMap
		)
	{
		return &g_DummyTexture;
	}
	virtual void SyncToken( const char *pToken ) {}
	virtual float	ComputePixelWidthOfSphere( const Vector& origin, float flRadius )
	{
		return 1.0f;
	}
	virtual float	ComputePixelDiameterOfSphere( const Vector& origin, float flRadius )
	{
		return 1.0f;
	}

	OcclusionQueryObjectHandle_t CreateOcclusionQueryObject( void )
	{
		return INVALID_OCCLUSION_QUERY_OBJECT_HANDLE;
	}

	void DestroyOcclusionQueryObject( OcclusionQueryObjectHandle_t handle )
	{
	}

	void ResetOcclusionQueryObject( OcclusionQueryObjectHandle_t hOcclusionQuery ) {}

	void BeginOcclusionQueryDrawing( OcclusionQueryObjectHandle_t handle )
	{
	}

	void EndOcclusionQueryDrawing( OcclusionQueryObjectHandle_t handle )
	{
	}

	int OcclusionQuery_GetNumPixelsRendered( OcclusionQueryObjectHandle_t handle )
	{
		return 0;
	}
	virtual void SetFlashlightMode( bool )
	{
	}
	virtual void SetRenderingPaint( bool bEnable ) {}
	virtual bool IsRenderingPaint() const { return false; }

	virtual bool GetFlashlightMode( void ) const
	{
		return false;
	}
		
	virtual bool IsCullingEnabledForSinglePassFlashlight() const 
	{
		return false;
	}

	virtual void EnableCullingForSinglePassFlashlight( bool bEnable ) {}

	virtual bool InFlashlightMode( void ) const
	{
		return false;
	}
	virtual void SetFlashlightState( const FlashlightState_t &state, const VMatrix &worldToTexture )
	{
	}
	virtual void SetFlashlightStateEx( const FlashlightState_t &state, const VMatrix &worldToTexture, ITexture *pFlashlightDepthTexture )
	{
	}
	
	virtual bool IsCascadedShadowMapping() const
	{
		return false;
	}
	
	virtual void SetCascadedShadowMapping( bool bEnable )
	{
		bEnable;
	}

	virtual void SetCascadedShadowMappingState( const CascadedShadowMappingState_t &state, ITexture *pDepthTextureAtlas )
	{
		state, pDepthTextureAtlas;
	}
	
	virtual void PushScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom )
	{
	}

	virtual void PopScissorRect()
	{
	}

	virtual void PushDeformation( DeformationBase_t const *Deformation )
	{
	}

	virtual void PopDeformation( )
	{
	}

	virtual int GetNumActiveDeformations() const
	{
		return 0;
	}



	// Get the current config for this video card (as last set by control panel or the default if not)
	virtual const MaterialSystem_Config_t &GetCurrentConfigForVideoCard() const
	{
		static MaterialSystem_Config_t dummy;
		return dummy;
	}

	// Get video card identitier
	virtual const MaterialSystemHardwareIdentifier_t &GetVideoCardIdentifier( void ) const
	{
		static MaterialSystemHardwareIdentifier_t dummy;
		return dummy;
	}
	virtual void AddModeChangeCallBack( ModeChangeCallbackFunc_t func )
	{
	}
	virtual void RemoveModeChangeCallBack( ModeChangeCallbackFunc_t func )
	{
	}
	virtual bool GetRecommendedVideoConfig( KeyValues *pKeyValues )
	{
		return false;
	}
	virtual bool GetRecommendedConfigurationInfo( int nDxLevel, KeyValues *pKeyValues )
	{
		return false;
	}

	virtual void EnableUserClipTransformOverride( bool bEnable )
	{
	}

	virtual void UserClipTransform( const VMatrix &worldToProjection )
	{
	}

	// Used to iterate over all shaders for editing purposes
	virtual int	 ShaderCount() const
	{
		return 0;
	}

	virtual int  GetShaders( int nFirstShader, int nCount, IShader **ppShaderList ) const
	{
		return 0;
	}

	// Used to enable editor materials. Must be called before Init.
	virtual void	EnableEditorMaterials()
	{
	}
	virtual void	EnableGBuffers()
	{
	}

	// Used to enable editor materials. Must be called before Init.
	virtual int		GetCurrentAdapter()	const
	{
		return 0;
	}

	// Creates/destroys morph data associated w/ a particular material
	IMorph *CreateMorph( MorphFormat_t, const char *pDebugName )
	{
		static CDummyMorph s_DummyMorph;
		return &s_DummyMorph;
	}

	void DestroyMorph( IMorph *pMorph )
	{
	}

	void BindMorph( IMorph *pMorph )
	{
	}

	// Sets morph target factors
	virtual void SetMorphTargetFactors( int nTargetId, float *pValue, int nCount )
	{
	}

	virtual void SetToneMappingScaleLinear( const Vector &scale )
	{
	}

	virtual void EvictManagedResources()
	{
	}

	// Gets the window size
	virtual void	GetWindowSize( int &width, int &height ) const
	{
		width = height = 0;
		if ( m_pRealMaterialSystem )
		{
			CMatRenderContextPtr pRenderContext( m_pRealMaterialSystem );
			pRenderContext->GetWindowSize(width, height);
		}
	}

	// For dealing with device lost in cases where SwapBuffers isn't called all the time (Hammer)
	virtual void HandleDeviceLost()
	{
	}

	virtual void AppUsesRenderTargets()
	{
	}

	virtual void DrawScreenSpaceRectangle( 
		IMaterial *pMaterial,
		int destx, int desty,
		int width, int height,
		float src_texture_x0, float src_texture_y0,
		float src_texture_x1, float src_texture_y1,	
		int src_texture_width, int src_texture_height,
		void *pClientRenderable = NULL,
		int nXDice = 1,
		int nYDice = 1 )
	{
	}

	virtual void BeginRenderTargetAllocation()
	{
	}

	// Simulate an Alt-Tab in here, which causes a release/restore of all resources
	virtual void EndRenderTargetAllocation()
	{
	}

	void FinishRenderTargetAllocation( void )
	{
	}
	
	void ReEnableRenderTargetAllocation_IRealizeIfICallThisAllTexturesWillBeUnloadedAndLoadTimeWillSufferHorribly( void )
	{
	}


	ITexture *CreateNamedRenderTargetTextureEx2( 
		const char *pRTName,				// Pass in NULL here for an unnamed render target.
		int w, 
		int h, 
		RenderTargetSizeMode_t sizeMode,	// Controls how size is generated (and regenerated on video mode change).
		ImageFormat format, 
		MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED, 
		unsigned int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT,
		unsigned int renderTargetFlags = 0
		)
	{
		return NULL;
	};

	ITexture *CreateNamedMultiRenderTargetTexture( 
		const char *pRTName,				// Pass in NULL here for an unnamed render target.
		int w, 
		int h, 
		RenderTargetSizeMode_t sizeMode,	// Controls how size is generated (and regenerated on video mode change).
		ImageFormat format, 
		MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED, 
		unsigned int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT,
		unsigned int renderTargetFlags = 0
		)
	{
		return NULL;
	};

	void PushRenderTargetAndViewport( )
	{
	}

	void PushRenderTargetAndViewport( ITexture *pTexture )
	{
	}

	void PushRenderTargetAndViewport( ITexture *pTexture, int nViewX, int nViewY, int nViewW, int nViewH )
	{
	}

	void PushRenderTargetAndViewport( ITexture *pTexture, ITexture *pDepthTexture, int nViewX, int nViewY, int nViewW, int nViewH )
	{
	}

	void PopRenderTargetAndViewport( void )
	{
	}

	virtual int ShaderFlagCount() const
	{
		return 0;
	}

	virtual const char *ShaderFlagName( int nIndex ) const
	{
		return "";
	}

	virtual void BindLightmapTexture( ITexture *pLightmapTexture )
	{
	}

	// Returns the currently active shader fallback for a particular shader
	virtual void GetShaderFallback( const char *pShaderName, char *pFallbackShader, int nFallbackLength )
	{
		pFallbackShader[0] = 0;
	}

#if defined( DX_TO_GL_ABSTRACTION ) && !defined( _GAMECONSOLE )
	virtual void DoStartupShaderPreloading( void )
	{
	}
#endif
	
	
	// Blit a subrect of the current render target to another texture
	virtual void CopyRenderTargetToTextureEx( ITexture *pTexture, int nRenderTargetID, Rect_t *pSrcRect, Rect_t *pDstRect = NULL )
	{
	}

	virtual void CopyTextureToRenderTargetEx( int nRenderTargetID, ITexture *pTexture, Rect_t *pSrcRect, Rect_t *pDstRect = NULL )
	{
	}

	bool IsTextureLoaded( char const* pTextureName ) const
	{
		return false;
	}

	bool GetTextureInformation( char const *szTextureName, MaterialTextureInfo_t &info ) const
	{
		return false;
	}

	void PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right )
	{
	}

	void SetFloatRenderingParameter(int parm_number, float value)
	{
	}

	void SetIntRenderingParameter(int parm_number, int value)
	{
	}

	void SetTextureRenderingParameter(int parm_number, ITexture *pTexture)
	{
	}

	void SetVectorRenderingParameter(int parm_number, Vector const &value)
	{
	}

	float GetFloatRenderingParameter(int parm_number) const
	{
		return 0;
	}

	int GetIntRenderingParameter(int parm_number) const
	{
		return 0;
	}

	ITexture *GetTextureRenderingParameter(int parm_number) const
	{
		return NULL;
	}

	Vector GetVectorRenderingParameter(int parm_number) const
	{
		return Vector(0,0,0);
	}
	
	void ReleaseResources(void)
	{
	}

	void ReacquireResources(void)
	{
	}

	Vector GetToneMappingScaleLinear( void )
	{
		return Vector(1,1,1);
	}

	virtual void GetMaxToRender( IMesh *pMesh, bool bMaxUntilFlush, int *pMaxVerts, int *pMaxIndices )
	{
		*pMaxVerts = 32768;
		*pMaxIndices = 32768;
	}

	// Returns the max possible vertices + indices to render in a single draw call
	virtual int GetMaxVerticesToRender( IMaterial *pMaterial )
	{
		return 32768;
	}

	virtual int GetMaxIndicesToRender( )
	{
		return 32768;
	}

	// stencil buffer operations.
	virtual void SetStencilState( const ShaderStencilState_t &state )
	{
	}

	virtual void ClearStencilBufferRectangle(int xmin, int ymin, int xmax, int ymax, int value)
	{
	}

	virtual void ModInit()
	{
	}

	virtual void ModShutdown()
	{
	}

	virtual void EnableColorCorrection( bool bEnable ) {}
	virtual ColorCorrectionHandle_t AddLookup( const char *pName ) { return 0; }
	virtual ColorCorrectionHandle_t FindLookup( const char *pName ) { return 0; }
	virtual bool RemoveLookup( ColorCorrectionHandle_t handle ) { return true; }
	virtual void LockLookup( ColorCorrectionHandle_t handle ) {}
	virtual void LoadLookup( ColorCorrectionHandle_t handle, const char *pLookupName ) {}
	virtual void UnlockLookup( ColorCorrectionHandle_t handle ) {}
	virtual void SetLookupWeight( ColorCorrectionHandle_t handle, float flWeight ) {}
	virtual void ResetLookupWeights( ) {}
	virtual void SetResetable( ColorCorrectionHandle_t handle, bool bResetable ) {}

	virtual void PushCustomClipPlane( const float *pPlane )
	{
	}

	virtual void PopCustomClipPlane( void )
	{
	}

	virtual bool EnableClipping( bool bEnable )
	{
		return true;
	}

	virtual void PushHeightClipPlane( void )
	{
	}

	virtual bool UsingFastClipping( void )
	{
		return true; //true for "crappier" hardware, so true is safer than false
	}

	virtual int StencilBufferBits( void )
	{
		return 0;
	}

	virtual void DisableAllLocalLights() {}
	virtual int CompareMaterialCombos( IMaterial *pMaterial1, IMaterial *pMaterial2, int lightmapID1, int lightmapID2 ) { return 0; }

	virtual bool SupportsMSAAMode( int nMSAAMode ) { return false; }
	virtual bool SupportsCSAAMode( int nNumSamples, int nQualityLevel ) { return false; }
#ifdef _GAMECONSOLE
	// Vitaliy: need HDR to run with -noshaderapi on console
	virtual bool SupportsHDRMode( HDRType_t nMode ) { return nMode == HDR_TYPE_NONE || nMode == HDR_TYPE_INTEGER; }
#else
	virtual bool SupportsHDRMode( HDRType_t nMode ) { return 0; }
#endif
	virtual bool IsDX10Card() { return false; }

	// Hooks for firing PIX events from outside the Material System...
	virtual void BeginPIXEvent( unsigned long color, const char *szName ) {};
	virtual void EndPIXEvent() {};
	virtual void SetPIXMarker( unsigned long color, const char *szName ) {};

	virtual IMatRenderContext *GetRenderContext() { return this; }

	void BeginRender() {}
	void BeginRender( float ) {}
	void EndRender() {}

	virtual void							SetThreadMode( MaterialThreadMode_t, int ) {}
	virtual MaterialThreadMode_t			GetThreadMode(){ return MATERIAL_SINGLE_THREADED; }
	virtual bool							IsRenderThreadSafe( ) { return true; }
	virtual bool							AllowThreading( bool bAllow, int nServiceThread ) { return false; }
	virtual void							ExecuteQueued() {}

	virtual void BeginBatch( IMesh* pIndices ) {}
	virtual void BindBatch( IMesh* pVertices, IMaterial *pAutoBind = NULL ) {}
	virtual void DrawBatch( MaterialPrimitiveType_t primType, int nFirstIndex, int nIndexCount )  {}
	virtual void EndBatch()  {}

	virtual bool SupportsShadowDepthTextures( void ) { return false; }

	virtual bool SupportsFetch4( void ) { return false; }


	virtual void SetShadowDepthBiasFactors( float fShadowSlopeScaleDepthBias, float fShadowDepthBias ) {}

	virtual ICallQueue *GetCallQueue() { return NULL; }
	virtual void GetWorldSpaceCameraPosition( Vector *pCameraPos )
	{
		pCameraPos->Init();
	}
	virtual void GetWorldSpaceCameraVectors( Vector *pVecForward, Vector *pVecRight, Vector *pVecUp )
	{
		if ( pVecForward )
		{
			pVecForward->Init( 1, 0, 0 );
		}
		if ( pVecRight )
		{
			pVecRight->Init( 0, -1, 0 );
		}
		if ( pVecUp )
		{
			pVecUp->Init( 0, 0, 1 );
		}
	}

	virtual void BeginUpdateLightmaps() {}
	virtual void EndUpdateLightmaps() {}

	virtual MaterialLock_t		Lock() { return NULL; }
	virtual void				Unlock( MaterialLock_t ) {}

	virtual ImageFormat GetShadowDepthTextureFormat() { return IMAGE_FORMAT_UNKNOWN; }
	virtual ImageFormat GetHighPrecisionShadowDepthTextureFormat() { return IMAGE_FORMAT_UNKNOWN; }

	virtual IMatRenderContext *CreateRenderContext( MaterialContextType_t type )
	{
		return RetAddRef( (IMatRenderContext *)this );
	}

	virtual IMatRenderContext *SetRenderContext( IMatRenderContext *pContext )
	{
		SafeRelease( pContext );
		return RetAddRef( this );
	}
	virtual IVertexBuffer *		GetDynamicVertexBuffer( /*VertexFormat_t vertexFormat, */bool buffered = true )
	{
		Assert( 0 );
		return NULL;
//		return GetDummyMesh();
	}
	virtual IIndexBuffer *		GetDynamicIndexBuffer( )
	{
		Assert( 0 );
		return NULL;
//		return GetDummyMesh();
	}

// ------------ New Vertex/Index Buffer interface ----------------------------
	virtual IVertexBuffer *CreateStaticVertexBuffer( VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroup )
	{
		Assert( 0 );
		return NULL;
	}
	virtual IIndexBuffer *CreateStaticIndexBuffer( MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroup )
	{
		Assert( 0 );
		return NULL;
	}
	virtual void DestroyVertexBuffer( IVertexBuffer * )
	{
	}
	virtual void DestroyIndexBuffer( IIndexBuffer * )
	{
	}
	// Do we need to specify the stream here in the case of locking multiple dynamic VBs on different streams?
	virtual IVertexBuffer *GetDynamicVertexBuffer( int streamID, VertexFormat_t vertexFormat, bool bBuffered = true )
	{
		Assert( 0 );
		return NULL;
	}
	virtual void BindVertexBuffer( int streamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions = 1 )
	{
	}
	virtual void BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes )
	{
	}
	virtual void Draw( MaterialPrimitiveType_t primitiveType, int nFirstIndex, int nIndexCount )
	{
	}
	virtual void BeginMorphAccumulation()
	{
	}
	virtual void EndMorphAccumulation()
	{
	}
	virtual void AccumulateMorph( IMorph* pMorph, int nMorphCount, const MorphWeight_t* pWeights )
	{
	}
	virtual bool GetMorphAccumulatorTexCoord( Vector2D *pTexCoord, IMorph *pMorph, int nVertex )
	{
		pTexCoord->Init();
		return false;
	}
	virtual int GetSubDBufferWidth()
	{
		return 0;
	}
	virtual float* LockSubDBuffer( int nNumRows )
	{
		return NULL;
	}
	virtual void UnlockSubDBuffer()
	{
	}

// ------------ End ----------------------------

	virtual ImageFormat GetNullTextureFormat() { return IMAGE_FORMAT_UNKNOWN; }

	virtual void AddTextureAlias( const char *pAlias, const char *pRealName ) {}
	virtual void RemoveTextureAlias( const char *pAlias ) {}

	virtual void SetExcludedTextures( const char *pScriptName, bool bUsingWeaponModelCache ) {}
	virtual void UpdateExcludedTextures( void ) {}
	virtual void ClearForceExcludes( void ) {}

	virtual void SetFlexWeights( int nFirstWeight, int nCount, const MorphWeight_t* pWeights ) {}

	virtual bool SupportsBorderColor() { return false; }

	virtual IMaterial *GetCurrentMaterial() { return NULL; }
	virtual int  GetCurrentNumBones() const { return 0; }
	virtual void *GetCurrentProxy() { return NULL; }

	virtual void SetFullScreenDepthTextureValidityFlag( bool bIsValid ) {}

	// A special path used to tick the front buffer while loading on the 360
	virtual void SetNonInteractiveLogoTexture( ITexture *pTexture, float flNormalizedX, float flNormalizedY, float flNormalizedW, float flNormalizedH ) {}
	virtual void SetNonInteractivePacifierTexture( ITexture *pTexture, float flNormalizedX, float flNormalizedY, float flNormalizedSize ) {}
	virtual void SetNonInteractiveTempFullscreenBuffer( ITexture *pTexture, MaterialNonInteractiveMode_t mode ) {}
	virtual void EnableNonInteractiveMode( MaterialNonInteractiveMode_t mode ) {}
	virtual void RefreshFrontBufferNonInteractive() {}
	virtual uint32 GetFrameTimestamps( ApplicationPerformanceCountersInfo_t &apci, ApplicationInstantCountersInfo_t & aici ) { return 0; }

	virtual void FlipCulling( bool bFlipCulling ) {}
	
	virtual void EnableSinglePassFlashlightMode( bool bEnable ) {}

	virtual bool SinglePassFlashlightModeEnabled() const 
	{
		return false;
	}

	virtual void DrawInstances( int nInstanceCount, const MeshInstanceData_t *pInstance ) {}
	virtual void *			LockRenderData( int nSizeInBytes ) { return NULL; }
	virtual void			UnlockRenderData( void *pData ) {}
	virtual bool			IsRenderData( const void *pData ) const { return false; }
	virtual void			AddRefRenderData() {}
	virtual void			ReleaseRenderData() {}

#if defined( _X360 )
	virtual void				ListUsedMaterials( void ) {}
	virtual HXUIFONT			OpenTrueTypeFont( const char *pFontname, int tall, int style )
	{
		return (HXUIFONT)0;
	}
	virtual void				CloseTrueTypeFont( HXUIFONT hFont ) {}
	virtual bool				GetTrueTypeFontMetrics( HXUIFONT hFont, wchar_t wchFirst, wchar_t wchLast, XUIFontMetrics *pFontMetrics, XUICharMetrics *pCharMetrics ) 
	{
		pFontMetrics->fLineHeight = 0.0f;
		pFontMetrics->fMaxAscent = 0.0f;
		pFontMetrics->fMaxDescent = 0.0f;
		pFontMetrics->fMaxWidth = 0.0f;
		pFontMetrics->fMaxHeight = 0.0f;
		pFontMetrics->fMaxAdvance = 0.0f;
		return true;
	}

	virtual bool				GetTrueTypeGlyphs( HXUIFONT hFont, int numChars, wchar_t *pWch, int *pOffsetX, int *pOffsetY, int *pWidth, int *pHeight, unsigned char *pRGBA, int *pRGBAOffset )
	{
		return false;
	}

	virtual void				PersistDisplay() {}
	virtual void				*GetD3DDevice() { return NULL; }

	virtual void				PushVertexShaderGPRAllocation( int iVertexShaderCount = 64 ) { };
	virtual void				PopVertexShaderGPRAllocation( void ) { };

	virtual bool				OwnGPUResources( bool bEnable ) { return false; }

	virtual void				FlushHiStencil() {}
#elif defined( _PS3 )
	virtual void				ListUsedMaterials( void ) {}
	virtual HPS3FONT			OpenTrueTypeFont( const char *pFontname, int tall, int style ){ return NULL; }
	virtual void				CloseTrueTypeFont( HPS3FONT hFont ){};
	virtual bool				GetTrueTypeFontMetrics( HPS3FONT hFont, int nFallbackTall, wchar_t wchFirst, wchar_t wchLast, CPS3FontMetrics *pFontMetrics, CPS3CharMetrics *pCharMetrics ){return false;}
	// Render a sequence of characters and extract the data into a buffer
	// For each character, provide the width+height of the font texture subrect,
	// an offset to apply when rendering the glyph, and an offset into a buffer to receive the RGBA data
	virtual bool				GetTrueTypeGlyphs( HPS3FONT hFont, int nFallbackTall, int numChars, wchar_t *pWch, int *pOffsetX, int *pOffsetY, int *pWidth, int *pHeight, unsigned char *pRGBA, int *pRGBAOffset ){return false;}
	virtual void TransmitScreenshotToVX() {};
	virtual void CompactRsxLocalMemory( char const *szReason ) {}
	virtual void SetFlipPresentFrequency( int nNumVBlanks ) {}
#endif
	virtual void SpinPresent( uint nFrames ){}

#if defined( _GAMECONSOLE )
	virtual void				BeginConsoleZPass( const WorldListIndicesInfo_t &indicesInfo ) {}
	virtual void				BeginConsoleZPass2( int nSlack ) {}
	virtual void				EndConsoleZPass() {}
#endif

#if defined( INCLUDE_SCALEFORM )
	virtual void				SetScaleformSlotViewport( int slot, int x, int y, int w, int h ) {}
	virtual void				RenderScaleformSlot( int slot ) {}
	virtual void				ForkRenderScaleformSlot( int slot ) {}
	virtual void				JoinRenderScaleformSlot( int slot ) {}

	virtual void				SetScaleformCursorViewport( int x, int y, int w, int h ) {}
	virtual void				RenderScaleformCursor() {}

	virtual void				AdvanceAndRenderScaleformSlot( int slot ) {}
	virtual void				AdvanceAndRenderScaleformCursor() {}
#endif // INCLUDE_SCALEFORM

#if defined( _PS3 )
	virtual void				FlushTextureCache() { }
#endif
	virtual void                AntiAliasingHint( int ) {}

	virtual void				CompactMemory() {}

	virtual void				GetGPUMemoryStats( GPUMemoryStats &stats ) {}

	// For sv_pure mode. The filesystem figures out which files the client needs to reload to be "pure" ala the server's preferences.
	virtual void ReloadFilesInList( IFileList *pFilesToReload )
	{
	}

	void UpdateGameTime( float flTime ) {}

	virtual bool CanDownloadTextures() const { return false; }

	virtual void BindPaintTexture( ITexture *pTexture )
	{
	}

	//--------------------------------------------------------
	// debug logging - no-op in queued context
	//--------------------------------------------------------
	virtual void							Printf( char *fmt, ... ) {};
	virtual void							PrintfVA( char *fmt, va_list vargs ){};
	virtual float							Knob( char *knobname, float *setvalue=NULL ) { return 0.0f; };	

	virtual void RegisterPaintmapDataManager( IPaintmapDataManager *pDataManager ) {}
	virtual void BeginUpdatePaintmaps( void ) {}
	virtual void EndUpdatePaintmaps( void ) {}
	virtual void UpdatePaintmap( int paintmap, BYTE* pPaintData, int numRects, Rect_t* pRects ) {}
};


static CDummyMaterialSystem g_DummyMaterialSystem;

EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CDummyMaterialSystem, IMaterialSystemStub, 
						MATERIAL_SYSTEM_STUB_INTERFACE_VERSION, g_DummyMaterialSystem );