1HEADmaster

1 files changed, 162 insertions, 0 deletions

diff --git a/materialsystem/cmaterial_queuefriendly.h b/materialsystem/cmaterial_queuefriendly.h
new file mode 100644
index 0000000..d91792c
--- /dev/null
+++ b/materialsystem/cmaterial_queuefriendly.h
@@ -0,0 +1,162 @@
+//========= Copyright 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 );
+	virtual MorphFormat_t	GetMorphFormat() const;
+
+	//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			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 void			SetUseFixedFunctionBakedLighting( bool bEnable );
+	virtual float			GetAlphaModulation();
+	virtual void			GetColorModulation( float *r, float *g, float *b );
+	virtual void			CallBindProxy( void *proxyData );
+	virtual IMaterial		*CheckProxyReplacement( void *proxyData );
+	virtual void			PrecacheMappingDimensions( );
+	virtual void			FindRepresentativeTexture( void );
+	virtual bool			WasReloadedFromWhitelist() { return m_pRealTimeVersion->WasReloadedFromWhitelist(); }
+	virtual bool			IsPrecached( ) const { return m_pRealTimeVersion->IsPrecached(); }
+
+
+#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 { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; 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<FileNameHandle_t> *pIncludes = NULL, int nFindContext = MATERIAL_FINDCONTEXT_NONE ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->PrecacheVars( pKeyValues, pPatchKeyValues, pIncludes, nFindContext ); }
+	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	IsPrecachedVars() const { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; return m_pRealTimeVersion->IsPrecachedVars(); }
+	virtual void	DrawMesh( VertexCompressionType_t vertexCompression ) { QUEUEFRIENDLY_USED_INTERNALLY_ASSERT; m_pRealTimeVersion->DrawMesh( vertexCompression ); }
+	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;
+		m_nReferenceCount = m_pRealTimeVersion->GetReferenceCount();
+	}
+	void UpdateToRealTime( void ); //update cached off variables using the real time version as a base.
+
+
+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;
+	int m_nReferenceCount; // Only ever accessed from the main thread.
+};
+
+
+
+#endif //#ifndef CMATERIAL_QUEUEFRIENDLY_H
+