tf2/tf2_src/materialsystem/mat_stub.cpp

//========= Copyright 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.
// ---------------------------------------------------------------------------------------- //
static unsigned short g_DummyIndices[6];

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 )
	{
		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 ) 
	{
		desc.m_pIndices = g_DummyIndices;
		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 ) 
	{
		desc.m_pIndices = g_DummyIndices;
		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 )
	{
	}
	
	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 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;
	}
};

// 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 ) {}

	// 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 ) {}

	// 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; }
	virtual NormalDecodeMode_t GetNormalDecodeMode() const { return NORMAL_DECODE_NONE; }

	// 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 void SwapContents( ITexture *pOther ) {}

	virtual unsigned int GetFlags( void ) const { return 0; }
	virtual void ForceLODOverride( int iNumLodsOverrideUpOrDown ) { 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 ) { return true; }
#endif

	// Save texture to a file.
	virtual bool SaveToFile( const char *fileName ) { return false; }

	void CopyToStagingTexture( ITexture* pDstTex ) {}

	virtual void SetErrorTexture( bool bIsErrorTexture ) { }
};

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 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  GetSamplerCount() const			{ return 0; }
	virtual bool HasSetDeviceGammaRamp() const		{ return false; }
	virtual bool SupportsCompressedTextures() const	{ return false; }
	virtual VertexCompressionType_t SupportsCompressedVertices() const { return VERTEX_COMPRESSION_NONE; }
	virtual bool SupportsVertexAndPixelShaders() const	{ return false; }
	virtual bool SupportsPixelShaders_1_4() const	{ return false; }
	virtual bool SupportsPixelShaders_2_0() const	{ return false; }
	virtual bool SupportsPixelShaders_2_b() const	{ return false; }
	virtual bool ActuallySupportsPixelShaders_2_b() const	{ return false; }
	virtual bool SupportsStaticControlFlow() const { return false; }
	virtual bool SupportsVertexShaders_2_0() const	{ return false; }
	virtual bool SupportsShaderModel_3_0() const	{ return false; }
	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 SupportsOverbright() const			{ return false; }
	virtual bool SupportsCubeMaps() const			{ return false; }
	virtual bool SupportsMipmappedCubemaps() const	{ return false; }
	virtual bool SupportsNonPow2Textures() const	{ return false; }

	// 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  GetTextureStageCount() const		{ return 0; }
	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 bool SupportsHardwareLighting() const	{ return false; }
	virtual int	 MaxBlendMatrices() const			{ return 0; }
	virtual int	 MaxBlendMatrixIndices() 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; }
	virtual bool UseFastZReject() const				{ return false; }
	virtual bool PreferReducedFillrate() 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; }

	virtual bool SupportsHDR() const				{ return false; }
	virtual HDRType_t GetHDRType() const			{ return HDR_TYPE_NONE; }
	virtual HDRType_t GetHardwareHDRType() const	{ return HDR_TYPE_NONE; }

	virtual bool HasProjectedBumpEnv() const		{ return false; }
	virtual bool SupportsSpheremapping() const		{ return false; }
	virtual bool NeedsAAClamp() const				{ return false; }
	virtual bool HasFastZReject() const				{ return false; }
	virtual bool NeedsATICentroidHack() const		{ return false; }
	virtual bool SupportsColorOnSecondStream() const{ return false; }
	virtual bool SupportsStaticPlusDynamicLighting() 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 GetVertexTextureCount() const		{ return 0; }
	virtual int GetMaxVertexTextureDimension() const { return 0; }
	virtual int MaxViewports() const { return 1; }
	virtual void OverrideStreamOffsetSupport( bool bOverrideEnabled, bool bEnableSupport ) {}
	virtual int GetShadowFilterMode() const { return 0; }
	virtual int NeedsShaderSRGBConversion() const { return 0; }
	bool UsesSRGBCorrectBlending() const { return false; }
	virtual bool HasFastVertexTextures() const { return false; }
	virtual int MaxHWMorphBatchCount() const { return 0; }
	virtual bool SupportsHDRMode( HDRType_t nMode ) const { return 0; }
	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 bool CanStretchRectFromTextures() 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;
	}

	// 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* ) {}

	virtual IMaterial		*CheckProxyReplacement( void *proxyData ) 
	{ 
		return this; 
	}

	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 void SetUseFixedFunctionBakedLighting( bool bEnable ) 
	{ 
	}
	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			IsPrecached() const {return true;}
};

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 bool IsMaterialLoaded( char const* pMaterialName )
	{
		if ( m_pRealMaterialSystem )
			return m_pRealMaterialSystem->IsMaterialLoaded( pMaterialName );
		return true;
	}

	virtual IMaterial *FindMaterialEx( char const* pMaterialName, const char *pTextureGroupName, int nContext, bool complain = true, const char *pComplainPrefix = NULL )
	{
		if ( m_pRealMaterialSystem )
			return m_pRealMaterialSystem->FindMaterialEx( pMaterialName, pTextureGroupName, nContext, 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 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 SetAsyncTextureLoadCache( FileCacheHandle_t hFileCache )
	{
	}

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

	virtual void				SuspendTextureStreaming( )
	{
		if ( m_pRealMaterialSystem )
			m_pRealMaterialSystem->SuspendTextureStreaming();
	}

	virtual void				ResumeTextureStreaming( )
	{
		if ( m_pRealMaterialSystem )
			m_pRealMaterialSystem->ResumeTextureStreaming();
	}

	// 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 bEnableValue )
	{
	}

	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( )
	{
	}

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

	// 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 )
	{
	}

	// 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				SetAmbientLight( float r, float g, float b )
	{
	}
	virtual void				SetLight( int lightNum, const LightDesc_t& desc )
	{
	}
	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				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 )
	{
	}

	// 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 )
	{
	}

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

	// 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()
	{
	}

	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;
	}

	// 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
	{
		w = 1024;
		h = 768;
	}
	
	ImageFormat GetBackBufferFormat( void ) const
	{
		return IMAGE_FORMAT_RGBA8888;
	}
	
	// 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 InitReturnVal_t Init() { return INIT_OK; }
	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 bool GetFlashlightMode( void ) const
	{
		return false;
	}
	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 void SetScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom, const bool bEnableScissor )
	{
	}

	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 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()
	{
	}

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

	virtual char *GetDisplayDeviceName() const OVERRIDE
	{
		return "";
	}

	// 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()
	{
	}

	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;
	};

	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;
	}

