1HEADmaster

2 files changed, 2994 insertions, 0 deletions

diff --git a/materialsystem/shaderapiempty/shaderapiempty.cpp b/materialsystem/shaderapiempty/shaderapiempty.cpp
new file mode 100644
index 0000000..850088c
--- /dev/null
+++ b/materialsystem/shaderapiempty/shaderapiempty.cpp
@@ -0,0 +1,2956 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+#include "utlvector.h"
+#include "materialsystem/imaterialsystem.h"
+#include "IHardwareConfigInternal.h"
+#include "shadersystem.h"
+#include "shaderapi/ishaderutil.h"
+#include "shaderapi/ishaderapi.h"
+#include "materialsystem/imesh.h"
+#include "tier0/dbg.h"
+#include "materialsystem/idebugtextureinfo.h"
+#include "materialsystem/deformations.h"
+
+
+//-----------------------------------------------------------------------------
+// The empty mesh
+//-----------------------------------------------------------------------------
+class CEmptyMesh : public IMesh
+{
+public:
+	CEmptyMesh( bool bIsDynamic );
+	virtual ~CEmptyMesh();
+
+	// FIXME: Make this work! Unsupported methods of IIndexBuffer + IVertexBuffer
+	virtual bool Lock( int nMaxIndexCount, bool bAppend, IndexDesc_t& desc );
+	virtual void Unlock( int nWrittenIndexCount, IndexDesc_t& desc );
+	virtual void ModifyBegin( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc );
+	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 Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc );
+	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 );
+	virtual bool IsDynamic() const { return m_bIsDynamic; }
+	virtual void BeginCastBuffer( VertexFormat_t format ) {}
+	virtual void BeginCastBuffer( MaterialIndexFormat_t format ) {}
+	virtual void EndCastBuffer( ) {}
+	virtual int GetRoomRemaining() const { return 0; }
+	virtual MaterialIndexFormat_t IndexFormat() const { return MATERIAL_INDEX_FORMAT_UNKNOWN; }
+
+	void LockMesh( int numVerts, int numIndices, MeshDesc_t& desc );
+	void UnlockMesh( int numVerts, int numIndices, MeshDesc_t& desc );
+
+	void ModifyBeginEx( bool bReadOnly, int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc );
+	void ModifyBegin( int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc );
+	void ModifyEnd( MeshDesc_t& desc );
+
+	// returns the # of vertices (static meshes only)
+	int  VertexCount() const;
+
+	// Sets the primitive type
+	void SetPrimitiveType( MaterialPrimitiveType_t type );
+	 
+	// Draws the entire mesh
+	void Draw(int firstIndex, int numIndices);
+
+	void Draw(CPrimList *pPrims, int nPrims);
+
+	// 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
+	void Spew( int numVerts, int numIndices, const MeshDesc_t & desc );
+
+	void ValidateData( int numVerts, int numIndices, const MeshDesc_t & desc );
+
+	// gets the associated material
+	IMaterial* GetMaterial();
+
+	void SetColorMesh( IMesh *pColorMesh, int nVertexOffset )
+	{
+	}
+
+
+	virtual int IndexCount() const
+	{
+		return 0;
+	}
+
+	virtual void SetFlexMesh( IMesh *pMesh, int nVertexOffset ) {}
+
+	virtual void DisableFlexMesh() {}
+
+	virtual void MarkAsDrawn() {}
+
+	virtual unsigned ComputeMemoryUsed() { return 0; }
+
+	virtual VertexFormat_t GetVertexFormat() const { return VERTEX_POSITION; }
+
+	virtual IMesh *GetMesh()
+	{
+		return this;
+	}
+
+private:
+	enum
+	{
+		VERTEX_BUFFER_SIZE = 1024 * 1024
+	};
+
+	unsigned char* m_pVertexMemory;
+	bool m_bIsDynamic;
+};
+
+
+//-----------------------------------------------------------------------------
+// The empty shader shadow
+//-----------------------------------------------------------------------------
+class CShaderShadowEmpty : public IShaderShadow
+{
+public:
+	CShaderShadowEmpty();
+	virtual ~CShaderShadowEmpty();
+
+	// Sets the default *shadow* state
+	void SetDefaultState();
+
+	// Methods related to depth buffering
+	void DepthFunc( ShaderDepthFunc_t depthFunc );
+	void EnableDepthWrites( bool bEnable );
+	void EnableDepthTest( bool bEnable );
+	void EnablePolyOffset( PolygonOffsetMode_t nOffsetMode );
+
+	// Suppresses/activates color writing 
+	void EnableColorWrites( bool bEnable );
+	void EnableAlphaWrites( bool bEnable );
+
+	// Methods related to alpha blending
+	void EnableBlending( bool bEnable );
+	void BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor );
+
+	// Alpha testing
+	void EnableAlphaTest( bool bEnable );
+	void AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ );
+
+	// Wireframe/filled polygons
+	void PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode );
+
+	// Back face culling
+	void EnableCulling( bool bEnable );
+	
+	// constant color + transparency
+	void EnableConstantColor( bool bEnable );
+
+	// Indicates the vertex format for use with a vertex shader
+	// The flags to pass in here come from the VertexFormatFlags_t enum
+	// If pTexCoordDimensions is *not* specified, we assume all coordinates
+	// are 2-dimensional
+	void VertexShaderVertexFormat( unsigned int nFlags, 
+		int nTexCoordCount, int* pTexCoordDimensions, int nUserDataSize );
+	
+	// Indicates we're going to light the model
+	void EnableLighting( bool bEnable );
+	void EnableSpecular( bool bEnable );
+
+	// vertex blending
+	void EnableVertexBlend( bool bEnable );
+
+	// per texture unit stuff
+	void OverbrightValue( TextureStage_t stage, float value );
+	void EnableTexture( Sampler_t stage, bool bEnable );
+	void EnableTexGen( TextureStage_t stage, bool bEnable );
+	void TexGen( TextureStage_t stage, ShaderTexGenParam_t param );
+
+	// alternate method of specifying per-texture unit stuff, more flexible and more complicated
+	// Can be used to specify different operation per channel (alpha/color)...
+	void EnableCustomPixelPipe( bool bEnable );
+	void CustomTextureStages( int stageCount );
+	void CustomTextureOperation( TextureStage_t stage, ShaderTexChannel_t channel, 
+		ShaderTexOp_t op, ShaderTexArg_t arg1, ShaderTexArg_t arg2 );
+
+	// indicates what per-vertex data we're providing
+	void DrawFlags( unsigned int drawFlags );
+
+	// A simpler method of dealing with alpha modulation
+	void EnableAlphaPipe( bool bEnable );
+	void EnableConstantAlpha( bool bEnable );
+	void EnableVertexAlpha( bool bEnable );
+	void EnableTextureAlpha( TextureStage_t stage, bool bEnable );
+
+	// GR - Separate alpha blending
+	void EnableBlendingSeparateAlpha( bool bEnable );
+	void BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor );
+
+	// Sets the vertex and pixel shaders
+	void SetVertexShader( const char *pFileName, int vshIndex );
+	void SetPixelShader( const char *pFileName, int pshIndex );
+
+	// Convert from linear to gamma color space on writes to frame buffer.
+	void EnableSRGBWrite( bool bEnable )
+	{
+	}
+
+	void EnableSRGBRead( Sampler_t stage, bool bEnable )
+	{
+	}
+
+	virtual void FogMode( ShaderFogMode_t fogMode )
+	{
+	}
+
+	virtual void DisableFogGammaCorrection( bool bDisable )
+	{
+	}
+
+	virtual void SetDiffuseMaterialSource( ShaderMaterialSource_t materialSource )
+	{
+	}
+
+	virtual void SetMorphFormat( MorphFormat_t flags )
+	{
+	}
+
+	virtual void EnableStencil( bool bEnable )
+	{
+	}
+	virtual void StencilFunc( ShaderStencilFunc_t stencilFunc )
+	{
+	}
+	virtual void StencilPassOp( ShaderStencilOp_t stencilOp )
+	{
+	}
+	virtual void StencilFailOp( ShaderStencilOp_t stencilOp )
+	{
+	}
+	virtual void StencilDepthFailOp( ShaderStencilOp_t stencilOp )
+	{
+	}
+	virtual void StencilReference( int nReference )
+	{
+	}
+	virtual void StencilMask( int nMask )
+	{
+	}
+	virtual void StencilWriteMask( int nMask )
+	{
+	}
+
+	virtual void ExecuteCommandBuffer( uint8 *pBuf ) 
+	{
+	}
+	// Alpha to coverage
+	void EnableAlphaToCoverage( bool bEnable );
+	
+	virtual void SetShadowDepthFiltering( Sampler_t stage )
+	{
+	}
+
+	virtual void BlendOp( ShaderBlendOp_t blendOp ) {}
+	virtual void BlendOpSeparateAlpha( ShaderBlendOp_t blendOp ) {}
+
+	bool m_IsTranslucent;
+	bool m_IsAlphaTested;
+	bool m_bIsDepthWriteEnabled;
+	bool m_bUsesVertexAndPixelShaders;
+};
+
+
+//-----------------------------------------------------------------------------
+// The DX8 implementation of the shader device
+//-----------------------------------------------------------------------------
+class CShaderDeviceEmpty : public IShaderDevice
+{
+public:
+	CShaderDeviceEmpty() : m_DynamicMesh( true ), m_Mesh( false ) {}
+
+	// Methods of IShaderDevice
+	virtual int GetCurrentAdapter() const { return 0; }
+	virtual bool IsUsingGraphics() const { return false; }
+	virtual void SpewDriverInfo() const;
+	virtual ImageFormat GetBackBufferFormat() const { return IMAGE_FORMAT_RGB888; }
+	virtual void GetBackBufferDimensions( int& width, int& height ) const;
+	virtual int  StencilBufferBits() const { return 0; }
+	virtual bool IsAAEnabled() const { return false; }
+	virtual void Present( ) {}
+	virtual void GetWindowSize( int &width, int &height ) const;
+	virtual bool AddView( void* hwnd );
+	virtual void RemoveView( void* hwnd );
+	virtual void SetView( void* hwnd );
+	virtual void ReleaseResources();
+	virtual void ReacquireResources();
+	virtual IMesh* CreateStaticMesh( VertexFormat_t fmt, const char *pTextureBudgetGroup, IMaterial * pMaterial = NULL );
+	virtual void DestroyStaticMesh( IMesh* mesh );
+	virtual IShaderBuffer* CompileShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion ) { return NULL; }
+	virtual VertexShaderHandle_t CreateVertexShader( IShaderBuffer* pShaderBuffer ) { return VERTEX_SHADER_HANDLE_INVALID; }
+	virtual void DestroyVertexShader( VertexShaderHandle_t hShader ) {}
+	virtual GeometryShaderHandle_t CreateGeometryShader( IShaderBuffer* pShaderBuffer ) { return GEOMETRY_SHADER_HANDLE_INVALID; }
+	virtual void DestroyGeometryShader( GeometryShaderHandle_t hShader ) {}
+	virtual PixelShaderHandle_t CreatePixelShader( IShaderBuffer* pShaderBuffer ) { return PIXEL_SHADER_HANDLE_INVALID; }
+	virtual void DestroyPixelShader( PixelShaderHandle_t hShader ) {}
+	virtual IVertexBuffer *CreateVertexBuffer( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroup );
+	virtual void DestroyVertexBuffer( IVertexBuffer *pVertexBuffer );
+	virtual IIndexBuffer *CreateIndexBuffer( ShaderBufferType_t bufferType, MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroup );
+	virtual void DestroyIndexBuffer( IIndexBuffer *pIndexBuffer );
+	virtual IVertexBuffer *GetDynamicVertexBuffer( int streamID, VertexFormat_t vertexFormat, bool bBuffered );
+	virtual IIndexBuffer *GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered );
+	virtual void SetHardwareGammaRamp( float fGamma, float fGammaTVRangeMin, float fGammaTVRangeMax, float fGammaTVExponent, bool bTVEnabled ) {}
+	virtual void EnableNonInteractiveMode( MaterialNonInteractiveMode_t mode, ShaderNonInteractiveInfo_t *pInfo ) {}
+	virtual void RefreshFrontBufferNonInteractive( ) {}
+	virtual void HandleThreadEvent( uint32 threadEvent ) {}
+
+#ifdef DX_TO_GL_ABSTRACTION
+	virtual void DoStartupShaderPreloading( void ) {}
+#endif
+
+	virtual char *GetDisplayDeviceName() OVERRIDE { return ""; }
+
+private:
+	CEmptyMesh m_Mesh;
+	CEmptyMesh m_DynamicMesh;
+};
+
+static CShaderDeviceEmpty s_ShaderDeviceEmpty;
+
+// FIXME: Remove; it's for backward compat with the materialsystem only for now
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderDeviceEmpty, IShaderDevice, 
+								  SHADER_DEVICE_INTERFACE_VERSION, s_ShaderDeviceEmpty )
+
+
+//-----------------------------------------------------------------------------
+// The DX8 implementation of the shader device
+//-----------------------------------------------------------------------------
+class CShaderDeviceMgrEmpty : public IShaderDeviceMgr
+{
+public:
+	// Methods of IAppSystem
+	virtual bool Connect( CreateInterfaceFn factory );
+	virtual void Disconnect();
+	virtual void *QueryInterface( const char *pInterfaceName );
+	virtual InitReturnVal_t Init();
+	virtual void Shutdown();
+
+public:
+	// Methods of IShaderDeviceMgr
+	virtual int	 GetAdapterCount() const;
+	virtual void GetAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const;
+	virtual bool GetRecommendedConfigurationInfo( int nAdapter, int nDXLevel, KeyValues *pKeyValues );
+	virtual int	 GetModeCount( int adapter ) const;
+	virtual void GetModeInfo( ShaderDisplayMode_t *pInfo, int nAdapter, int mode ) const;
+	virtual void GetCurrentModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter ) const;
+	virtual bool SetAdapter( int nAdapter, int nFlags );
+	virtual CreateInterfaceFn SetMode( void *hWnd, int nAdapter, const ShaderDeviceInfo_t& mode );
+	virtual void AddModeChangeCallback( ShaderModeChangeCallbackFunc_t func ) {}
+	virtual void RemoveModeChangeCallback( ShaderModeChangeCallbackFunc_t func ) {}
+};
+
+static CShaderDeviceMgrEmpty s_ShaderDeviceMgrEmpty;
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderDeviceMgrEmpty, IShaderDeviceMgr, 
+								  SHADER_DEVICE_MGR_INTERFACE_VERSION, s_ShaderDeviceMgrEmpty )
+
+
+//-----------------------------------------------------------------------------
+// The DX8 implementation of the shader API
+//-----------------------------------------------------------------------------
+class CShaderAPIEmpty : public IShaderAPI, public IHardwareConfigInternal, public IDebugTextureInfo
+{
+public:
+	// constructor, destructor
+	CShaderAPIEmpty( );
+	virtual ~CShaderAPIEmpty();
+
+	// IDebugTextureInfo implementation.
+public:
+
+	virtual bool IsDebugTextureListFresh( int numFramesAllowed = 1 ) { return false; }
+	virtual bool SetDebugTextureRendering( bool bEnable ) { return false; }
+	virtual void EnableDebugTextureList( bool bEnable ) {}
+	virtual void EnableGetAllTextures( bool bEnable ) {}
+	virtual KeyValues* GetDebugTextureList() { return NULL; }
+	virtual int GetTextureMemoryUsed( TextureMemoryType eTextureMemory ) { return 0; }
+
+	// Methods of IShaderDynamicAPI
+	virtual void GetBackBufferDimensions( int& width, int& height ) const
+	{
+		s_ShaderDeviceEmpty.GetBackBufferDimensions( width, height );
+	}
+	virtual void GetCurrentColorCorrection( ShaderColorCorrectionInfo_t* pInfo )
+	{
+		pInfo->m_bIsEnabled = false;
+		pInfo->m_nLookupCount = 0;
+		pInfo->m_flDefaultWeight = 0.0f;
+	}
+
+
+	// Methods of IShaderAPI
+public:
+	virtual void SetViewports( int nCount, const ShaderViewport_t* pViewports );
+	virtual int GetViewports( ShaderViewport_t* pViewports, int nMax ) const;
+	virtual void ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil, int renderTargetWidth, int renderTargetHeight );
+	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 BindVertexShader( VertexShaderHandle_t hVertexShader ) {}
+	virtual void BindGeometryShader( GeometryShaderHandle_t hGeometryShader ) {}
+	virtual void BindPixelShader( PixelShaderHandle_t hPixelShader ) {}
+	virtual void SetRasterState( const ShaderRasterState_t& state ) {}
+	virtual void MarkUnusedVertexFields( unsigned int nFlags, int nTexCoordCount, bool *pUnusedTexCoords ) {}
+	virtual bool OwnGPUResources( bool bEnable ) { return false; }
+
+	virtual bool DoRenderTargetsNeedSeparateDepthBuffer() const;
+
+	// Used to clear the transition table when we know it's become invalid.
+	void ClearSnapshots();
+
+	// Sets the mode...
+	bool SetMode( void* hwnd, int nAdapter, const ShaderDeviceInfo_t &info )
+	{
+		return true;
+	}
+
+	void ChangeVideoMode( const ShaderDeviceInfo_t &info )
+	{
+	}
+
+	// Called when the dx support level has changed
+	virtual void DXSupportLevelChanged() {}
+
+	virtual void EnableUserClipTransformOverride( bool bEnable ) {}
+	virtual void UserClipTransform( const VMatrix &worldToView ) {}
+
+	// Sets the default *dynamic* state
+	void SetDefaultState( );
+
+	// Returns the snapshot id for the shader state
+	StateSnapshot_t	 TakeSnapshot( );
+
+	// Returns true if the state snapshot is transparent
+	bool IsTranslucent( StateSnapshot_t id ) const;
+	bool IsAlphaTested( StateSnapshot_t id ) const;
+	bool UsesVertexAndPixelShaders( StateSnapshot_t id ) const;
+	virtual bool IsDepthWriteEnabled( StateSnapshot_t id ) const;
+
+	// Gets the vertex format for a set of snapshot ids
+	VertexFormat_t ComputeVertexFormat( int numSnapshots, StateSnapshot_t* pIds ) const;
+
+	// Gets the vertex format for a set of snapshot ids
+	VertexFormat_t ComputeVertexUsage( int numSnapshots, StateSnapshot_t* pIds ) const;
+
+	// Begins a rendering pass that uses a state snapshot
+	void BeginPass( StateSnapshot_t snapshot  );
+
+	// Uses a state snapshot
+	void UseSnapshot( StateSnapshot_t snapshot );
+
+	// Use this to get the mesh builder that allows us to modify vertex data
+	CMeshBuilder* GetVertexModifyBuilder();
+
+	// Sets the color to modulate by
+	void Color3f( float r, float g, float b );
+	void Color3fv( float const* pColor );
+	void Color4f( float r, float g, float b, float a );
+	void Color4fv( float const* pColor );
+
+	// Faster versions of color
+	void Color3ub( unsigned char r, unsigned char g, unsigned char b );
+	void Color3ubv( unsigned char const* rgb );
+	void Color4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a );
+	void Color4ubv( unsigned char const* rgba );
+
+	// Sets the lights
+	void SetLight( int lightNum, const LightDesc_t& desc );
+	void SetLightingOrigin( Vector vLightingOrigin );
+	void SetAmbientLight( float r, float g, float b );
+	void SetAmbientLightCube( Vector4D cube[6] );
+
+	// Get the lights
+	int GetMaxLights( void ) const;
+	const LightDesc_t& GetLight( int lightNum ) const;
+
+	// Render state for the ambient light cube (vertex shaders)
+	void SetVertexShaderStateAmbientLightCube();
+	void SetPixelShaderStateAmbientLightCube( int pshReg, bool bForceToBlack = false )
+	{
+	}
+
+	float GetAmbientLightCubeLuminance(void)
+	{
+		return 0.0f;
+	}
+
+	void SetSkinningMatrices();
+
+	// Lightmap texture binding
+	void BindLightmap( TextureStage_t stage );
+	void BindLightmapAlpha( TextureStage_t stage )
+	{
+	}
+	void BindBumpLightmap( TextureStage_t stage );
+	void BindFullbrightLightmap( TextureStage_t stage );
+	void BindWhite( TextureStage_t stage );
+	void BindBlack( TextureStage_t stage );
+	void BindGrey( TextureStage_t stage );
+	void BindFBTexture( TextureStage_t stage, int textureIdex );
+	void CopyRenderTargetToTexture( ShaderAPITextureHandle_t texID )
+	{
+	}
+
+	void CopyRenderTargetToTextureEx( ShaderAPITextureHandle_t texID, int nRenderTargetID, Rect_t *pSrcRect, Rect_t *pDstRect )
+	{
+	}
+
+	void CopyTextureToRenderTargetEx( int nRenderTargetID, ShaderAPITextureHandle_t textureHandle, Rect_t *pSrcRect, Rect_t *pDstRect )
+	{
+	}
+
+	// Special system flat normal map binding.
+	void BindFlatNormalMap( TextureStage_t stage );
+	void BindNormalizationCubeMap( TextureStage_t stage );
+	void BindSignedNormalizationCubeMap( TextureStage_t stage );
+
+	// Set the number of bone weights
+	void SetNumBoneWeights( int numBones );
+	void EnableHWMorphing( bool bEnable );
+
+	// Flushes any primitives that are buffered
+	void FlushBufferedPrimitives();
+
+	// Gets the dynamic mesh; 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.
+	IMesh* GetDynamicMesh( IMaterial* pMaterial, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride );
+	IMesh* GetDynamicMeshEx( IMaterial* pMaterial, VertexFormat_t fmt, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride );
+
+	IMesh* GetFlexMesh();
+
+	// Renders a single pass of a material
+	void RenderPass( int nPass, int nPassCount );
+
+	// stuff related to matrix stacks
+	void MatrixMode( MaterialMatrixMode_t matrixMode );
+	void PushMatrix();
+	void PopMatrix();
+	void LoadMatrix( float *m );
+	void LoadBoneMatrix( int boneIndex, const float *m ) {}
+	void MultMatrix( float *m );
+	void MultMatrixLocal( float *m );
+	void GetMatrix( MaterialMatrixMode_t matrixMode, float *dst );
+	void LoadIdentity( void );
+	void LoadCameraToWorld( void );
+	void Ortho( double left, double top, double right, double bottom, double zNear, double zFar );
+	void PerspectiveX( double fovx, double aspect, double zNear, double zFar );
+	void PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right );
+	void PickMatrix( int x, int y, int width, int height );
+	void Rotate( float angle, float x, float y, float z );
+	void Translate( float x, float y, float z );
+	void Scale( float x, float y, float z );
+	void ScaleXY( float x, float y );
+
+	// Fog methods...
+	void FogMode( MaterialFogMode_t fogMode );
+	void FogStart( float fStart );
+	void FogEnd( float fEnd );
+	void SetFogZ( float fogZ );
+	void FogMaxDensity( float flMaxDensity );
+	void GetFogDistances( float *fStart, float *fEnd, float *fFogZ );
+	void FogColor3f( float r, float g, float b );
+	void FogColor3fv( float const* rgb );
+	void FogColor3ub( unsigned char r, unsigned char g, unsigned char b );
+	void FogColor3ubv( unsigned char const* rgb );
+
+	virtual void SceneFogColor3ub( unsigned char r, unsigned char g, unsigned char b );
+	virtual void SceneFogMode( MaterialFogMode_t fogMode );
+	virtual void GetSceneFogColor( unsigned char *rgb );
+	virtual MaterialFogMode_t GetSceneFogMode( );
+	virtual int GetPixelFogCombo( );
+
+	void SetHeightClipZ( float z ); 
+	void SetHeightClipMode( enum MaterialHeightClipMode_t heightClipMode ); 
+
+	void SetClipPlane( int index, const float *pPlane );
+	void EnableClipPlane( int index, bool bEnable );
+
+	void SetFastClipPlane( const float *pPlane );
+	void EnableFastClip( bool bEnable );
+	
+	// We use smaller dynamic VBs during level transitions, to free up memory
+	virtual int  GetCurrentDynamicVBSize( void );
+	virtual void DestroyVertexBuffers( bool bExitingLevel = false );
+
+	// Sets the vertex and pixel shaders
+	void SetVertexShaderIndex( int vshIndex );
+	void SetPixelShaderIndex( int pshIndex );
+
+	// Sets the constant register for vertex and pixel shaders
+	void SetVertexShaderConstant( int var, float const* pVec, int numConst = 1, bool bForce = false );
+	void SetBooleanVertexShaderConstant( int var, BOOL const* pVec, int numConst = 1, bool bForce = false );
+	void SetIntegerVertexShaderConstant( int var, int const* pVec, int numConst = 1, bool bForce = false );
+	void SetPixelShaderConstant( int var, float const* pVec, int numConst = 1, bool bForce = false );
+	void SetBooleanPixelShaderConstant( int var, BOOL const* pVec, int numBools = 1, bool bForce = false );
+	void SetIntegerPixelShaderConstant( int var, int const* pVec, int numIntVecs = 1, bool bForce = false );
+
+	void InvalidateDelayedShaderConstants( void );
+
+	// Gamma<->Linear conversions according to the video hardware we're running on
+	float GammaToLinear_HardwareSpecific( float fGamma ) const;
+	float LinearToGamma_HardwareSpecific( float fLinear ) const;
+
+	//Set's the linear->gamma conversion textures to use for this hardware for both srgb writes enabled and disabled(identity)
+	void SetLinearToGammaConversionTextures( ShaderAPITextureHandle_t hSRGBWriteEnabledTexture, ShaderAPITextureHandle_t hIdentityTexture );
+
+	// Cull mode
+	void CullMode( MaterialCullMode_t cullMode );
+
+	// Force writes only when z matches. . . useful for stenciling things out
+	// by rendering the desired Z values ahead of time.
+	void ForceDepthFuncEquals( bool bEnable );
+
+	// Forces Z buffering on or off
+	void OverrideDepthEnable( bool bEnable, bool bDepthEnable );
+	void OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable );
+	void OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable );
+
+	// Sets the shade mode
+	void ShadeMode( ShaderShadeMode_t mode );
+
+	// Binds a particular material to render with
+	void Bind( IMaterial* pMaterial );
+
+	// Returns the nearest supported format
+	ImageFormat GetNearestSupportedFormat( ImageFormat fmt, bool bFilteringRequired = true ) const;
+ 	ImageFormat GetNearestRenderTargetFormat( ImageFormat fmt ) const;
+
+	// Sets the texture state
+	void BindTexture( Sampler_t stage, ShaderAPITextureHandle_t textureHandle );
+
+	void SetRenderTarget( ShaderAPITextureHandle_t colorTextureHandle, ShaderAPITextureHandle_t depthTextureHandle )
+	{
+	}
+
+	void SetRenderTargetEx( int nRenderTargetID, ShaderAPITextureHandle_t colorTextureHandle, ShaderAPITextureHandle_t depthTextureHandle )
+	{
+	}
+
+	// Indicates we're going to be modifying this texture
+	// TexImage2D, TexSubImage2D, TexWrap, TexMinFilter, and TexMagFilter
+	// all use the texture specified by this function.
+	void ModifyTexture( ShaderAPITextureHandle_t textureHandle );
+
+	// Texture management methods
+	void TexImage2D( int level, int cubeFace, ImageFormat dstFormat, int zOffset, int width, int height, 
+							 ImageFormat srcFormat, bool bSrcIsTiled, void *imageData );
+	void TexSubImage2D( int level, int cubeFace, int xOffset, int yOffset, int zOffset, int width, int height,
+							 ImageFormat srcFormat, int srcStride, bool bSrcIsTiled, void *imageData );
+
+	void TexImageFromVTF( IVTFTexture *pVTF, int iVTFFrame );
+
+	bool TexLock( int level, int cubeFaceID, int xOffset, int yOffset, 
+									int width, int height, CPixelWriter& writer );
+	void TexUnlock( );
+	
+	// These are bound to the texture, not the texture environment
+	void TexMinFilter( ShaderTexFilterMode_t texFilterMode );
+	void TexMagFilter( ShaderTexFilterMode_t texFilterMode );
+	void TexWrap( ShaderTexCoordComponent_t coord, ShaderTexWrapMode_t wrapMode );
+	void TexSetPriority( int priority );	
+
+	ShaderAPITextureHandle_t CreateTexture( 
+		int width, 
+		int height,
+		int depth,
+		ImageFormat dstImageFormat, 
+		int numMipLevels, 
+		int numCopies, 
+		int flags, 
+		const char *pDebugName,
+		const char *pTextureGroupName );
+	// Create a multi-frame texture (equivalent to calling "CreateTexture" multiple times, but more efficient)
+	void CreateTextures( 
+		ShaderAPITextureHandle_t *pHandles,
+		int count,
+		int width, 
+		int height,
+		int depth,
+		ImageFormat dstImageFormat, 
+		int numMipLevels, 
+		int numCopies, 
+		int flags, 
+		const char *pDebugName,
+		const char *pTextureGroupName );
+	ShaderAPITextureHandle_t CreateDepthTexture( ImageFormat renderFormat, int width, int height, const char *pDebugName, bool bTexture );
+	void DeleteTexture( ShaderAPITextureHandle_t textureHandle );
+	bool IsTexture( ShaderAPITextureHandle_t textureHandle );
+	bool IsTextureResident( ShaderAPITextureHandle_t textureHandle );
+
+	// stuff that isn't to be used from within a shader
+	void ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth );
+	void ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth );
+	void PerformFullScreenStencilOperation( void );
+	void ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat );
+	virtual void ReadPixels( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *data, ImageFormat dstFormat, int nDstStride );
+
+	// Selection mode methods
+	int SelectionMode( bool selectionMode );
+	void SelectionBuffer( unsigned int* pBuffer, int size );
+	void ClearSelectionNames( );
+	void LoadSelectionName( int name );
+	void PushSelectionName( int name );
+	void PopSelectionName();
+
+	void FlushHardware();
+	void ResetRenderState( bool bFullReset = true );
+
+	void SetScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom, const bool bEnableScissor );
+
+	// Can we download textures?
+	virtual bool CanDownloadTextures() const;
+
+	// Board-independent calls, here to unify how shaders set state
+	// Implementations should chain back to IShaderUtil->BindTexture(), etc.
+
+	// Use this to begin and end the frame
+	void BeginFrame();
+	void EndFrame();
+
+	// returns current time
+	double CurrentTime() const;
+
+	// Get the current camera position in world space.
+	void GetWorldSpaceCameraPosition( float * pPos ) const;
+
+	// Members of IMaterialSystemHardwareConfig
+	bool HasDestAlphaBuffer() const;
+	bool HasStencilBuffer() const;
+	virtual int  MaxViewports() const;
+	virtual void OverrideStreamOffsetSupport( bool bOverrideEnabled, bool bEnableSupport ) {}
+	virtual int  GetShadowFilterMode() const;
+	int  StencilBufferBits() const;
+	int	 GetFrameBufferColorDepth() const;
+	int  GetSamplerCount() const;
+	bool HasSetDeviceGammaRamp() const;
+	bool SupportsCompressedTextures() const;
+	VertexCompressionType_t SupportsCompressedVertices() const;
+	bool SupportsVertexAndPixelShaders() const;
+	bool SupportsPixelShaders_1_4() const;
+	bool SupportsPixelShaders_2_0() const;
+	bool SupportsPixelShaders_2_b() const;
+	bool ActuallySupportsPixelShaders_2_b() const;
+	bool SupportsStaticControlFlow() const;
+	bool SupportsVertexShaders_2_0() const;
+	bool SupportsShaderModel_3_0() const;
+	int  MaximumAnisotropicLevel() const;
+	int  MaxTextureWidth() const;
+	int  MaxTextureHeight() const;
+	int  MaxTextureAspectRatio() const;
+	int  GetDXSupportLevel() const;
+	const char *GetShaderDLLName() const
+	{
+		return "UNKNOWN";
+	}
+	int	 TextureMemorySize() const;
+	bool SupportsOverbright() const;
+	bool SupportsCubeMaps() const;
+	bool SupportsMipmappedCubemaps() const;
+	bool SupportsNonPow2Textures() const;
+	int  GetTextureStageCount() const;
+	int	 NumVertexShaderConstants() const;
+	int	 NumBooleanVertexShaderConstants() const;
+	int	 NumIntegerVertexShaderConstants() const;
+	int	 NumPixelShaderConstants() const;
+	int	 MaxNumLights() const;
+	bool SupportsHardwareLighting() const;
+	int	 MaxBlendMatrices() const;
+	int	 MaxBlendMatrixIndices() const;
+	int	 MaxVertexShaderBlendMatrices() const;
+	int	 MaxUserClipPlanes() const;
+	bool UseFastClipping() const
+	{
+		return false;
+	}
+	bool SpecifiesFogColorInLinearSpace() const;
+	virtual bool SupportsSRGB() const;
+	virtual bool FakeSRGBWrite() const;
+	virtual bool CanDoSRGBReadFromRTs() const;
+	virtual bool SupportsGLMixedSizeTargets() const;
+
+	const char *GetHWSpecificShaderDLLName() const;
+	bool NeedsAAClamp() const
+	{
+		return false;
+	}
+	bool SupportsSpheremapping() const;
+	virtual int MaxHWMorphBatchCount() const { return 0; }
+
+	// This is the max dx support level supported by the card
+	virtual int	 GetMaxDXSupportLevel() const;
+
+	bool ReadPixelsFromFrontBuffer() const;
+	bool PreferDynamicTextures() const;
+	virtual bool PreferReducedFillrate() const;
+	bool HasProjectedBumpEnv() const;
+	void ForceHardwareSync( void );
+	
+	int GetCurrentNumBones( void ) const;
+	bool IsHWMorphingEnabled( void ) const;
+	int GetCurrentLightCombo( void ) const;
+	void GetDX9LightState( LightState_t *state ) const;
+	MaterialFogMode_t GetCurrentFogType( void ) const;
+
+	void RecordString( const char *pStr );
+
+	void EvictManagedResources();
+
+	void SetTextureTransformDimension( TextureStage_t textureStage, int dimension, bool projected );
+	void DisableTextureTransform( TextureStage_t textureStage )
+	{
+	}
+	void SetBumpEnvMatrix( TextureStage_t textureStage, float m00, float m01, float m10, float m11 );
+
+	// Gets the lightmap dimensions
+	virtual void GetLightmapDimensions( int *w, int *h );
+
+	virtual void SyncToken( const char *pToken );
+
+	// Setup standard vertex shader constants (that don't change)
+	// This needs to be called anytime that overbright changes.
+	virtual void SetStandardVertexShaderConstants( float fOverbright )
+	{
+	}
+	
+	// Level of anisotropic filtering
+	virtual void SetAnisotropicLevel( int nAnisotropyLevel );
+
+	bool SupportsHDR() const
+	{
+		return false;
+	}
+	HDRType_t GetHDRType() const
+	{
+		return HDR_TYPE_NONE;
+	}
+	HDRType_t GetHardwareHDRType() const
+	{
+		return HDR_TYPE_NONE;
+	}
+	virtual bool NeedsATICentroidHack() const
+	{
+		return false;
+	}
+	virtual bool SupportsColorOnSecondStream() const
+	{
+		return false;
+	}
+	virtual bool SupportsStaticPlusDynamicLighting() const
+	{
+		return false;
+	}
+	virtual bool SupportsStreamOffset() const
+	{
+		return false;
+	}
+	void SetDefaultDynamicState()
+	{
+	}
+	virtual void CommitPixelShaderLighting( int pshReg )
+	{
+	}
+
+	ShaderAPIOcclusionQuery_t CreateOcclusionQueryObject( void )
+	{
+		return INVALID_SHADERAPI_OCCLUSION_QUERY_HANDLE;
+	}
+
+	void DestroyOcclusionQueryObject( ShaderAPIOcclusionQuery_t handle )
+	{
+	}
+
+	void BeginOcclusionQueryDrawing( ShaderAPIOcclusionQuery_t handle )
+	{
+	}
+
+	void EndOcclusionQueryDrawing( ShaderAPIOcclusionQuery_t handle )
+	{
+	}
+
+	int OcclusionQuery_GetNumPixelsRendered( ShaderAPIOcclusionQuery_t handle, bool bFlush )
+	{
+		return 0;
+	}
+
+	virtual void AcquireThreadOwnership() {}
+	virtual void ReleaseThreadOwnership() {}
+
+	virtual bool SupportsBorderColor() const { return false; }
+	virtual bool SupportsFetch4() const { return false; }
+	virtual bool CanStretchRectFromTextures( void ) const { return false; }
+	virtual void EnableBuffer2FramesAhead( bool bEnable ) {}
+
+	virtual void SetPSNearAndFarZ( int pshReg ) { }
+
+	virtual void SetDepthFeatheringPixelShaderConstant( int iConstant, float fDepthBlendScale ) {}
+
+	void SetPixelShaderFogParams( int reg )
+	{
+	}
+
+	virtual bool InFlashlightMode() const
+	{
+		return false;
+	}
+
+	virtual bool InEditorMode() const
+	{
+		return false;
+	}
+
+	// What fields in the morph do we actually use?
+	virtual MorphFormat_t ComputeMorphFormat( int numSnapshots, StateSnapshot_t* pIds ) const
+	{
+		return 0;
+	}
+
+	// Gets the bound morph's vertex format; returns 0 if no morph is bound
+	virtual MorphFormat_t GetBoundMorphFormat()
+	{
+		return 0;
+	}
+
+	// Binds a standard texture
+	virtual void BindStandardTexture( Sampler_t stage, StandardTextureId_t id )
+	{
+	}
+
+	virtual void BindStandardVertexTexture( VertexTextureSampler_t stage, StandardTextureId_t id )
+	{
+	}
+
+	virtual void GetStandardTextureDimensions( int *pWidth, int *pHeight, StandardTextureId_t id )
+	{
+		*pWidth = *pHeight = 0;
+	}
+
+
+	virtual void SetFlashlightState( const FlashlightState_t &state, const VMatrix &worldToTexture )
+	{
+	}
+
+	virtual void SetFlashlightStateEx( const FlashlightState_t &state, const VMatrix &worldToTexture, ITexture *pFlashlightDepthTexture )
+	{
+	}
+
+	virtual const FlashlightState_t &GetFlashlightState( VMatrix &worldToTexture ) const 
+	{
+		static FlashlightState_t  blah;
+		return blah;
+	}
+
+	virtual const FlashlightState_t &GetFlashlightStateEx( VMatrix &worldToTexture, ITexture **pFlashlightDepthTexture ) const 
+	{
+		static FlashlightState_t  blah;
+		return blah;
+	}
+
+	virtual void ClearVertexAndPixelShaderRefCounts()
+	{
+	}
+
+	virtual void PurgeUnusedVertexAndPixelShaders()
+	{
+	}
+
+	virtual bool IsAAEnabled() const
+	{
+		return false;
+	}
+
+	virtual int GetVertexTextureCount() const
+	{
+		return 0;
+	}
+
+	virtual int GetMaxVertexTextureDimension() const
+	{
+		return 0;
+	}
+
+	virtual int  MaxTextureDepth() const
+	{
+		return 0;
+	}
+
+	// Binds a vertex texture to a particular texture stage in the vertex pipe
+	virtual void BindVertexTexture( VertexTextureSampler_t nSampler, ShaderAPITextureHandle_t hTexture )
+	{
+	}
+
+	// Sets morph target factors
+	virtual void SetFlexWeights( int nFirstWeight, int nCount, const MorphWeight_t* pWeights )
+	{
+	}
+
+	// NOTE: Stuff after this is added after shipping HL2.
+	ITexture *GetRenderTargetEx( int nRenderTargetID )
+	{
+		return NULL;
+	}
+
+	void SetToneMappingScaleLinear( const Vector &scale )
+	{
+	}
+
+	const Vector &GetToneMappingScaleLinear( void ) const
+	{
+		static Vector dummy;
+		return dummy;
+	}
+
+	virtual float GetLightMapScaleFactor( void ) const
+	{
+		return 1.0;
+	}
+
+
+	// For dealing with device lost in cases where SwapBuffers isn't called all the time (Hammer)
+	virtual void HandleDeviceLost()
+	{
+	}
+
+	virtual void EnableLinearColorSpaceFrameBuffer( bool bEnable )
+	{
+	}
+
+	// Lets the shader know about the full-screen texture so it can 
+	virtual void SetFullScreenTextureHandle( ShaderAPITextureHandle_t h )
+	{
+	}
+
+	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);
+	}
+
+	// Methods related to stencil
+	void SetStencilEnable(bool onoff)
+	{
+	}
+
+	void SetStencilFailOperation(StencilOperation_t op)
+	{
+	}
+
+	void SetStencilZFailOperation(StencilOperation_t op)
+	{
+	}
+
+	void SetStencilPassOperation(StencilOperation_t op)
+	{
+	}
+
+	void SetStencilCompareFunction(StencilComparisonFunction_t cmpfn)
+	{
+	}
+
+	void SetStencilReferenceValue(int ref)
+	{
+	}
+
+	void SetStencilTestMask(uint32 msk)
+	{
+	}
+
+	void SetStencilWriteMask(uint32 msk)
+	{
+	}
+
+	void ClearStencilBufferRectangle( int xmin, int ymin, int xmax, int ymax,int value)
+	{
+	}
+
+	virtual void GetDXLevelDefaults(uint &max_dxlevel,uint &recommended_dxlevel)
+	{
+		max_dxlevel=recommended_dxlevel=90;
+	}
+
+	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;
+	}
+	virtual int CompareSnapshots( StateSnapshot_t snapshot0, StateSnapshot_t snapshot1 ) { return 0; }
+
+	virtual void DisableAllLocalLights() {}
+
+	virtual bool SupportsMSAAMode( int nMSAAMode ) { return false; }
+
+	virtual bool SupportsCSAAMode( int nNumSamples, int nQualityLevel ) { 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 void ComputeVertexDescription( unsigned char* pBuffer, VertexFormat_t vertexFormat, MeshDesc_t& desc ) const {}
+
+	virtual bool SupportsShadowDepthTextures() { return false; }
+
+	virtual bool SupportsFetch4() { return false; }
+
+	virtual int NeedsShaderSRGBConversion(void) const { return 0; }
+	virtual bool UsesSRGBCorrectBlending() const { return false; }
+
+	virtual bool HasFastVertexTextures() const { return false; }
+
+	virtual void SetShadowDepthBiasFactors( float fShadowSlopeScaleDepthBias, float fShadowDepthBias ) {}
+
+	virtual void SetDisallowAccess( bool ) {}
+	virtual void EnableShaderShaderMutex( bool ) {}
+	virtual void ShaderLock() {}
+	virtual void ShaderUnlock() {}
+
+// ------------ New Vertex/Index Buffer interface ----------------------------
+	void BindVertexBuffer( int streamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions1 )
+	{
+	}
+	void BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes )
+	{
+	}
+	void Draw( MaterialPrimitiveType_t primitiveType, int firstIndex, int numIndices )
+	{
+	}
+// ------------ End ----------------------------
+
+	virtual int  GetVertexBufferCompression( void ) const { return 0; };
+
+	virtual bool ShouldWriteDepthToDestAlpha( void ) const { return false; };
+	virtual bool SupportsHDRMode( HDRType_t nHDRMode ) const { return false; };
+	virtual bool IsDX10Card() const { return false; };
+
+	void PushDeformation( const DeformationBase_t *pDeformation )
+	{
+	}
+
+	virtual void PopDeformation( )
+	{
+	}
+
+	int GetNumActiveDeformations( ) const
+	{
+		return 0;
+	}
+
+	// for shaders to set vertex shader constants. returns a packed state which can be used to set the dynamic combo
+	int GetPackedDeformationInformation( int nMaskOfUnderstoodDeformations,
+										 float *pConstantValuesOut,
+										 int nBufferSize,
+										 int nMaximumDeformations,
+										 int *pNumDefsOut ) const
+	{
+		*pNumDefsOut = 0;
+		return 0;
+	}
+
+	void SetStandardTextureHandle(StandardTextureId_t,ShaderAPITextureHandle_t)
+	{
+	}
+
+	virtual void ExecuteCommandBuffer( uint8 *pData )
+	{
+	}
+	virtual bool GetHDREnabled( void ) const { return true; }
+	virtual void SetHDREnabled( bool bEnable ) {}
+
+	virtual void CopyRenderTargetToScratchTexture( ShaderAPITextureHandle_t srcRt, ShaderAPITextureHandle_t dstTex, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL ) 
+	{
+	}
+
+	// Allows locking and unlocking of very specific surface types.
+	virtual void LockRect( void** pOutBits, int* pOutPitch, ShaderAPITextureHandle_t texHandle, int mipmap, int x, int y, int w, int h, bool bWrite, bool bRead ) 
+	{
+	}
+
+	virtual void UnlockRect( ShaderAPITextureHandle_t texHandle, int mipmap )
+	{
+	}
+
+	virtual void TexLodClamp( int finest ) {}
+
+	virtual void TexLodBias( float bias ) {}
+
+	virtual void CopyTextureToTexture( ShaderAPITextureHandle_t srcTex, ShaderAPITextureHandle_t dstTex ) {}
+	
+	void PrintfVA( char *fmt, va_list vargs ) {}
+	void Printf( const char *fmt, ... ) {}
+	float Knob( char *knobname, float *setvalue = NULL ) { return 0.0f; };
+
+private:
+	enum
+	{
+		TRANSLUCENT = 0x1,
+		ALPHATESTED = 0x2,
+		VERTEX_AND_PIXEL_SHADERS = 0x4,
+		DEPTHWRITE = 0x8,
+	};
+
+	CEmptyMesh m_Mesh;
+
+	void EnableAlphaToCoverage() {} ;
+	void DisableAlphaToCoverage() {} ;
+
+	ImageFormat GetShadowDepthTextureFormat() { return IMAGE_FORMAT_UNKNOWN; };
+	ImageFormat GetNullTextureFormat() { return IMAGE_FORMAT_UNKNOWN; };
+};
+
+
+//-----------------------------------------------------------------------------
+// Class Factory
+//-----------------------------------------------------------------------------
+
+static CShaderAPIEmpty g_ShaderAPIEmpty;
+static CShaderShadowEmpty g_ShaderShadow;
+
+// FIXME: Remove; it's for backward compat with the materialsystem only for now
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIEmpty, IShaderAPI, 
+									SHADERAPI_INTERFACE_VERSION, g_ShaderAPIEmpty )
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderShadowEmpty, IShaderShadow, 
+								SHADERSHADOW_INTERFACE_VERSION, g_ShaderShadow )
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIEmpty, IMaterialSystemHardwareConfig, 
+				MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION, g_ShaderAPIEmpty )
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIEmpty, IDebugTextureInfo, 
+				DEBUG_TEXTURE_INFO_VERSION, g_ShaderAPIEmpty )
+
+
+//-----------------------------------------------------------------------------
+// The main GL Shader util interface
+//-----------------------------------------------------------------------------
+IShaderUtil* g_pShaderUtil;
+
+
+//-----------------------------------------------------------------------------
+// Factory to return from SetMode
+//-----------------------------------------------------------------------------
+static void* ShaderInterfaceFactory( const char *pInterfaceName, int *pReturnCode )
+{
+	if ( pReturnCode )
+	{
+		*pReturnCode = IFACE_OK;
+	}
+	if ( !Q_stricmp( pInterfaceName, SHADER_DEVICE_INTERFACE_VERSION ) )
+		return static_cast< IShaderDevice* >( &s_ShaderDeviceEmpty );
+	if ( !Q_stricmp( pInterfaceName, SHADERAPI_INTERFACE_VERSION ) )
+		return static_cast< IShaderAPI* >( &g_ShaderAPIEmpty );
+	if ( !Q_stricmp( pInterfaceName, SHADERSHADOW_INTERFACE_VERSION ) )
+		return static_cast< IShaderShadow* >( &g_ShaderShadow );
+
+	if ( pReturnCode )
+	{
+		*pReturnCode = IFACE_FAILED;
+	}
+	return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// CShaderDeviceMgrEmpty
+//
+//-----------------------------------------------------------------------------
+bool CShaderDeviceMgrEmpty::Connect( CreateInterfaceFn factory )
+{
+	// So others can access it
+	g_pShaderUtil = (IShaderUtil*)factory( SHADER_UTIL_INTERFACE_VERSION, NULL );
+
+	return true;
+}
+
+void CShaderDeviceMgrEmpty::Disconnect()
+{
+	g_pShaderUtil = NULL;
+}
+
+void *CShaderDeviceMgrEmpty::QueryInterface( const char *pInterfaceName )
+{
+	if ( !Q_stricmp( pInterfaceName, SHADER_DEVICE_MGR_INTERFACE_VERSION ) )
+		return static_cast< IShaderDeviceMgr* >( this );
+	if ( !Q_stricmp( pInterfaceName, MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION ) )
+		return static_cast< IMaterialSystemHardwareConfig* >( &g_ShaderAPIEmpty );
+	return NULL;
+}
+
+InitReturnVal_t CShaderDeviceMgrEmpty::Init()
+{
+	return INIT_OK;
+}
+
+void CShaderDeviceMgrEmpty::Shutdown()
+{
+
+}
+
+// Sets the adapter
+bool CShaderDeviceMgrEmpty::SetAdapter( int nAdapter, int nFlags )
+{
+	return true;
+}
+
+// FIXME: Is this a public interface? Might only need to be private to shaderapi
+CreateInterfaceFn CShaderDeviceMgrEmpty::SetMode( void *hWnd, int nAdapter, const ShaderDeviceInfo_t& mode ) 
+{
+	return ShaderInterfaceFactory;
+}
+
+// Gets the number of adapters...
+int	 CShaderDeviceMgrEmpty::GetAdapterCount() const
+{
+	return 0;
+}
+
+bool CShaderDeviceMgrEmpty::GetRecommendedConfigurationInfo( int nAdapter, int nDXLevel, KeyValues *pKeyValues ) 
+{
+	return true;
+}
+
+// Returns info about each adapter
+void CShaderDeviceMgrEmpty::GetAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const
+{
+	memset( &info, 0, sizeof( info ) );
+	info.m_nDXSupportLevel = 90;
+}
+
+// Returns the number of modes
+int	 CShaderDeviceMgrEmpty::GetModeCount( int nAdapter ) const
+{
+	return 0;
+}
+
+// Returns mode information..
+void CShaderDeviceMgrEmpty::GetModeInfo( ShaderDisplayMode_t *pInfo, int nAdapter, int nMode ) const
+{
+}
+
+void CShaderDeviceMgrEmpty::GetCurrentModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter ) const
+{
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// Shader device empty
+//
+//-----------------------------------------------------------------------------
+void CShaderDeviceEmpty::GetWindowSize( int &width, int &height ) const
+{
+	width = 0;
+	height = 0;
+}
+
+void CShaderDeviceEmpty::GetBackBufferDimensions( int& width, int& height ) const
+{
+	width = 1024;
+	height = 768;
+}
+
+// Use this to spew information about the 3D layer 
+void CShaderDeviceEmpty::SpewDriverInfo() const
+{
+	Warning("Empty shader\n");
+}
+
+// Creates/ destroys a child window
+bool CShaderDeviceEmpty::AddView( void* hwnd )
+{
+	return true;
+}
+
+void CShaderDeviceEmpty::RemoveView( void* hwnd )
+{
+}
+
+// Activates a view
+void CShaderDeviceEmpty::SetView( void* hwnd )
+{
+}
+
+void CShaderDeviceEmpty::ReleaseResources()
+{
+}
+
+void CShaderDeviceEmpty::ReacquireResources()
+{
+}
+
+// Creates/destroys Mesh
+IMesh* CShaderDeviceEmpty::CreateStaticMesh( VertexFormat_t fmt, const char *pTextureBudgetGroup, IMaterial * pMaterial )
+{
+	return &m_Mesh;
+}
+
+void CShaderDeviceEmpty::DestroyStaticMesh( IMesh* mesh )
+{
+}
+
+// Creates/destroys static vertex + index buffers
+IVertexBuffer *CShaderDeviceEmpty::CreateVertexBuffer( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pTextureBudgetGroup )
+{
+	return ( type == SHADER_BUFFER_TYPE_STATIC || type == SHADER_BUFFER_TYPE_STATIC_TEMP ) ? &m_Mesh : &m_DynamicMesh;
+}
+
+void CShaderDeviceEmpty::DestroyVertexBuffer( IVertexBuffer *pVertexBuffer )
+{
+
+}
+
+IIndexBuffer *CShaderDeviceEmpty::CreateIndexBuffer( ShaderBufferType_t bufferType, MaterialIndexFormat_t fmt, int nIndexCount, const char *pTextureBudgetGroup )
+{
+	switch( bufferType )
+	{
+	case SHADER_BUFFER_TYPE_STATIC:
+	case SHADER_BUFFER_TYPE_STATIC_TEMP:
+		return &m_Mesh;
+	default:
+		Assert( 0 );
+	case SHADER_BUFFER_TYPE_DYNAMIC:
+	case SHADER_BUFFER_TYPE_DYNAMIC_TEMP:
+		return &m_DynamicMesh;
+	}
+}
+
+void CShaderDeviceEmpty::DestroyIndexBuffer( IIndexBuffer *pIndexBuffer )
+{
+
+}
+
+IVertexBuffer *CShaderDeviceEmpty::GetDynamicVertexBuffer( int streamID, VertexFormat_t vertexFormat, bool bBuffered )
+{
+	return &m_DynamicMesh;
+}
+
+IIndexBuffer *CShaderDeviceEmpty::GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered )
+{
+	return &m_Mesh;
+}
+
+
+
+//-----------------------------------------------------------------------------
+//
+// The empty mesh...
+//
+//-----------------------------------------------------------------------------
+CEmptyMesh::CEmptyMesh( bool bIsDynamic ) : m_bIsDynamic( bIsDynamic )
+{
+	m_pVertexMemory = new unsigned char[VERTEX_BUFFER_SIZE];
+}
+
+CEmptyMesh::~CEmptyMesh()
+{
+	delete[] m_pVertexMemory;
+}
+
+bool CEmptyMesh::Lock( int nMaxIndexCount, bool bAppend, IndexDesc_t& desc )
+{
+	static int s_BogusIndex;
+	desc.m_pIndices = (unsigned short*)&s_BogusIndex;
+	desc.m_nIndexSize = 0;
+	desc.m_nFirstIndex = 0;
+	desc.m_nOffset = 0;
+	return true;
+}
+
+void CEmptyMesh::Unlock( int nWrittenIndexCount, IndexDesc_t& desc )
+{
+}
+
+void CEmptyMesh::ModifyBegin( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc )
+{
+	Lock( nIndexCount, false, desc );
+}
+
+void CEmptyMesh::ModifyEnd( IndexDesc_t& desc )
+{
+}
+
+void CEmptyMesh::Spew( int nIndexCount, const IndexDesc_t & desc )
+{
+}
+
+void CEmptyMesh::ValidateData( int nIndexCount, const IndexDesc_t &desc )
+{
+}
+
+bool CEmptyMesh::Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc )
+{
+	// Who cares about the data?
+	desc.m_pPosition = (float*)m_pVertexMemory;
+	desc.m_pNormal = (float*)m_pVertexMemory;
+	desc.m_pColor = m_pVertexMemory;
+
+	int i;
+	for ( i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; ++i)
+	{
+		desc.m_pTexCoord[i] = (float*)m_pVertexMemory;
+	}
+
+	desc.m_pBoneWeight = (float*)m_pVertexMemory;
+	desc.m_pBoneMatrixIndex = (unsigned char*)m_pVertexMemory;
+	desc.m_pTangentS = (float*)m_pVertexMemory;
+	desc.m_pTangentT = (float*)m_pVertexMemory;
+	desc.m_pUserData = (float*)m_pVertexMemory;
+	desc.m_NumBoneWeights = 2;
+
+	desc.m_VertexSize_Position = 0;
+	desc.m_VertexSize_BoneWeight = 0;
+	desc.m_VertexSize_BoneMatrixIndex = 0;
+	desc.m_VertexSize_Normal = 0;
+	desc.m_VertexSize_Color = 0;
+	for( i=0; i < VERTEX_MAX_TEXTURE_COORDINATES; i++ )
+	{
+		desc.m_VertexSize_TexCoord[i] = 0;
+	}
+	desc.m_VertexSize_TangentS = 0;
+	desc.m_VertexSize_TangentT = 0;
+	desc.m_VertexSize_UserData = 0;
+	desc.m_ActualVertexSize = 0;	// Size of the vertices.. Some of the m_VertexSize_ elements above
+
+	desc.m_nFirstVertex = 0;
+	desc.m_nOffset = 0;
+	return true;
+}
+
+void CEmptyMesh::Unlock( int nVertexCount, VertexDesc_t &desc )
+{
+}
+
+void CEmptyMesh::Spew( int nVertexCount, const VertexDesc_t &desc ) 
+{
+}
+
+void CEmptyMesh::ValidateData( int nVertexCount, const VertexDesc_t & desc )
+{
+}
+
+void CEmptyMesh::LockMesh( int numVerts, int numIndices, MeshDesc_t& desc )
+{
+	Lock( numVerts, false, *static_cast<VertexDesc_t*>( &desc ) );
+	Lock( numIndices, false, *static_cast<IndexDesc_t*>( &desc ) );
+}
+
+void CEmptyMesh::UnlockMesh( int numVerts, int numIndices, MeshDesc_t& desc )
+{
+}
+
+void CEmptyMesh::ModifyBeginEx( bool bReadOnly, int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc )
+{
+	Lock( numVerts, false, *static_cast<VertexDesc_t*>( &desc ) );
+	Lock( numIndices, false, *static_cast<IndexDesc_t*>( &desc ) );
+}
+
+void CEmptyMesh::ModifyBegin( int firstVertex, int numVerts, int firstIndex, int numIndices, MeshDesc_t& desc )
+{
+	ModifyBeginEx( false, firstVertex, numVerts, firstIndex, numIndices, desc );
+}
+
+void CEmptyMesh::ModifyEnd( MeshDesc_t& desc )
+{
+}
+
+// returns the # of vertices (static meshes only)
+int CEmptyMesh::VertexCount() const
+{
+	return 0;
+}
+
+// Sets the primitive type
+void CEmptyMesh::SetPrimitiveType( MaterialPrimitiveType_t type )
+{
+}
+
+// Draws the entire mesh
+void CEmptyMesh::Draw( int firstIndex, int numIndices )
+{
+}
+
+void CEmptyMesh::Draw(CPrimList *pPrims, int nPrims)
+{
+}
+
+// Copy verts and/or indices to a mesh builder. This only works for temp meshes!
+void CEmptyMesh::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
+void CEmptyMesh::Spew( int numVerts, int numIndices, const MeshDesc_t & desc )
+{
+}
+
+void CEmptyMesh::ValidateData( int numVerts, int numIndices, const MeshDesc_t & desc )
+{
+}
+
+// gets the associated material
+IMaterial* CEmptyMesh::GetMaterial()
+{
+	// umm. this don't work none
+	Assert(0);
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// The shader shadow interface
+//-----------------------------------------------------------------------------
+CShaderShadowEmpty::CShaderShadowEmpty()
+{
+	m_IsTranslucent = false;
+	m_IsAlphaTested = false;
+	m_bIsDepthWriteEnabled = true;
+	m_bUsesVertexAndPixelShaders = false;
+}
+
+CShaderShadowEmpty::~CShaderShadowEmpty()
+{
+}
+
+// Sets the default *shadow* state
+void CShaderShadowEmpty::SetDefaultState()
+{
+	m_IsTranslucent = false;
+	m_IsAlphaTested = false;
+	m_bIsDepthWriteEnabled = true;
+	m_bUsesVertexAndPixelShaders = false;
+}
+
+// Methods related to depth buffering
+void CShaderShadowEmpty::DepthFunc( ShaderDepthFunc_t depthFunc )
+{
+}
+
+void CShaderShadowEmpty::EnableDepthWrites( bool bEnable )
+{
+	m_bIsDepthWriteEnabled = bEnable;
+}
+
+void CShaderShadowEmpty::EnableDepthTest( bool bEnable )
+{
+}
+
+void CShaderShadowEmpty::EnablePolyOffset( PolygonOffsetMode_t nOffsetMode )
+{
+}
+
+// Suppresses/activates color writing 
+void CShaderShadowEmpty::EnableColorWrites( bool bEnable )
+{
+}
+
+// Suppresses/activates alpha writing 
+void CShaderShadowEmpty::EnableAlphaWrites( bool bEnable )
+{
+}
+
+// Methods related to alpha blending
+void CShaderShadowEmpty::EnableBlending( bool bEnable )
+{
+	m_IsTranslucent = bEnable;
+}
+
+void CShaderShadowEmpty::BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
+{
+}
+
+// A simpler method of dealing with alpha modulation
+void CShaderShadowEmpty::EnableAlphaPipe( bool bEnable )
+{
+}
+
+void CShaderShadowEmpty::EnableConstantAlpha( bool bEnable )
+{
+}
+
+void CShaderShadowEmpty::EnableVertexAlpha( bool bEnable )
+{
+}
+
+void CShaderShadowEmpty::EnableTextureAlpha( TextureStage_t stage, bool bEnable )
+{
+}
+
+
+// Alpha testing
+void CShaderShadowEmpty::EnableAlphaTest( bool bEnable )
+{
+	m_IsAlphaTested = bEnable;
+}
+
+void CShaderShadowEmpty::AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ )
+{
+}
+
+
+// Wireframe/filled polygons
+void CShaderShadowEmpty::PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode )
+{
+}
+
+
+// Back face culling
+void CShaderShadowEmpty::EnableCulling( bool bEnable )
+{
+}
+
+
+// Alpha to coverage
+void CShaderShadowEmpty::EnableAlphaToCoverage( bool bEnable )
+{
+}
+
+
+// constant color + transparency
+void CShaderShadowEmpty::EnableConstantColor( bool bEnable )
+{
+}
+
+// Indicates the vertex format for use with a vertex shader
+// The flags to pass in here come from the VertexFormatFlags_t enum
+// If pTexCoordDimensions is *not* specified, we assume all coordinates
+// are 2-dimensional
+void CShaderShadowEmpty::VertexShaderVertexFormat( unsigned int nFlags, 
+												   int nTexCoordCount,
+												   int* pTexCoordDimensions,
+												   int nUserDataSize )
+{
+}
+
+// Indicates we're going to light the model
+void CShaderShadowEmpty::EnableLighting( bool bEnable )
+{
+}
+
+void CShaderShadowEmpty::EnableSpecular( bool bEnable )
+{
+}
+
+// Activate/deactivate skinning
+void CShaderShadowEmpty::EnableVertexBlend( bool bEnable )
+{
+}
+
+// per texture unit stuff
+void CShaderShadowEmpty::OverbrightValue( TextureStage_t stage, float value )
+{
+}
+
+void CShaderShadowEmpty::EnableTexture( Sampler_t stage, bool bEnable )
+{
+}
+
+void CShaderShadowEmpty::EnableCustomPixelPipe( bool bEnable )
+{
+}
+
+void CShaderShadowEmpty::CustomTextureStages( int stageCount )
+{
+}
+
+void CShaderShadowEmpty::CustomTextureOperation( TextureStage_t stage, ShaderTexChannel_t channel, 
+	ShaderTexOp_t op, ShaderTexArg_t arg1, ShaderTexArg_t arg2 )
+{
+}
+
+void CShaderShadowEmpty::EnableTexGen( TextureStage_t stage, bool bEnable )
+{
+}
+
+void CShaderShadowEmpty::TexGen( TextureStage_t stage, ShaderTexGenParam_t param )
+{
+}
+
+// Sets the vertex and pixel shaders
+void CShaderShadowEmpty::SetVertexShader( const char *pShaderName, int vshIndex )
+{
+	m_bUsesVertexAndPixelShaders = ( pShaderName != NULL );
+}
+
+void CShaderShadowEmpty::EnableBlendingSeparateAlpha( bool bEnable )
+{
+}
+void CShaderShadowEmpty::SetPixelShader( const char *pShaderName, int pshIndex )
+{
+	m_bUsesVertexAndPixelShaders = ( pShaderName != NULL );
+}
+
+void CShaderShadowEmpty::BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
+{
+}
+// indicates what per-vertex data we're providing
+void CShaderShadowEmpty::DrawFlags( unsigned int drawFlags )
+{
+}
+
+
+
+//-----------------------------------------------------------------------------
+//
+// Shader API Empty
+//
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor
+//-----------------------------------------------------------------------------
+
+CShaderAPIEmpty::CShaderAPIEmpty()  : m_Mesh( false )
+{
+}
+
+CShaderAPIEmpty::~CShaderAPIEmpty()
+{
+}
+
+
+bool CShaderAPIEmpty::DoRenderTargetsNeedSeparateDepthBuffer() const
+{
+	return false;
+}
+
+// Can we download textures?
+bool CShaderAPIEmpty::CanDownloadTextures() const
+{
+	return false;
+}
+
+// Used to clear the transition table when we know it's become invalid.
+void CShaderAPIEmpty::ClearSnapshots()
+{
+}
+
+// Members of IMaterialSystemHardwareConfig
+bool CShaderAPIEmpty::HasDestAlphaBuffer() const
+{
+	return false;
+}
+
+bool CShaderAPIEmpty::HasStencilBuffer() const
+{
+	return false;
+}
+
+int CShaderAPIEmpty::MaxViewports() const
+{
+	return 1;
+}
+
+int CShaderAPIEmpty::GetShadowFilterMode() const
+{
+	return 0;
+}
+
+int CShaderAPIEmpty::StencilBufferBits() const
+{
+	return 0;
+}
+
+int	 CShaderAPIEmpty::GetFrameBufferColorDepth() const
+{
+	return 0;
+}
+
+int  CShaderAPIEmpty::GetSamplerCount() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 60))
+		return 1;
+	if (( ShaderUtil()->GetConfig().dxSupportLevel >= 60 ) && ( ShaderUtil()->GetConfig().dxSupportLevel < 80 ))
+		return 2;
+	return 4;
+}
+
+bool CShaderAPIEmpty::HasSetDeviceGammaRamp() const
+{
+	return false;
+}
+
+bool CShaderAPIEmpty::SupportsCompressedTextures() const
+{
+	return false;
+}
+
+VertexCompressionType_t CShaderAPIEmpty::SupportsCompressedVertices() const
+{
+	return VERTEX_COMPRESSION_NONE;
+}
+
+bool CShaderAPIEmpty::SupportsVertexAndPixelShaders() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 80))
+		return false;
+
+	return true;
+}
+
+bool CShaderAPIEmpty::SupportsPixelShaders_1_4() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 81))
+		return false;
+
+	return true;
+}
+
+bool CShaderAPIEmpty::SupportsPixelShaders_2_0() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 90))
+		return false;
+
+	return true;
+}
+
+bool CShaderAPIEmpty::SupportsPixelShaders_2_b() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 90))
+		return false;
+
+	return true;
+}
+
+bool CShaderAPIEmpty::ActuallySupportsPixelShaders_2_b() const
+{
+	return true;
+}
+
+bool CShaderAPIEmpty::SupportsShaderModel_3_0() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+		(ShaderUtil()->GetConfig().dxSupportLevel < 95))
+		return false;
+
+	return true;
+}
+
+bool CShaderAPIEmpty::SupportsStaticControlFlow() const
+{
+	if ( IsOpenGL() )
+		return false;
+
+	return SupportsVertexShaders_2_0();
+}
+
+bool CShaderAPIEmpty::SupportsVertexShaders_2_0() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 90))
+		return false;
+
+	return true;
+}
+
+int  CShaderAPIEmpty::MaximumAnisotropicLevel() const
+{
+	return 0;
+}
+
+void CShaderAPIEmpty::SetAnisotropicLevel( int nAnisotropyLevel )
+{
+}
+
+int  CShaderAPIEmpty::MaxTextureWidth() const
+{
+	// Should be big enough to cover all cases
+	return 16384;
+}
+
+int  CShaderAPIEmpty::MaxTextureHeight() const
+{
+	// Should be big enough to cover all cases
+	return 16384;
+}
+
+int  CShaderAPIEmpty::MaxTextureAspectRatio() const
+{
+	// Should be big enough to cover all cases
+	return 16384;
+}
+
+
+int	 CShaderAPIEmpty::TextureMemorySize() const
+{
+	// fake it
+	return 64 * 1024 * 1024;
+}
+
+int  CShaderAPIEmpty::GetDXSupportLevel() const 
+{ 
+	return 90; 
+}
+
+bool CShaderAPIEmpty::SupportsOverbright() const
+{
+	return false;
+}
+
+bool CShaderAPIEmpty::SupportsCubeMaps() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 70))
+		return false;
+
+	return true;
+}
+
+bool CShaderAPIEmpty::SupportsNonPow2Textures() const
+{
+	return true;
+}
+
+bool CShaderAPIEmpty::SupportsMipmappedCubemaps() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 70))
+		return false;
+
+	return true;
+}
+
+int  CShaderAPIEmpty::GetTextureStageCount() const
+{
+	return 4;
+}
+
+int	 CShaderAPIEmpty::NumVertexShaderConstants() const
+{
+	return 128;
+}
+
+int	 CShaderAPIEmpty::NumBooleanVertexShaderConstants() const
+{
+	return 0;
+}
+
+int	 CShaderAPIEmpty::NumIntegerVertexShaderConstants() const
+{
+	return 0;
+}
+
+int	 CShaderAPIEmpty::NumPixelShaderConstants() const
+{
+	return 8;
+}
+
+int	 CShaderAPIEmpty::MaxNumLights() const
+{
+	return 4;
+}
+
+bool CShaderAPIEmpty::SupportsSpheremapping() const
+{
+	return false;
+}
+
+
+// This is the max dx support level supported by the card
+int	CShaderAPIEmpty::GetMaxDXSupportLevel() const
+{
+	return 90;
+}
+
+bool CShaderAPIEmpty::SupportsHardwareLighting() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 70))
+		return false;
+
+	return true;
+}
+
+int	 CShaderAPIEmpty::MaxBlendMatrices() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 70))
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+int	 CShaderAPIEmpty::MaxBlendMatrixIndices() const
+{
+	if ((ShaderUtil()->GetConfig().dxSupportLevel > 0) &&
+	    (ShaderUtil()->GetConfig().dxSupportLevel < 70))
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+int	 CShaderAPIEmpty::MaxVertexShaderBlendMatrices() const
+{
+	return 0;
+}
+
+int	CShaderAPIEmpty::MaxUserClipPlanes() const
+{
+	return 0;
+}
+
+bool CShaderAPIEmpty::SpecifiesFogColorInLinearSpace() const
+{
+	return false;
+}
+
+bool CShaderAPIEmpty::SupportsSRGB() const
+{
+	return false;
+}
+
+bool CShaderAPIEmpty::FakeSRGBWrite() const
+{
+	return false;
+}
+
+bool CShaderAPIEmpty::CanDoSRGBReadFromRTs() const
+{
+	return true;
+}
+
+bool CShaderAPIEmpty::SupportsGLMixedSizeTargets() const
+{
+	return false;
+}
+
+const char *CShaderAPIEmpty::GetHWSpecificShaderDLLName() const
+{
+	return 0;
+}
+
+// Sets the default *dynamic* state
+void CShaderAPIEmpty::SetDefaultState()
+{
+}
+
+
+// Returns the snapshot id for the shader state
+StateSnapshot_t	 CShaderAPIEmpty::TakeSnapshot( )
+{
+	StateSnapshot_t id = 0;
+	if (g_ShaderShadow.m_IsTranslucent)
+		id |= TRANSLUCENT;
+	if (g_ShaderShadow.m_IsAlphaTested)
+		id |= ALPHATESTED;
+	if (g_ShaderShadow.m_bUsesVertexAndPixelShaders)
+		id |= VERTEX_AND_PIXEL_SHADERS;
+	if (g_ShaderShadow.m_bIsDepthWriteEnabled)
+		id |= DEPTHWRITE;
+	return id;
+}
+
+// Returns true if the state snapshot is transparent
+bool CShaderAPIEmpty::IsTranslucent( StateSnapshot_t id ) const
+{
+	return (id & TRANSLUCENT) != 0; 
+}
+
+bool CShaderAPIEmpty::IsAlphaTested( StateSnapshot_t id ) const
+{
+	return (id & ALPHATESTED) != 0; 
+}
+
+bool CShaderAPIEmpty::IsDepthWriteEnabled( StateSnapshot_t id ) const
+{
+	return (id & DEPTHWRITE) != 0; 
+}
+
+bool CShaderAPIEmpty::UsesVertexAndPixelShaders( StateSnapshot_t id ) const
+{
+	return (id & VERTEX_AND_PIXEL_SHADERS) != 0; 
+}
+
+// Gets the vertex format for a set of snapshot ids
+VertexFormat_t CShaderAPIEmpty::ComputeVertexFormat( int numSnapshots, StateSnapshot_t* pIds ) const
+{
+	return 0;
+}
+
+// Gets the vertex format for a set of snapshot ids
+VertexFormat_t CShaderAPIEmpty::ComputeVertexUsage( int numSnapshots, StateSnapshot_t* pIds ) const
+{
+	return 0;
+}
+
+// Uses a state snapshot
+void CShaderAPIEmpty::UseSnapshot( StateSnapshot_t snapshot )
+{
+}
+
+// Sets the color to modulate by
+void CShaderAPIEmpty::Color3f( float r, float g, float b )
+{
+}
+
+void CShaderAPIEmpty::Color3fv( float const* pColor )
+{
+}
+
+void CShaderAPIEmpty::Color4f( float r, float g, float b, float a )
+{
+}
+
+void CShaderAPIEmpty::Color4fv( float const* pColor )
+{
+}
+
+// Faster versions of color
+void CShaderAPIEmpty::Color3ub( unsigned char r, unsigned char g, unsigned char b )
+{
+}
+
+void CShaderAPIEmpty::Color3ubv( unsigned char const* rgb )
+{
+}
+
+void CShaderAPIEmpty::Color4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a )
+{
+}
+
+void CShaderAPIEmpty::Color4ubv( unsigned char const* rgba )
+{
+}
+
+// The shade mode
+void CShaderAPIEmpty::ShadeMode( ShaderShadeMode_t mode )
+{
+}
+
+// Binds a particular material to render with
+void CShaderAPIEmpty::Bind( IMaterial* pMaterial )
+{
+}
+
+// Cull mode
+void CShaderAPIEmpty::CullMode( MaterialCullMode_t cullMode )
+{
+}
+
+void CShaderAPIEmpty::ForceDepthFuncEquals( bool bEnable )
+{
+}
+
+// Forces Z buffering on or off
+void CShaderAPIEmpty::OverrideDepthEnable( bool bEnable, bool bDepthEnable )
+{
+}
+
+void CShaderAPIEmpty::OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable )
+{
+}
+
+void CShaderAPIEmpty::OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable )
+{
+}
+
+//legacy fast clipping linkage
+void CShaderAPIEmpty::SetHeightClipZ( float z )
+{
+}
+
+void CShaderAPIEmpty::SetHeightClipMode( enum MaterialHeightClipMode_t heightClipMode )
+{
+}
+
+// Sets the lights
+void CShaderAPIEmpty::SetLight( int lightNum, const LightDesc_t& desc )
+{
+}
+
+// Sets lighting origin for the current model
+void CShaderAPIEmpty::SetLightingOrigin( Vector vLightingOrigin )
+{
+}
+
+void CShaderAPIEmpty::SetAmbientLight( float r, float g, float b )
+{
+}
+
+void CShaderAPIEmpty::SetAmbientLightCube( Vector4D cube[6] )
+{
+}
+
+// Get lights
+int CShaderAPIEmpty::GetMaxLights( void ) const
+{
+	return 0;
+}
+
+const LightDesc_t& CShaderAPIEmpty::GetLight( int lightNum ) const
+{
+	static LightDesc_t blah;
+	return blah;
+}
+
+// Render state for the ambient light cube (vertex shaders)
+void CShaderAPIEmpty::SetVertexShaderStateAmbientLightCube()
+{
+}
+
+void CShaderAPIEmpty::SetSkinningMatrices()
+{
+}
+
+// Lightmap texture binding
+void CShaderAPIEmpty::BindLightmap( TextureStage_t stage )
+{
+}
+
+void CShaderAPIEmpty::BindBumpLightmap( TextureStage_t stage )
+{
+}
+
+void CShaderAPIEmpty::BindFullbrightLightmap( TextureStage_t stage )
+{
+}
+
+void CShaderAPIEmpty::BindWhite( TextureStage_t stage )
+{
+}
+
+void CShaderAPIEmpty::BindBlack( TextureStage_t stage )
+{
+}
+
+void CShaderAPIEmpty::BindGrey( TextureStage_t stage )
+{
+}
+
+// Gets the lightmap dimensions
+void CShaderAPIEmpty::GetLightmapDimensions( int *w, int *h )
+{
+	g_pShaderUtil->GetLightmapDimensions( w, h );
+}
+
+// Special system flat normal map binding.
+void CShaderAPIEmpty::BindFlatNormalMap( TextureStage_t stage )
+{
+}
+
+void CShaderAPIEmpty::BindNormalizationCubeMap( TextureStage_t stage )
+{
+}
+
+void CShaderAPIEmpty::BindSignedNormalizationCubeMap( TextureStage_t stage )
+{
+}
+
+void CShaderAPIEmpty::BindFBTexture( TextureStage_t stage, int textureIndex )
+{
+}
+
+// Flushes any primitives that are buffered
+void CShaderAPIEmpty::FlushBufferedPrimitives()
+{
+}
+
+// Gets the dynamic mesh; 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.
+IMesh* CShaderAPIEmpty::GetDynamicMesh( IMaterial* pMaterial, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride )
+{
+	return &m_Mesh;
+}
+
+IMesh* CShaderAPIEmpty::GetDynamicMeshEx( IMaterial* pMaterial, VertexFormat_t fmt, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride )
+{
+	return &m_Mesh;
+}
+
+IMesh* CShaderAPIEmpty::GetFlexMesh()
+{
+	return &m_Mesh;
+}
+
+// Begins a rendering pass that uses a state snapshot
+void CShaderAPIEmpty::BeginPass( StateSnapshot_t snapshot  )
+{
+}
+
+// Renders a single pass of a material
+void CShaderAPIEmpty::RenderPass( int nPass, int nPassCount )
+{
+}
+
+// stuff related to matrix stacks
+void CShaderAPIEmpty::MatrixMode( MaterialMatrixMode_t matrixMode )
+{
+}
+
+void CShaderAPIEmpty::PushMatrix()
+{
+}
+
+void CShaderAPIEmpty::PopMatrix()
+{
+}
+
+void CShaderAPIEmpty::LoadMatrix( float *m )
+{
+}
+
+void CShaderAPIEmpty::MultMatrix( float *m )
+{
+}
+
+void CShaderAPIEmpty::MultMatrixLocal( float *m )
+{
+}
+
+void CShaderAPIEmpty::GetMatrix( MaterialMatrixMode_t matrixMode, float *dst )
+{
+}
+
+void CShaderAPIEmpty::LoadIdentity( void )
+{
+}
+
+void CShaderAPIEmpty::LoadCameraToWorld( void )
+{
+}
+
+void CShaderAPIEmpty::Ortho( double left, double top, double right, double bottom, double zNear, double zFar )
+{
+}
+
+void CShaderAPIEmpty::PerspectiveX( double fovx, double aspect, double zNear, double zFar )
+{
+}
+
+void CShaderAPIEmpty::PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right )
+{
+}
+
+void CShaderAPIEmpty::PickMatrix( int x, int y, int width, int height )
+{
+}
+
+void CShaderAPIEmpty::Rotate( float angle, float x, float y, float z )
+{
+}
+
+void CShaderAPIEmpty::Translate( float x, float y, float z )
+{
+}
+
+void CShaderAPIEmpty::Scale( float x, float y, float z )
+{
+}
+
+void CShaderAPIEmpty::ScaleXY( float x, float y )
+{
+}
+
+// Fog methods...
+void CShaderAPIEmpty::FogMode( MaterialFogMode_t fogMode )
+{
+}
+
+void CShaderAPIEmpty::FogStart( float fStart )
+{
+}
+
+void CShaderAPIEmpty::FogEnd( float fEnd )
+{
+}
+
+void CShaderAPIEmpty::SetFogZ( float fogZ )
+{
+}
+	
+void CShaderAPIEmpty::FogMaxDensity( float flMaxDensity )
+{
+}
+
+void CShaderAPIEmpty::GetFogDistances( float *fStart, float *fEnd, float *fFogZ )
+{
+}
+
+
+void CShaderAPIEmpty::SceneFogColor3ub( unsigned char r, unsigned char g, unsigned char b )
+{
+}
+
+
+void CShaderAPIEmpty::SceneFogMode( MaterialFogMode_t fogMode )
+{
+}
+
+void CShaderAPIEmpty::GetSceneFogColor( unsigned char *rgb )
+{
+}
+
+MaterialFogMode_t CShaderAPIEmpty::GetSceneFogMode( )
+{
+	return MATERIAL_FOG_NONE;
+}
+
+int CShaderAPIEmpty::GetPixelFogCombo( )
+{
+	return 0;
+}
+
+void CShaderAPIEmpty::FogColor3f( float r, float g, float b )
+{
+}
+
+void CShaderAPIEmpty::FogColor3fv( float const* rgb )
+{
+}
+
+void CShaderAPIEmpty::FogColor3ub( unsigned char r, unsigned char g, unsigned char b )
+{
+}
+
+void CShaderAPIEmpty::FogColor3ubv( unsigned char const* rgb )
+{
+}
+
+void CShaderAPIEmpty::SetViewports( int nCount, const ShaderViewport_t* pViewports )
+{
+}
+
+int CShaderAPIEmpty::GetViewports( ShaderViewport_t* pViewports, int nMax ) const
+{
+	return 1;
+}
+
+// Sets the vertex and pixel shaders
+void CShaderAPIEmpty::SetVertexShaderIndex( int vshIndex )
+{
+}
+
+void CShaderAPIEmpty::SetPixelShaderIndex( int pshIndex )
+{
+}
+
+// Sets the constant registers for vertex and pixel shaders
+void CShaderAPIEmpty::SetVertexShaderConstant( int var, float const* pVec, int numConst, bool bForce )
+{
+}
+
+void CShaderAPIEmpty::SetBooleanVertexShaderConstant( int var, BOOL const* pVec, int numConst, bool bForce )
+{
+}
+
+void CShaderAPIEmpty::SetIntegerVertexShaderConstant( int var, int const* pVec, int numConst, bool bForce )
+{
+}
+
+void CShaderAPIEmpty::SetPixelShaderConstant( int var, float const* pVec, int numConst, bool bForce )
+{
+}
+
+void CShaderAPIEmpty::SetBooleanPixelShaderConstant( int var, BOOL const* pVec, int numBools, bool bForce )
+{
+}
+
+void CShaderAPIEmpty::SetIntegerPixelShaderConstant( int var, int const* pVec, int numIntVecs, bool bForce )
+{
+}
+
+void CShaderAPIEmpty::InvalidateDelayedShaderConstants( void )
+{
+}
+
+float CShaderAPIEmpty::GammaToLinear_HardwareSpecific( float fGamma ) const
+{
+	return 0.0f;
+}
+
+float CShaderAPIEmpty::LinearToGamma_HardwareSpecific( float fLinear ) const
+{
+	return 0.0f;
+}
+
+void CShaderAPIEmpty::SetLinearToGammaConversionTextures( ShaderAPITextureHandle_t hSRGBWriteEnabledTexture, ShaderAPITextureHandle_t hIdentityTexture )
+{
+}
+
+
+// Returns the nearest supported format
+ImageFormat CShaderAPIEmpty::GetNearestSupportedFormat( ImageFormat fmt, bool bFilteringRequired /* = true */ ) const
+{
+	return fmt;
+}
+
+ImageFormat CShaderAPIEmpty::GetNearestRenderTargetFormat( ImageFormat fmt ) const
+{
+	return fmt;
+}
+
+// Sets the texture state
+void CShaderAPIEmpty::BindTexture( Sampler_t stage, ShaderAPITextureHandle_t textureHandle )
+{
+}
+
+void CShaderAPIEmpty::ClearColor3ub( unsigned char r, unsigned char g, unsigned char b )
+{
+}
+
+void CShaderAPIEmpty::ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a )
+{
+}
+
+// Indicates we're going to be modifying this texture
+// TexImage2D, TexSubImage2D, TexWrap, TexMinFilter, and TexMagFilter
+// all use the texture specified by this function.
+void CShaderAPIEmpty::ModifyTexture( ShaderAPITextureHandle_t textureHandle )
+{
+}
+
+// Texture management methods
+void CShaderAPIEmpty::TexImage2D( int level, int cubeFace, ImageFormat dstFormat, int zOffset, int width, int height, 
+						 ImageFormat srcFormat, bool bSrcIsTiled, void *imageData )
+{
+}
+
+void CShaderAPIEmpty::TexSubImage2D( int level, int cubeFace, int xOffset, int yOffset, int zOffset, int width, int height,
+						 ImageFormat srcFormat, int srcStride, bool bSrcIsTiled, void *imageData )
+{
+}
+
+void CShaderAPIEmpty::TexImageFromVTF( IVTFTexture *pVTF, int iVTFFrame )
+{
+}
+
+bool CShaderAPIEmpty::TexLock( int level, int cubeFaceID, int xOffset, int yOffset, 
+								int width, int height, CPixelWriter& writer )
+{
+	return false;
+}
+
+void CShaderAPIEmpty::TexUnlock( )
+{
+}
+
+
+// These are bound to the texture, not the texture environment
+void CShaderAPIEmpty::TexMinFilter( ShaderTexFilterMode_t texFilterMode )
+{
+}
+
+void CShaderAPIEmpty::TexMagFilter( ShaderTexFilterMode_t texFilterMode )
+{
+}
+
+void CShaderAPIEmpty::TexWrap( ShaderTexCoordComponent_t coord, ShaderTexWrapMode_t wrapMode )
+{
+}
+
+void CShaderAPIEmpty::TexSetPriority( int priority )
+{
+}
+
+ShaderAPITextureHandle_t CShaderAPIEmpty::CreateTexture( 
+	int width, 
+	int height,
+	int depth,
+	ImageFormat dstImageFormat, 
+	int numMipLevels, 
+	int numCopies, 
+	int flags, 
+	const char *pDebugName,
+	const char *pTextureGroupName )
+{
+	return 0;
+}
+
+// Create a multi-frame texture (equivalent to calling "CreateTexture" multiple times, but more efficient)
+void CShaderAPIEmpty::CreateTextures( 
+							ShaderAPITextureHandle_t *pHandles,
+							int count,
+							int width, 
+							int height,
+							int depth,
+							ImageFormat dstImageFormat, 
+							int numMipLevels, 
+							int numCopies, 
+							int flags, 
+							const char *pDebugName,
+							const char *pTextureGroupName )
+{
+	for ( int k = 0; k < count; ++ k )
+		pHandles[ k ] = 0;
+}
+
+
+ShaderAPITextureHandle_t CShaderAPIEmpty::CreateDepthTexture( ImageFormat renderFormat, int width, int height, const char *pDebugName, bool bTexture )
+{
+	return 0;
+}
+
+void CShaderAPIEmpty::DeleteTexture( ShaderAPITextureHandle_t textureHandle )
+{
+}
+
+bool CShaderAPIEmpty::IsTexture( ShaderAPITextureHandle_t textureHandle )
+{
+	return true;
+}
+
+bool CShaderAPIEmpty::IsTextureResident( ShaderAPITextureHandle_t textureHandle )
+{
+	return false;
+}
+
+// stuff that isn't to be used from within a shader
+void CShaderAPIEmpty::ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil, int renderTargetWidth, int renderTargetHeight )
+{
+}
+
+void CShaderAPIEmpty::ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth )
+{
+}
+
+void CShaderAPIEmpty::ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth )
+{
+}
+
+void CShaderAPIEmpty::PerformFullScreenStencilOperation( void )
+{
+}
+
+void CShaderAPIEmpty::SetScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom, const bool bEnableScissor )
+{
+}
+
+void CShaderAPIEmpty::ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat )
+{
+}
+
+void CShaderAPIEmpty::ReadPixels( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *data, ImageFormat dstFormat, int nDstStride )
+{
+}
+
+void CShaderAPIEmpty::FlushHardware()
+{
+}
+
+void CShaderAPIEmpty::ResetRenderState( bool bFullReset )
+{
+}
+
+// Set the number of bone weights
+void CShaderAPIEmpty::SetNumBoneWeights( int numBones )
+{
+}
+
+void CShaderAPIEmpty::EnableHWMorphing( bool bEnable )
+{
+}
+
+// Selection mode methods
+int CShaderAPIEmpty::SelectionMode( bool selectionMode )
+{
+	return 0;
+}
+
+void CShaderAPIEmpty::SelectionBuffer( unsigned int* pBuffer, int size )
+{
+}
+
+void CShaderAPIEmpty::ClearSelectionNames( )
+{
+}
+
+void CShaderAPIEmpty::LoadSelectionName( int name )
+{
+}
+
+void CShaderAPIEmpty::PushSelectionName( int name )
+{
+}
+
+void CShaderAPIEmpty::PopSelectionName()
+{
+}
+
+
+// Use this to get the mesh builder that allows us to modify vertex data
+CMeshBuilder* CShaderAPIEmpty::GetVertexModifyBuilder()
+{
+	return 0;
+}
+
+// Board-independent calls, here to unify how shaders set state
+// Implementations should chain back to IShaderUtil->BindTexture(), etc.
+
+// Use this to begin and end the frame
+void CShaderAPIEmpty::BeginFrame()
+{
+}
+
+void CShaderAPIEmpty::EndFrame()
+{
+}
+
+// returns the current time in seconds....
+double CShaderAPIEmpty::CurrentTime() const
+{
+	return Sys_FloatTime();
+}
+
+// Get the current camera position in world space.
+void CShaderAPIEmpty::GetWorldSpaceCameraPosition( float * pPos ) const
+{
+}
+
+void CShaderAPIEmpty::ForceHardwareSync( void )
+{
+}
+
+void CShaderAPIEmpty::SetClipPlane( int index, const float *pPlane )
+{
+}
+
+void CShaderAPIEmpty::EnableClipPlane( int index, bool bEnable )
+{
+}
+
+void CShaderAPIEmpty::SetFastClipPlane( const float *pPlane )
+{
+}
+
+void CShaderAPIEmpty::EnableFastClip( bool bEnable )
+{
+}
+
+int CShaderAPIEmpty::GetCurrentNumBones( void ) const
+{
+	return 0;
+}
+
+bool CShaderAPIEmpty::IsHWMorphingEnabled( void ) const
+{
+	return false;
+}
+
+int CShaderAPIEmpty::GetCurrentLightCombo( void ) const
+{
+	return 0;
+}
+
+void CShaderAPIEmpty::GetDX9LightState( LightState_t *state ) const
+{
+	state->m_nNumLights = 0;
+	state->m_bAmbientLight = false;
+	state->m_bStaticLightVertex = false;
+	state->m_bStaticLightTexel = false;
+}
+
+MaterialFogMode_t CShaderAPIEmpty::GetCurrentFogType( void ) const
+{
+	return MATERIAL_FOG_NONE;
+}
+
+void CShaderAPIEmpty::RecordString( const char *pStr )
+{
+}
+
+bool CShaderAPIEmpty::ReadPixelsFromFrontBuffer() const
+{
+	return true;
+}
+
+bool CShaderAPIEmpty::PreferDynamicTextures() const
+{
+	return false;
+}
+
+bool CShaderAPIEmpty::PreferReducedFillrate() const
+{ 
+	return false; 
+}
+
+bool CShaderAPIEmpty::HasProjectedBumpEnv() const
+{
+	return true;
+}
+
+int  CShaderAPIEmpty::GetCurrentDynamicVBSize( void )
+{
+	return 0;
+}
+
+void CShaderAPIEmpty::DestroyVertexBuffers( bool bExitingLevel )
+{
+}
+
+void CShaderAPIEmpty::EvictManagedResources()
+{
+}
+
+void CShaderAPIEmpty::SetTextureTransformDimension( TextureStage_t textureStage, int dimension, bool projected )
+{
+}
+
+void CShaderAPIEmpty::SetBumpEnvMatrix( TextureStage_t textureStage, float m00, float m01, float m10, float m11 )
+{
+}
+
+void CShaderAPIEmpty::SyncToken( const char *pToken )
+{
+}
diff --git a/materialsystem/shaderapiempty/shaderapiempty.vpc b/materialsystem/shaderapiempty/shaderapiempty.vpc
new file mode 100644
index 0000000..fc7b9a9
--- /dev/null
+++ b/materialsystem/shaderapiempty/shaderapiempty.vpc
@@ -0,0 +1,38 @@
+//-----------------------------------------------------------------------------
+//	SHADEREMPTY.VPC
+//
+//	Project Script
+//-----------------------------------------------------------------------------
+
+$Macro SRCDIR		"..\.."
+$Macro OUTBINDIR	"$SRCDIR\..\game\bin"
+
+$Include "$SRCDIR\vpc_scripts\source_dll_base.vpc"
+
+$Configuration
+{
+	$Compiler
+	{
+		$AdditionalIncludeDirectories		"$BASE;..\"
+		$PreprocessorDefinitions			"$BASE;SHADER_DLL_EXPORT;PROTECTED_THINGS_ENABLE"
+	}
+
+	$Linker
+	{
+		$AdditionalDependencies				"$BASE odbc32.lib odbccp32.lib"
+		$SystemLibraries                                                        "iconv" [$OSXALL]
+	}
+}
+
+$Project "shaderapiempty"
+{
+	$Folder	"Source Files"
+	{
+		$File	"shaderapiempty.cpp"
+	}
+
+	$Folder	"Header Files"
+	{
+		$File	"$SRCDIR\public\tier0\platform.h"
+	}
+}