diff options
Diffstat (limited to 'materialsystem/cmaterialsystem.h')
| -rw-r--r-- | materialsystem/cmaterialsystem.h | 736 |
1 files changed, 736 insertions, 0 deletions
diff --git a/materialsystem/cmaterialsystem.h b/materialsystem/cmaterialsystem.h new file mode 100644 index 0000000..a5c890d --- /dev/null +++ b/materialsystem/cmaterialsystem.h @@ -0,0 +1,736 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#ifndef CMATERIALSYSTEM_H +#define CMATERIALSYSTEM_H + +#include "tier1/delegates.h" + +#include "materialsystem_global.h" +#include "materialsystem/imaterialsystem.h" +#include "materialsystem/ishaderapi.h" +#include "imaterialinternal.h" +#include "imaterialsysteminternal.h" +#include "shaderapi/ishaderutil.h" +#include "materialsystem/deformations.h" + +#include "tier1/utlintrusivelist.h" +#include "utlvector.h" +#include "utldict.h" +#include "cmaterialdict.h" +#include "cmatlightmaps.h" +#include "cmatrendercontext.h" +#include "cmatqueuedrendercontext.h" +#include "materialsystem_global.h" + +#ifndef MATSYS_INTERNAL +#error "This file is private to the implementation of IMaterialSystem/IMaterialSystemInternal" +#endif + +#if defined( _WIN32 ) +#pragma once +#endif + +//----------------------------------------------------------------------------- + +class CJob; +class CTextureCompositor; +class IThreadPool; +struct DeferredUpdateLightmapInfo_t; + +// typedefs to allow use of delegation macros +typedef int LightmapOffset_t[2]; + +//----------------------------------------------------------------------------- + +extern CThreadFastMutex g_MatSysMutex; + +//----------------------------------------------------------------------------- +// The material system implementation +//----------------------------------------------------------------------------- + + +class CMaterialSystem : public CTier2AppSystem< IMaterialSystemInternal >, public IShaderUtil +{ + typedef CTier2AppSystem< IMaterialSystemInternal > BaseClass; +public: + + CMaterialSystem(); + ~CMaterialSystem(); + + //--------------------------------------------------------- + // Initialization and shutdown + //--------------------------------------------------------- + + // + // IAppSystem + // + virtual bool Connect( CreateInterfaceFn factory ); + virtual void Disconnect(); + virtual void * QueryInterface( const char *pInterfaceName ); + virtual InitReturnVal_t Init(); + virtual void Shutdown(); + + CreateInterfaceFn Init( const char* pShaderDLL, + IMaterialProxyFactory* pMaterialProxyFactory, + CreateInterfaceFn fileSystemFactory, + CreateInterfaceFn cvarFactory ); + + // Call this to set an explicit shader version to use + // Must be called before Init(). + void SetShaderAPI( const char *pShaderAPIDLL ); + + // Must be called before Init(), if you're going to call it at all... + void SetAdapter( int nAdapter, int nFlags ); + + void ModInit(); + void ModShutdown(); + +private: + // Used to dynamically load and unload the shader api + CreateInterfaceFn CreateShaderAPI( const char* pShaderDLL ); + void DestroyShaderAPI(); + + // Method to get at interfaces supported by the SHADDERAPI + void * QueryShaderAPI( const char *pInterfaceName ); + + // Initializes the color correction terms + void InitColorCorrection(); + + // force the thread mode to single threaded, synchronizes with render thread if running + void ForceSingleThreaded(); + + void ThreadRelease( ); + void ThreadAcquire( bool bForce = false ); + +public: + virtual void SetThreadMode( MaterialThreadMode_t nextThreadMode, int nServiceThread ); + virtual MaterialThreadMode_t GetThreadMode( ); // current thread mode + virtual bool IsRenderThreadSafe( ); + virtual bool AllowThreading( bool bAllow, int nServiceThread ); + virtual void ExecuteQueued(); + + //--------------------------------------------------------- + // Component accessors + //--------------------------------------------------------- + const CMatLightmaps * GetLightmaps() const { return &m_Lightmaps; } + CMatLightmaps * GetLightmaps() { return &m_Lightmaps; } + + IMatRenderContext * GetRenderContext(); + IMatRenderContext * CreateRenderContext( MaterialContextType_t type ); + IMatRenderContext * SetRenderContext( IMatRenderContext * ); + + const IMatRenderContextInternal * GetRenderContextInternal() const { IMatRenderContextInternal *pRenderContext = m_pRenderContext.Get(); return ( pRenderContext ) ? pRenderContext : &m_HardwareRenderContext; } + IMatRenderContextInternal * GetRenderContextInternal() { IMatRenderContextInternal *pRenderContext = m_pRenderContext.Get(); return ( pRenderContext ) ? pRenderContext : &m_HardwareRenderContext; } + + const CMaterialDict * GetMaterialDict() const { return &m_MaterialDict; } + CMaterialDict * GetMaterialDict() { return &m_MaterialDict; } + + virtual void ReloadFilesInList( IFileList *pFilesToReload ); + +public: + //--------------------------------------------------------- + // Config management + //--------------------------------------------------------- + + // IMaterialSystem + virtual IMaterialSystemHardwareConfig * GetHardwareConfig( const char *pVersion, int *returnCode ); + + // Get the current config for this video card (as last set by control panel or the default if not) + virtual bool UpdateConfig( bool forceUpdate ); + virtual bool OverrideConfig( const MaterialSystem_Config_t &config, bool bForceUpdate ); + const MaterialSystem_Config_t & GetCurrentConfigForVideoCard() const; + + // Gets *recommended* configuration information associated with the display card, + virtual bool GetRecommendedConfigurationInfo( int nDXLevel, KeyValues * pKeyValues ); + + // IShaderUtil + MaterialSystem_Config_t & GetConfig(); + +private: + //--------------------------------- + + // This is called when the config changes + void GenerateConfigFromConfigKeyValues( MaterialSystem_Config_t *pConfig, bool bOverwriteCommandLineValues ); + + // Read/write config into convars + void ReadConfigFromConVars( MaterialSystem_Config_t *pConfig ); + void WriteConfigIntoConVars( const MaterialSystem_Config_t &config ); + + // Write dxsupport info to configvars + void WriteConfigurationInfoToConVars( bool bOverwriteCommandLineValues = true ); + + +public: + // ----------------------------------------------------------- + // Device methods + // ----------------------------------------------------------- + int GetDisplayAdapterCount() const; + int GetCurrentAdapter() const; + char *GetDisplayDeviceName() const OVERRIDE; + void GetDisplayAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const; + int GetModeCount( int adapter ) const; + void GetModeInfo( int adapter, int mode, MaterialVideoMode_t& info ) const; + void AddModeChangeCallBack( ModeChangeCallbackFunc_t func ); + void RemoveModeChangeCallBack( ModeChangeCallbackFunc_t func ); + + // Returns the mode info for the current display device + void GetDisplayMode( MaterialVideoMode_t& info ) const; + bool SetMode( void* hwnd, const MaterialSystem_Config_t &config ); + + // Reports support for a given MSAA mode + bool SupportsMSAAMode( int nMSAAMode ); + + // Reports support for a given CSAA mode + bool SupportsCSAAMode( int nNumSamples, int nQualityLevel ); + + bool SupportsHDRMode( HDRType_t nHDRModede ); + + bool UsesSRGBCorrectBlending() const; + + // Reports support for shadow depth texturing + bool SupportsShadowDepthTextures( void ); + + // Reports support for fetch4 texture access (useful for shadow map PCF in shader) + bool SupportsFetch4( void ); + + // Vendor-dependent shadow depth texture format + ImageFormat GetShadowDepthTextureFormat( void ); + + // Vendor-dependent slim texture format + ImageFormat GetNullTextureFormat( void ); + + // Shadow depth bias factors + void SetShadowDepthBiasFactors( float fShadowSlopeScaleDepthBias, float fShadowDepthBias ); + + const MaterialSystemHardwareIdentifier_t &GetVideoCardIdentifier() const; + + // Use this to spew information about the 3D layer + void SpewDriverInfo() const; + + DELEGATE_TO_OBJECT_2V( GetDXLevelDefaults, uint &, uint &, g_pShaderAPI ); + + DELEGATE_TO_OBJECT_2VC( GetBackBufferDimensions, int &, int &, g_pShaderDevice ); + DELEGATE_TO_OBJECT_0C( ImageFormat, GetBackBufferFormat, g_pShaderDevice ); + + DELEGATE_TO_OBJECT_1V( PushDeformation, DeformationBase_t const *, g_pShaderAPI ); + + DELEGATE_TO_OBJECT_0V( PopDeformation, g_pShaderAPI ); + + DELEGATE_TO_OBJECT_0C(int, GetNumActiveDeformations, g_pShaderAPI ); + + // ----------------------------------------------------------- + // Window methods + // ----------------------------------------------------------- + // Creates/ destroys a child window + bool AddView( void* hwnd ); + void RemoveView( void* hwnd ); + + // Sets the view + void SetView( void* hwnd ); + + // ----------------------------------------------------------- + // Control flow + // ----------------------------------------------------------- + void BeginFrame( float frameTime ); + void EndFrame(); + virtual bool IsInFrame( ) const; + void Flush( bool flushHardware = false ); + void SwapBuffers(); + + // Flushes managed textures from the texture cacher + void EvictManagedResources(); + + void ReleaseResources(); + void ReacquireResources(); + + // Recomputes a state snapshot + void RecomputeAllStateSnapshots(); + + void NoteAnisotropicLevel( int currentLevel ); + + // ----------------------------------------------------------- + // Device loss/restore + // ----------------------------------------------------------- + // Installs a function to be called when we need to release vertex buffers + void AddReleaseFunc( MaterialBufferReleaseFunc_t func ); + void RemoveReleaseFunc( MaterialBufferReleaseFunc_t func ); + + // Installs a function to be called when we need to restore vertex buffers + void AddRestoreFunc( MaterialBufferRestoreFunc_t func ); + void RemoveRestoreFunc( MaterialBufferRestoreFunc_t func ); + + // Called by the shader API when it's just about to lose video memory + void ReleaseShaderObjects(); + void RestoreShaderObjects( CreateInterfaceFn shaderFactory, int nChangeFlags = 0 ); + + // Release temporary HW memory... + void ResetTempHWMemory( bool bExitingLevel = false ); + + // For dealing with device lost in cases where SwapBuffers isn't called all the time (Hammer) + void HandleDeviceLost(); + + + // ----------------------------------------------------------- + // Shaders + // ----------------------------------------------------------- + int ShaderCount() const; + int GetShaders( int nFirstShader, int nCount, IShader **ppShaderList ) const; + int ShaderFlagCount() const; + const char * ShaderFlagName( int nIndex ) const; + void GetShaderFallback( const char *pShaderName, char *pFallbackShader, int nFallbackLength ); + + + // ----------------------------------------------------------- + // Material proxies + // ----------------------------------------------------------- + IMaterialProxyFactory* GetMaterialProxyFactory(); + void SetMaterialProxyFactory( IMaterialProxyFactory* pFactory ); + + + // ----------------------------------------------------------- + // Editor mode + // ----------------------------------------------------------- + bool InEditorMode() const; + + // Used to enable editor materials. Must be called before Init. + void EnableEditorMaterials(); + + // Can we use editor materials? + bool CanUseEditorMaterials() const; + + + // ----------------------------------------------------------- + // Stub mode mode + // ----------------------------------------------------------- + void SetInStubMode( bool bInStubMode ); + bool IsInStubMode(); + + + //--------------------------------------------------------- + // Image formats + //--------------------------------------------------------- + ImageFormatInfo_t const& ImageFormatInfo( ImageFormat fmt) const; + + int GetMemRequired( int width, int height, int depth, ImageFormat format, bool mipmap ); + + bool ConvertImageFormat( unsigned char *src, enum ImageFormat srcImageFormat, + unsigned char *dst, enum ImageFormat dstImageFormat, + int width, int height, int srcStride = 0, int dstStride = 0 ); + + + //--------------------------------------------------------- + // Debug support + //--------------------------------------------------------- + void CreateDebugMaterials(); + void CleanUpDebugMaterials(); + void CleanUpErrorMaterial(); + + void DebugPrintUsedMaterials( const char *pSearchSubString, bool bVerbose ); + void DebugPrintUsedTextures(); + + void ToggleSuppressMaterial( const char* pMaterialName ); + void ToggleDebugMaterial( const char* pMaterialName ); + + + //--------------------------------------------------------- + // Compositor Support + //--------------------------------------------------------- + void CreateCompositorMaterials(); + void CleanUpCompositorMaterials(); + + //--------------------------------------------------------- + // Misc features + //--------------------------------------------------------- + + //returns whether fast clipping is being used or not - needed to be exposed for better per-object clip behavior + bool UsingFastClipping(); + + int StencilBufferBits(); + + + //--------------------------------------------------------- + // Standard material and textures + //--------------------------------------------------------- + void AllocateStandardTextures(); + void ReleaseStandardTextures(); + + IMaterialInternal * GetDrawFlatMaterial() { return m_pDrawFlatMaterial; } + IMaterialInternal * GetBufferClearObeyStencil( int i ) { return m_pBufferClearObeyStencil[i]; } + IMaterialInternal * GetRenderTargetBlitMaterial() { return m_pRenderTargetBlitMaterial; } + + ShaderAPITextureHandle_t GetFullbrightLightmapTextureHandle() const { return m_FullbrightLightmapTextureHandle; } + ShaderAPITextureHandle_t GetFullbrightBumpedLightmapTextureHandle() const { return m_FullbrightBumpedLightmapTextureHandle; } + ShaderAPITextureHandle_t GetBlackTextureHandle() const { return m_BlackTextureHandle; } + ShaderAPITextureHandle_t GetFlatNormalTextureHandle() const { return m_FlatNormalTextureHandle; } + ShaderAPITextureHandle_t GetGreyTextureHandle() const { return m_GreyTextureHandle; } + ShaderAPITextureHandle_t GetGreyAlphaZeroTextureHandle() const { return m_GreyAlphaZeroTextureHandle; } + ShaderAPITextureHandle_t GetWhiteTextureHandle() const { return m_WhiteTextureHandle; } + ShaderAPITextureHandle_t GetLinearToGammaTableTextureHandle() const { return m_LinearToGammaTableTextureHandle; } + ShaderAPITextureHandle_t GetLinearToGammaIdentityTableTextureHandle() const { return m_LinearToGammaIdentityTableTextureHandle; } + ShaderAPITextureHandle_t GetMaxDepthTextureHandle() const { return m_MaxDepthTextureHandle; } + + //--------------------------------------------------------- + // Material and texture management + //--------------------------------------------------------- + // Stop attempting to stream in textures in response to usage. Useful for phases such as loading or other explicit + // operations that shouldn't take usage of textures as a signal to stream them in at full rez. + void SuspendTextureStreaming( ); + void ResumeTextureStreaming( ); + void UncacheAllMaterials(); + void UncacheUnusedMaterials( bool bRecomputeStateSnapshots ); + void CacheUsedMaterials(); + void ReloadTextures(); + void ReloadMaterials( const char *pSubString = NULL ); + + // Create new materials (currently only used by the editor!) + IMaterial * CreateMaterial( const char *pMaterialName, KeyValues *pVMTKeyValues ); + IMaterial * FindMaterial( const char *materialName, const char *pTextureGroupName, bool complain = true, const char *pComplainPrefix = NULL ); + virtual IMaterial * FindMaterialEx( char const* pMaterialName, const char *pTextureGroupName, int nContext, bool complain = true, const char *pComplainPrefix = NULL ); + bool IsMaterialLoaded( const char *materialName ); + virtual IMaterial * FindProceduralMaterial( const char *pMaterialName, const char *pTextureGroupName, KeyValues *pVMTKeyValues ); + const char * GetForcedTextureLoadPathID() { return m_pForcedTextureLoadPathID; } + + void SetAsyncTextureLoadCache( void* h ); + void SetVMTFileLoadCache( void* h ); + + //--------------------------------- + + DELEGATE_TO_OBJECT_0C( MaterialHandle_t, FirstMaterial, &m_MaterialDict ); + DELEGATE_TO_OBJECT_1C( MaterialHandle_t, NextMaterial, MaterialHandle_t, &m_MaterialDict ); + DELEGATE_TO_OBJECT_0C( MaterialHandle_t, InvalidMaterial, &m_MaterialDict ); + DELEGATE_TO_OBJECT_1C( IMaterial *, GetMaterial, MaterialHandle_t, &m_MaterialDict ); + DELEGATE_TO_OBJECT_1C( IMaterialInternal *, GetMaterialInternal, MaterialHandle_t, &m_MaterialDict ); + DELEGATE_TO_OBJECT_0C( int, GetNumMaterials, &m_MaterialDict ); + DELEGATE_TO_OBJECT_1V( AddMaterialToMaterialList, IMaterialInternal *, &m_MaterialDict ); + DELEGATE_TO_OBJECT_1V( RemoveMaterial, IMaterialInternal *, &m_MaterialDict ); + DELEGATE_TO_OBJECT_1V( RemoveMaterialSubRect, IMaterialInternal *, &m_MaterialDict ); + + //--------------------------------- + + ITexture * FindTexture( char const* pTextureName, const char *pTextureGroupName, bool complain = true, int nAdditionalCreationFlags = 0 ); + + bool IsTextureLoaded( const char* pTextureName ) const; + + void AddTextureAlias( const char *pAlias, const char *pRealName ); + void RemoveTextureAlias( const char *pAlias ); + + void SetExcludedTextures( const char *pScriptName ); + void UpdateExcludedTextures( void ); + + // Creates a procedural texture + ITexture * CreateProceduralTexture( const char *pTextureName, + const char *pTextureGroupName, + int w, + int h, + ImageFormat fmt, + int nFlags ); + + // + // Render targets + // + void BeginRenderTargetAllocation(); + void EndRenderTargetAllocation(); // Simulate an Alt-Tab in here, which causes a release/restore of all resources + + // Creates a texture for use as a render target + ITexture * CreateRenderTargetTexture( int w, + int h, + RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change). + ImageFormat format, + MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED ); + + ITexture * CreateNamedRenderTargetTextureEx( const char *pRTName, // Pass in NULL here for an unnamed render target. + int w, + int h, + RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change). + ImageFormat format, + MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED, + unsigned int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT, + unsigned int renderTargetFlags = 0 ); + + ITexture * CreateNamedRenderTargetTexture( const char *pRTName, + int w, + int h, + RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change). + ImageFormat format, + MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED, + bool bClampTexCoords = true, + bool bAutoMipMap = false ); + + ITexture * CreateNamedRenderTargetTextureEx2( const char *pRTName, // Pass in NULL here for an unnamed render target. + int w, + int h, + RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change). + ImageFormat format, + MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED, + unsigned int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT, + unsigned int renderTargetFlags = 0 ); + + virtual ITexture* CreateTextureFromBits(int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits); + + virtual void OverrideRenderTargetAllocation( bool rtAlloc ); + + virtual ITextureCompositor* NewTextureCompositor( int w, int h, const char* pCompositeName, int nTeamNum, uint64 randomSeed, KeyValues* stageDesc, uint32 texCompositeCreateFlags ) OVERRIDE; + void ScheduleTextureComposite( CTextureCompositor* _texCompositor ); + + + virtual void SetRenderTargetFrameBufferSizeOverrides( int nWidth, int nHeight ) OVERRIDE; + virtual void GetRenderTargetFrameBufferDimensions( int & nWidth, int & nHeight ) OVERRIDE; + + virtual void AsyncFindTexture( const char* pFilename, const char *pTextureGroupName, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs, bool bComplain = true, int nAdditionalCreationFlags = 0 ) OVERRIDE; + virtual ITexture* CreateNamedTextureFromBitsEx( const char* pName, const char *pTextureGroupName, int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits, int nFlags ) OVERRIDE; + + virtual bool AddTextureCompositorTemplate( const char* pName, KeyValues* pTmplDesc, int nTexCompositeTemplateFlags = 0 ) OVERRIDE; + virtual bool VerifyTextureCompositorTemplates() OVERRIDE; + + + + + // ----------------------------------------------------------- + + bool OnDrawMesh( IMesh *pMesh, int firstIndex, int numIndices ); + bool OnDrawMesh( IMesh *pMesh, CPrimList *pLists, int nLists ); + DELEGATE_TO_OBJECT_3( bool, OnSetFlexMesh, IMesh *, IMesh *, int, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_3( bool, OnSetColorMesh, IMesh *, IMesh *, int, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_2( bool, OnSetPrimitiveType, IMesh *, MaterialPrimitiveType_t, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_0V( SyncMatrices, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_1V( SyncMatrix, MaterialMatrixMode_t, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_0( bool, OnFlushBufferedPrimitives, GetRenderContextInternal() ); + void OnThreadEvent( uint32 threadEvent ); + ShaderAPITextureHandle_t GetShaderAPITextureBindHandle( ITexture *pTexture, int nFrame, int nTextureChannel ); // JasonM ???? + + + + // ----------------------------------------------------------- + // Lightmaps delegates + // ----------------------------------------------------------- + DELEGATE_TO_OBJECT_0V( BeginLightmapAllocation, &m_Lightmaps ); + + void EndLightmapAllocation() + { + GetLightmaps()->EndLightmapAllocation(); + AllocateStandardTextures(); + } + + DELEGATE_TO_OBJECT_4( int, AllocateLightmap, int, int, LightmapOffset_t, IMaterial *, &m_Lightmaps ); + DELEGATE_TO_OBJECT_1( int, AllocateWhiteLightmap, IMaterial *, &m_Lightmaps ); + DELEGATE_TO_OBJECT_3( int, AllocateDynamicLightmap, LightmapOffset_t, int *, int, &m_Lightmaps ); + void UpdateLightmap( int, LightmapOffset_t, LightmapOffset_t, float *, float *, float *, float * ); + DELEGATE_TO_OBJECT_0( int, GetNumSortIDs, &m_Lightmaps ); + DELEGATE_TO_OBJECT_1V( GetSortInfo, MaterialSystem_SortInfo_t *, &m_Lightmaps ); + DELEGATE_TO_OBJECT_3VC( GetLightmapPageSize, int, int *, int *, &m_Lightmaps ); + DELEGATE_TO_OBJECT_0V( ResetMaterialLightmapPageInfo, &m_Lightmaps ); + DELEGATE_TO_OBJECT_1C( int, GetLightmapWidth, int, &m_Lightmaps ); + DELEGATE_TO_OBJECT_1C( int, GetLightmapHeight, int, &m_Lightmaps ); + DELEGATE_TO_OBJECT_0V( BeginUpdateLightmaps, &m_Lightmaps ); + DELEGATE_TO_OBJECT_0V( EndUpdateLightmaps, &m_Lightmaps ); + + // ----------------------------------------------------------- + // Render context delegates + // ----------------------------------------------------------- + + // IMaterialSystem + DELEGATE_TO_OBJECT_3V( ClearBuffers, bool, bool, bool, GetRenderContextInternal() ); + + // IMaterialSystemInternal + DELEGATE_TO_OBJECT_0( IMaterial *, GetCurrentMaterial, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_0( int, GetLightmapPage, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_0( ITexture *, GetLocalCubemap, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_1V( ForceDepthFuncEquals, bool, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_0( MaterialHeightClipMode_t, GetHeightClipMode, GetRenderContextInternal() ); + DELEGATE_TO_OBJECT_0C( bool, InFlashlightMode, GetRenderContextInternal() ); + + // IShaderUtil + DELEGATE_TO_OBJECT_2V( BindStandardTexture, Sampler_t, StandardTextureId_t, &m_HardwareRenderContext ); + DELEGATE_TO_OBJECT_2V( BindStandardVertexTexture, VertexTextureSampler_t, StandardTextureId_t, &m_HardwareRenderContext ); + DELEGATE_TO_OBJECT_2V( GetLightmapDimensions, int *, int *, &m_HardwareRenderContext ); + DELEGATE_TO_OBJECT_3V( GetStandardTextureDimensions, int *, int *, StandardTextureId_t, &m_HardwareRenderContext ); + DELEGATE_TO_OBJECT_0( MorphFormat_t, GetBoundMorphFormat, &m_HardwareRenderContext ); + DELEGATE_TO_OBJECT_1( ITexture *, GetRenderTargetEx, int, &m_HardwareRenderContext ); + DELEGATE_TO_OBJECT_7V( DrawClearBufferQuad, unsigned char, unsigned char, unsigned char, unsigned char, bool, bool, bool, &m_HardwareRenderContext ); + DELEGATE_TO_OBJECT_0C( int, MaxHWMorphBatchCount, g_pMorphMgr ); + DELEGATE_TO_OBJECT_1V( GetCurrentColorCorrection, ShaderColorCorrectionInfo_t*, g_pColorCorrectionSystem ); + +#if defined( _X360 ) + void ListUsedMaterials(); + HXUIFONT OpenTrueTypeFont( const char *pFontname, int tall, int style ); + void CloseTrueTypeFont( HXUIFONT hFont ); + bool GetTrueTypeFontMetrics( HXUIFONT hFont, XUIFontMetrics *pFontMetrics, XUICharMetrics charMetrics[256] ); + // Render a sequence of characters and extract the data into a buffer + // For each character, provide the width+height of the font texture subrect, + // an offset to apply when rendering the glyph, and an offset into a buffer to receive the RGBA data + bool GetTrueTypeGlyphs( HXUIFONT hFont, int numChars, wchar_t *pWch, int *pOffsetX, int *pOffsetY, int *pWidth, int *pHeight, unsigned char *pRGBA, int *pOffset ); + void ReadBackBuffer( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *pData, ImageFormat dstFormat, int nDstStride ); + void PersistDisplay(); + void *GetD3DDevice(); + bool OwnGPUResources( bool bEnable ); +#endif + + MaterialLock_t Lock(); + void Unlock( MaterialLock_t ); + CMatCallQueue * GetRenderCallQueue(); + uint GetRenderThreadId() const { return m_nRenderThreadID; } + void UnbindMaterial( IMaterial *pMaterial ); + + IMaterialProxy *DetermineProxyReplacements( IMaterial *pMaterial, KeyValues *pFallbackKeyValues ); + void LoadReplacementMaterials(); + void ScanDirForReplacements( const char *pszPathName ); + void InitReplacementsFromFile( const char *pszPathName ); + + void PreloadReplacements( ); + CUtlDict< KeyValues *, int > m_Replacements; + + virtual void CompactMemory(); + +private: + void OnRenderingAsyncComplete(); + + // ----------------------------------------------------------- +private: + CON_COMMAND_MEMBER_F( CMaterialSystem, "mat_showmaterials", DebugPrintUsedMaterials, "Show materials.", 0 ); + CON_COMMAND_MEMBER_F( CMaterialSystem, "mat_showmaterialsverbose", DebugPrintUsedMaterialsVerbose, "Show materials (verbose version).", 0 ); + CON_COMMAND_MEMBER_F( CMaterialSystem, "mat_showtextures", DebugPrintUsedTextures, "Show used textures.", 0 ); + CON_COMMAND_MEMBER_F( CMaterialSystem, "mat_reloadallmaterials", ReloadAllMaterials, "Reloads all materials", FCVAR_CHEAT ); + CON_COMMAND_MEMBER_F( CMaterialSystem, "mat_reloadmaterial", ReloadMaterials, "Reloads a single material", FCVAR_CHEAT ); + CON_COMMAND_MEMBER_F( CMaterialSystem, "mat_reloadtextures", ReloadTextures, "Reloads all textures", FCVAR_CHEAT ); + +#if defined( _X360 ) + CON_COMMAND_MEMBER_F( CMaterialSystem, "mat_material_list", ListUsedMaterials, "Show used textures.", 0 ); +#endif + + friend void* InstantiateMaterialSystemV76Interface(); + friend CMaterialSystem *CMatLightmaps::GetMaterialSystem() const; + + void ThreadExecuteQueuedContext( CMatQueuedRenderContext *pContext ); + + IThreadPool * CreateMatQueueThreadPool(); + void DestroyMatQueueThreadPool(); + +#ifdef DX_TO_GL_ABSTRACTION + void DoStartupShaderPreloading( void ); +#endif + + // ----------------------------------------------------------- + + CMaterialDict m_MaterialDict; + CMatLightmaps m_Lightmaps; + CThreadLocal<IMatRenderContextInternal *> m_pRenderContext; + CMatRenderContext m_HardwareRenderContext; + + CMatQueuedRenderContext m_QueuedRenderContexts[2]; + int m_iCurQueuedContext; + + MaterialThreadMode_t m_ThreadMode; + MaterialThreadMode_t m_IdealThreadMode; + bool m_bThreadingNotAvailable; // this is true if the VirtualAlloc()'s in the threading fail to allocate + int m_nServiceThread; + + //--------------------------------- + + char * m_pShaderDLL; + CSysModule * m_ShaderHInst; // Used to dynamically load the shader DLL + CreateInterfaceFn m_ShaderAPIFactory; + + int m_nAdapter; + int m_nAdapterFlags; + + //--------------------------------- + + IMaterialProxyFactory * m_pMaterialProxyFactory; + + //--------------------------------- + // Callback methods for releasing + restoring video memory + CUtlVector< MaterialBufferReleaseFunc_t > m_ReleaseFunc; + CUtlVector< MaterialBufferRestoreFunc_t > m_RestoreFunc; + + //--------------------------------- + + bool m_bRequestedEditorMaterials; + bool m_bCanUseEditorMaterials; + + //--------------------------------- + + // Store texids for various things + ShaderAPITextureHandle_t m_FullbrightLightmapTextureHandle; + ShaderAPITextureHandle_t m_FullbrightBumpedLightmapTextureHandle; + ShaderAPITextureHandle_t m_BlackTextureHandle; + ShaderAPITextureHandle_t m_FlatNormalTextureHandle; + ShaderAPITextureHandle_t m_GreyTextureHandle; + ShaderAPITextureHandle_t m_GreyAlphaZeroTextureHandle; + ShaderAPITextureHandle_t m_WhiteTextureHandle; + ShaderAPITextureHandle_t m_LinearToGammaTableTextureHandle; //linear to gamma srgb conversion lookup for the current hardware + ShaderAPITextureHandle_t m_LinearToGammaIdentityTableTextureHandle; //An identity lookup for when srgb writes are off + ShaderAPITextureHandle_t m_MaxDepthTextureHandle; //a 1x1 texture with maximum depth values. + + // Have we allocated the standard lightmaps? + bool m_StandardTexturesAllocated; + + + bool m_bReplacementFilesValid; + + //--------------------------------- + // Shared materials used for debugging.... + //--------------------------------- + + enum BufferClearType_t //bClearColor + ( bClearAlpha << 1 ) + ( bClearDepth << 2 ) + { + BUFFER_CLEAR_NONE, + BUFFER_CLEAR_COLOR, + BUFFER_CLEAR_ALPHA, + BUFFER_CLEAR_COLOR_AND_ALPHA, + BUFFER_CLEAR_DEPTH, + BUFFER_CLEAR_COLOR_AND_DEPTH, + BUFFER_CLEAR_ALPHA_AND_DEPTH, + BUFFER_CLEAR_COLOR_AND_ALPHA_AND_DEPTH, + + BUFFER_CLEAR_TYPE_COUNT + }; + + IMaterialInternal * m_pBufferClearObeyStencil[BUFFER_CLEAR_TYPE_COUNT]; + IMaterialInternal * m_pDrawFlatMaterial; + IMaterialInternal * m_pRenderTargetBlitMaterial; + CUtlVector< IMaterialInternal* > m_pCompositorMaterials; + + //--------------------------------- + + const char * m_pForcedTextureLoadPathID; + FileCacheHandle_t m_hAsyncLoadFileCache; + uint m_nRenderThreadID; + bool m_bAllocatingRenderTargets; + bool m_bInStubMode; + bool m_bGeneratedConfig; + bool m_bInFrame; + bool m_bForcedSingleThreaded; + bool m_bAllowQueuedRendering; + volatile bool m_bThreadHasOwnership; + uint m_ThreadOwnershipID; + + //--------------------------------- + + CJob * m_pActiveAsyncJob; + CUtlVector<uint32> m_threadEvents; + + IThreadPool * m_pMatQueueThreadPool; + + //--------------------------------- + + int m_nRenderTargetFrameBufferWidthOverride; + int m_nRenderTargetFrameBufferHeightOverride; + + CUtlVector< CTextureCompositor* > m_scheduledComposites; + CUtlVector< CTextureCompositor* > m_pendingComposites; +}; + +//----------------------------------------------------------------------------- + +inline CMaterialSystem *CMatLightmaps::GetMaterialSystem() const +{ + return GET_OUTER( CMaterialSystem, m_Lightmaps ); +} + +//----------------------------------------------------------------------------- + +#endif // CMATERIALSYSTEM_H |