#ifdef DX_TO_GL_ABSTRACTION
	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;
	}

	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 SetVectorRenderingParameter(int parm_number, Vector const &value)
	{
	}

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

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

	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 SetStencilEnable(bool onoff)
	{
	}

	virtual void SetStencilFailOperation(StencilOperation_t op)
	{
	}

	virtual void SetStencilZFailOperation(StencilOperation_t op)
	{
	}

	virtual void SetStencilPassOperation(StencilOperation_t op)
	{
	}

	virtual void SetStencilCompareFunction(StencilComparisonFunction_t cmpfn)
	{
	}

	virtual void SetStencilReferenceValue(int ref)
	{
	}

	virtual void SetStencilTestMask(uint32 msk)
	{
	}

	virtual void SetStencilWriteMask(uint32 msk) 
	{
	}

	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 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 )
	{
	}
	void ResetToneMappingScale( float sc)
	{
	}
	void TurnOnToneMapping()
	{
	}

	virtual void GetDXLevelDefaults(uint &max_dxlevel,uint &recommended_dxlevel)
	{
		max_dxlevel=recommended_dxlevel=90;
	}

	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; }
	virtual bool SupportsHDRMode( HDRType_t nHDRModede ) { return false; }
	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(int nFirstIndex, int nIndexCount )  {}
	virtual void EndBatch()  {}

	virtual void SetGoalToneMappingScale(float) {}

	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 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( /*MaterialIndexFormat_t fmt, */bool buffered = true )
	{
		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 IIndexBuffer *GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, 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;
	}
// ------------ 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 ) {}
	virtual void UpdateExcludedTextures( 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 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 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, XUIFontMetrics *pFontMetrics, XUICharMetrics charMetrics[256] ) 
	{
		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; }
#endif

	virtual void				CompactMemory() {}

	// 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 )
	{
	}

	virtual void				PrintfVA( char *fmt, va_list vargs ) {}
	virtual void				Printf( const char *fmt, ... ) {}
	virtual float				Knob( char *knobname, float *setvalue=NULL ) { return 0.0f; }

	virtual void				SetRenderTargetFrameBufferSizeOverrides( int nWidth, int nHeight ) OVERRIDE
	{
		// Nope.
	}
	virtual void				GetRenderTargetFrameBufferDimensions( int & nWidth, int & nHeight ) OVERRIDE
	{
		GetBackBufferDimensions( nWidth, nHeight );
	}

	virtual ITexture*			CreateTextureFromBits(int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits)
	{
		return NULL;	
	}

	virtual void OverrideRenderTargetAllocation( bool )
	{
		// anda
	
	}

	virtual ITextureCompositor*	NewTextureCompositor( int w, int h, const char* pCompositeName, int nTeamNum, uint64 randomSeed, KeyValues* stageDesc, uint texCompositeCreateFlags ) OVERRIDE
	{
		return NULL;	
	}

	virtual void AsyncFindTexture( const char* pFilename, const char *pTextureGroupName, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs, bool bComplain = true, int nAdditionalCreationFlags = 0 )
	{

	}

	virtual void AsyncCreateTextureFromRenderTarget( ITexture* pSrcRt, const char* pDstName, ImageFormat dstFmt, bool bGenMips, int nAdditionalCreationFlags, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs )
	{

	}
	
	virtual ITexture*			CreateNamedTextureFromBitsEx( const char* pName, const char *pTextureGroupName, int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits, int nFlags )
	{
		return NULL;
	}

	virtual bool				AddTextureCompositorTemplate( const char* pName, KeyValues* pTmplDesc, int nTexCompositeTemplateFlags ) OVERRIDE
	{
		return false;
	}

	virtual bool VerifyTextureCompositorTemplates() OVERRIDE
	{
		return false;	
	}

};


static CDummyMaterialSystem g_DummyMaterialSystem;

EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CDummyMaterialSystem, IMaterialSystemStub, 
						MATERIAL_SYSTEM_STUB_INTERFACE_VERSION, g_DummyMaterialSystem );