//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ // //=============================================================================// #ifndef CMATERIAL_QUEUEFRIENDLY_H #define CMATERIAL_QUEUEFRIENDLY_H #ifdef _WIN32 #pragma once #endif #include "imaterialinternal.h" class CMaterial_QueueFriendly : public IMaterialInternal //wraps a CMaterial with queue friendly functions for game/engine code. materialsystem/shaderapi code should use CMaterial directly. { public: virtual const char * GetName() const; virtual const char * GetTextureGroupName() const; virtual PreviewImageRetVal_t GetPreviewImageProperties( int *width, int *height, ImageFormat *imageFormat, bool* isTranslucent ) const; virtual PreviewImageRetVal_t GetPreviewImage( unsigned char *data, int width, int height, ImageFormat imageFormat ) const; virtual int GetMappingWidth( ); virtual int GetMappingHeight( ); virtual int GetNumAnimationFrames( ); virtual bool InMaterialPage( void ); virtual void GetMaterialOffset( float *pOffset ); virtual void GetMaterialScale( float *pScale ); virtual IMaterial *GetMaterialPage( void ); virtual void IncrementReferenceCount( void ); virtual int GetEnumerationID( void ) const; virtual bool HasProxy( void ) const; virtual void GetReflectivity( Vector& reflect ); virtual bool GetPropertyFlag( MaterialPropertyTypes_t type ); virtual bool IsTwoSided(); virtual int ShaderParamCount() const; virtual bool IsErrorMaterial() const; //should probably return the realtime error material instead of this wrapper for it virtual bool IsSpriteCard(); //lets just assume nobody changes the shader to spritecard and immediately asks if it's a spritecard //TODO: Investigate if these are likely to change at all when setting vars/flags virtual bool IsAlphaTested(); virtual bool IsVertexLit(); virtual VertexFormat_t GetVertexFormat() const; virtual bool UsesEnvCubemap( void ); virtual bool NeedsTangentSpace( void ); virtual bool NeedsSoftwareSkinning( void ); virtual int GetNumPasses( void ); virtual int GetTextureMemoryBytes( void ); virtual bool NeedsLightmapBlendAlpha( void ); virtual bool NeedsSoftwareLighting( void ); //TODO: Investigate if this can change over the course of a frame. virtual void GetLowResColorSample( float s, float t, float *color ) const; //Functions that need to be queue friendly, the whole reason for this wrapper class. virtual IMaterialVar * FindVar( const char *varName, bool *found, bool complain = true ); virtual IMaterialVar * FindVarFast( char const *pVarName, unsigned int *pToken ); virtual IMaterialVar **GetShaderParams( void ); virtual void DecrementReferenceCount( void ); virtual void DeleteIfUnreferenced(); virtual void RecomputeStateSnapshots(); virtual bool IsTranslucent(); virtual bool IsTranslucentUnderModulation( float fAlphaModulation ) const; virtual bool NeedsPowerOfTwoFrameBufferTexture( bool bCheckSpecificToThisFrame = true ); virtual bool NeedsFullFrameBufferTexture( bool bCheckSpecificToThisFrame = true ); virtual void AlphaModulate( float alpha ); virtual void ColorModulate( float r, float g, float b ); virtual void SetMaterialVarFlag( MaterialVarFlags_t flag, bool on ); virtual bool GetMaterialVarFlag( MaterialVarFlags_t flag ) const; virtual void SetShader( const char *pShaderName ); virtual void SetShaderAndParams( KeyValues *pKeyValues ); virtual const char * GetShaderName() const; virtual void Refresh(); virtual void RefreshPreservingMaterialVars(); virtual float GetAlphaModulation(); virtual void GetColorModulation( float *r, float *g, float *b ); virtual void CallBindProxy( void *proxyData, ICallQueue *pCallQueue ); virtual void PrecacheMappingDimensions( ); virtual void FindRepresentativeTexture( void ); virtual bool WasReloadedFromWhitelist() { return m_pRealTimeVersion->WasReloadedFromWhitelist(); } #define QUEUEFRIENDLY_USED_INTERNALLY_ASSERT AssertMsg( 0, "CMaterial_QueueFriendly used internally within materialsystem. Update the calling code to use a realtime CMaterial." ) //------------------------------------------------------------------------------ // IMaterialInternal interfaces. Internal systems should not be using this queue // wrapper class at all. Switch to the real time pointer in the calling code. //------------------------------------------------------------------------------ virtual int GetReferenceCount( ) const { return m_pRealTimeVersion->GetReferenceCount(); } virtual void SetEnumerationID( int id ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->SetEnumerationID( id ); } virtual void SetNeedsWhiteLightmap( bool val ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->SetNeedsWhiteLightmap( val ); } virtual bool GetNeedsWhiteLightmap( ) const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->GetNeedsWhiteLightmap(); } virtual void Uncache( bool bPreserveVars = false ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->Uncache( bPreserveVars ); } virtual void Precache() { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->Precache(); } // If provided, pKeyValues and pPatchKeyValues should come from LoadVMTFile() virtual bool PrecacheVars( KeyValues *pKeyValues = NULL, KeyValues *pPatchKeyValues = NULL, CUtlVector *pIncludes = NULL ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->PrecacheVars( pKeyValues, pPatchKeyValues, pIncludes ); } virtual void ReloadTextures() { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->ReloadTextures(); } virtual void SetMinLightmapPageID( int pageID ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->SetMinLightmapPageID( pageID ); } virtual void SetMaxLightmapPageID( int pageID ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->SetMaxLightmapPageID( pageID ); } virtual int GetMinLightmapPageID( ) const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->GetMinLightmapPageID(); } virtual int GetMaxLightmapPageID( ) const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->GetMaxLightmapPageID(); } virtual IShader *GetShader() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->GetShader(); } virtual bool IsPrecached( ) const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->IsPrecached(); } virtual bool IsPrecachedVars() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->IsPrecachedVars(); } virtual void DrawMesh( VertexCompressionType_t vertexCompression, bool bIsAlphaModulating, bool bRenderingPreTessPatchMesh ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->DrawMesh( vertexCompression, bIsAlphaModulating, bRenderingPreTessPatchMesh ); } virtual VertexFormat_t GetVertexUsage() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->GetVertexUsage(); } virtual bool PerformDebugTrace() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->PerformDebugTrace(); } virtual bool NoDebugOverride() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->NoDebugOverride(); } virtual void ToggleSuppression() { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->ToggleSuppression(); } virtual bool IsSuppressed() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->IsSuppressed(); } virtual void ToggleDebugTrace() { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->ToggleDebugTrace(); } virtual bool UseFog() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->UseFog(); } virtual void AddMaterialVar( IMaterialVar *pMaterialVar ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->AddMaterialVar( pMaterialVar ); } virtual ShaderRenderState_t *GetRenderState() { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->GetRenderState(); } virtual bool IsManuallyCreated() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->IsManuallyCreated(); } virtual bool NeedsFixedFunctionFlashlight() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->NeedsFixedFunctionFlashlight(); } virtual bool IsUsingVertexID() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->IsUsingVertexID(); } virtual void MarkAsPreloaded( bool bSet ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->MarkAsPreloaded( bSet ); } virtual bool IsPreloaded() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->IsPreloaded(); } virtual void ArtificialAddRef() { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->ArtificialAddRef(); } virtual void ArtificialRelease() { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->ArtificialRelease(); } virtual void ReportVarChanged( IMaterialVar *pVar ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->ReportVarChanged( pVar ); } virtual uint32 GetChangeID() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->GetChangeID(); } virtual bool IsTranslucentInternal( float fAlphaModulation ) const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->IsTranslucentInternal( fAlphaModulation ); } virtual void DecideShouldReloadFromWhitelist( IFileList *pFileList ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->DecideShouldReloadFromWhitelist( pFileList ); } virtual void ReloadFromWhitelistIfMarked() { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->ReloadFromWhitelistIfMarked(); } virtual bool IsRealTimeVersion( void ) const; virtual IMaterialInternal *GetRealTimeVersion( void ); virtual IMaterialInternal *GetQueueFriendlyVersion( void ); void SetRealTimeVersion( IMaterialInternal *pRealTimeVersion ) { m_pRealTimeVersion = pRealTimeVersion; } void UpdateToRealTime( void ); //update cached off variables using the real time version as a base. virtual void CompactMaterialVars() {} // The material system should be asking, and it should be working with the realtime version only. virtual bool HasQueueFriendlyProxies() const { Assert( !"Unexpected call to HasQueueFriendlyProxies" ); return false; } virtual bool SetTempExcluded( bool bSet, int nExcludedDimensionLimit ); protected: IMaterialInternal *m_pRealTimeVersion; //the material we're wrapping with queued delays private: //some calls need to know what state the material would be in right now if the queue had completed. float m_fAlphaModulationOnQueueCompletion; Vector m_vColorModulationOnQueueCompletion; }; #endif //#ifndef CMATERIAL_QUEUEFRIENDLY_H