d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
521 Commits
25 Branches
6 Tags
221 MiB
Tree: b9cf6b2c7e
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b9cf6b2c7e'
${ noResults }
source-engine/materialsystem/shaderapiempty/shaderapiempty.cpp

2957 lines
76 KiB
Raw Normal View History Unescape

1
5 years ago
//========= 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 )
{
}