//========= 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( &desc ) ); Lock( numIndices, false, *static_cast( &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( &desc ) ); Lock( numIndices, false, *static_cast( &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 ) { }