1HEADmaster

1 files changed, 410 insertions, 0 deletions

diff --git a/materialsystem/cmaterial_queuefriendly.cpp b/materialsystem/cmaterial_queuefriendly.cpp
new file mode 100644
index 0000000..d6a9097
--- /dev/null
+++ b/materialsystem/cmaterial_queuefriendly.cpp
@@ -0,0 +1,410 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "cmaterial_queuefriendly.h"
+#include "tier1/callqueue.h"
+#include "materialsystem_global.h"
+
+
+#define USE_QUEUED_MATERIAL_CALLS //uncomment to queue up material changing calls. Comment out to always use instant calls.
+
+
+#ifdef USE_QUEUED_MATERIAL_CALLS
+
+#define QUEUE_MATERIAL_CALL( FuncName, ... )														\
+	{																								\
+		ICallQueue *pCallQueue = materials->GetRenderContext()->GetCallQueue();						\
+		if ( !pCallQueue )																			\
+		{																							\
+			m_pRealTimeVersion->FuncName( __VA_ARGS__ );											\
+		}																							\
+		else																						\
+		{																							\
+			pCallQueue->QueueCall( m_pRealTimeVersion, &IMaterialInternal::FuncName, ##__VA_ARGS__ );	\
+		}																							\
+	}
+
+#else
+
+#define QUEUE_MATERIAL_CALL( FuncName, ... ) m_pRealTimeVersion->FuncName( __VA_ARGS__ );
+
+#endif
+
+
+const char *CMaterial_QueueFriendly::GetName() const
+{
+	return m_pRealTimeVersion->GetName();
+}
+
+const char *CMaterial_QueueFriendly::GetTextureGroupName() const
+{
+	return m_pRealTimeVersion->GetTextureGroupName();
+}
+
+PreviewImageRetVal_t CMaterial_QueueFriendly::GetPreviewImageProperties( int *width, int *height, ImageFormat *imageFormat, bool* isTranslucent ) const
+{
+	return m_pRealTimeVersion->GetPreviewImageProperties( width, height, imageFormat, isTranslucent );
+}
+
+PreviewImageRetVal_t CMaterial_QueueFriendly::GetPreviewImage( unsigned char *data, int width, int height, ImageFormat imageFormat ) const
+{
+	return m_pRealTimeVersion->GetPreviewImage( data, width, height, imageFormat );
+}
+
+int CMaterial_QueueFriendly::GetMappingWidth( )
+{
+	return m_pRealTimeVersion->GetMappingWidth();
+}
+
+int CMaterial_QueueFriendly::GetMappingHeight( )
+{
+	return m_pRealTimeVersion->GetMappingHeight();
+}
+
+int CMaterial_QueueFriendly::GetNumAnimationFrames( )
+{
+	return m_pRealTimeVersion->GetNumAnimationFrames();
+}
+
+bool CMaterial_QueueFriendly::InMaterialPage( void )
+{
+	return m_pRealTimeVersion->InMaterialPage();
+}
+
+void CMaterial_QueueFriendly::GetMaterialOffset( float *pOffset )
+{
+	m_pRealTimeVersion->GetMaterialOffset( pOffset );
+}
+
+void CMaterial_QueueFriendly::GetMaterialScale( float *pScale )
+{
+	m_pRealTimeVersion->GetMaterialScale( pScale );
+}
+
+IMaterial *CMaterial_QueueFriendly::GetMaterialPage( void )
+{
+	return m_pRealTimeVersion->GetMaterialPage();
+}
+
+void CMaterial_QueueFriendly::IncrementReferenceCount( void )
+{
+	Assert( ThreadInMainThread() );
+	++m_nReferenceCount;
+	m_pRealTimeVersion->IncrementReferenceCount();
+}
+
+int CMaterial_QueueFriendly::GetEnumerationID( void ) const
+{
+	return m_pRealTimeVersion->GetEnumerationID();
+}
+
+bool CMaterial_QueueFriendly::HasProxy( void ) const
+{
+	return m_pRealTimeVersion->HasProxy();
+}
+
+void CMaterial_QueueFriendly::GetReflectivity( Vector& reflect )
+{
+	m_pRealTimeVersion->GetReflectivity( reflect );
+}
+
+bool CMaterial_QueueFriendly::GetPropertyFlag( MaterialPropertyTypes_t type )
+{
+	return m_pRealTimeVersion->GetPropertyFlag( type );
+}
+
+bool CMaterial_QueueFriendly::IsTwoSided()
+{
+	return m_pRealTimeVersion->IsTwoSided();
+}
+
+int CMaterial_QueueFriendly::ShaderParamCount() const
+{
+	return m_pRealTimeVersion->ShaderParamCount();
+}
+
+bool CMaterial_QueueFriendly::IsErrorMaterial() const
+{
+	return m_pRealTimeVersion->IsErrorMaterial();
+}
+
+bool CMaterial_QueueFriendly::IsSpriteCard()
+{
+	return m_pRealTimeVersion->IsSpriteCard();
+}
+
+
+
+//TODO: Investigate if these are likely to change at all when setting vars/flags
+bool CMaterial_QueueFriendly::IsAlphaTested()
+{
+	return m_pRealTimeVersion->IsAlphaTested();
+}
+
+bool CMaterial_QueueFriendly::IsVertexLit()
+{
+	return m_pRealTimeVersion->IsVertexLit();
+}
+
+VertexFormat_t CMaterial_QueueFriendly::GetVertexFormat() const
+{
+	return m_pRealTimeVersion->GetVertexFormat();
+}
+
+bool CMaterial_QueueFriendly::UsesEnvCubemap( void )
+{
+	return m_pRealTimeVersion->UsesEnvCubemap();
+}
+
+bool CMaterial_QueueFriendly::NeedsTangentSpace( void )
+{
+	return m_pRealTimeVersion->NeedsTangentSpace();
+}
+
+bool CMaterial_QueueFriendly::NeedsSoftwareSkinning( void )
+{
+	return m_pRealTimeVersion->NeedsSoftwareSkinning();
+}
+
+int CMaterial_QueueFriendly::GetNumPasses( void )
+{
+	return m_pRealTimeVersion->GetNumPasses();
+}
+
+int CMaterial_QueueFriendly::GetTextureMemoryBytes( void )
+{
+	return m_pRealTimeVersion->GetTextureMemoryBytes();
+}
+
+bool CMaterial_QueueFriendly::NeedsLightmapBlendAlpha( void )
+{
+	return m_pRealTimeVersion->NeedsLightmapBlendAlpha();
+}
+
+bool CMaterial_QueueFriendly::NeedsSoftwareLighting( void )
+{
+	return m_pRealTimeVersion->NeedsSoftwareLighting();
+}
+
+MorphFormat_t CMaterial_QueueFriendly::GetMorphFormat() const
+{
+	return m_pRealTimeVersion->GetMorphFormat();
+}
+
+void CMaterial_QueueFriendly::GetLowResColorSample( float s, float t, float *color ) const
+{
+	if ( m_pRealTimeVersion )
+		m_pRealTimeVersion->GetLowResColorSample( s, t, color );
+	else
+		color[ 0 ] = color[ 1 ] = color[ 2 ] = 0.0f;
+}
+
+
+
+IMaterialVar *CMaterial_QueueFriendly::FindVar( const char *varName, bool *found, bool complain )
+{
+	//TODO: return a queue friendly variable that can be get/set
+	return m_pRealTimeVersion->FindVar( varName, found, complain );
+}
+
+IMaterialVar *CMaterial_QueueFriendly::FindVarFast( char const *pVarName, unsigned int *pToken )
+{
+	//TODO: return a queue friendly variable that can be get/set
+	return m_pRealTimeVersion->FindVarFast( pVarName, pToken );
+}
+
+IMaterialVar **CMaterial_QueueFriendly::GetShaderParams( void )
+{
+	//TODO: return queue friendly variables that can be get/set
+	return m_pRealTimeVersion->GetShaderParams();
+}
+
+void CMaterial_QueueFriendly::DecrementReferenceCount( void )
+{
+	Assert( ThreadInMainThread() );
+	--m_nReferenceCount;
+	QUEUE_MATERIAL_CALL( DecrementReferenceCount );
+}
+
+void CMaterial_QueueFriendly::DeleteIfUnreferenced()
+{
+	Assert( ThreadInMainThread() );
+	if ( m_nReferenceCount > 0 )
+		return;
+		
+	MaterialSystem()->RemoveMaterial( GetRealTimeVersion() );
+	QUEUE_MATERIAL_CALL( DeleteIfUnreferenced );
+}
+
+void CMaterial_QueueFriendly::RecomputeStateSnapshots()
+{
+	QUEUE_MATERIAL_CALL( RecomputeStateSnapshots );
+}
+
+
+bool CMaterial_QueueFriendly::IsTranslucent()
+{
+	//TODO: need to base this as if the queued state is 100% up to date
+	return m_pRealTimeVersion->IsTranslucentInternal( GetMaterialVarFlag( MATERIAL_VAR_IGNORE_ALPHA_MODULATION ) ? 1.0f : m_fAlphaModulationOnQueueCompletion );
+}
+
+bool CMaterial_QueueFriendly::NeedsPowerOfTwoFrameBufferTexture( bool bCheckSpecificToThisFrame )
+{
+	//bCheckSpecificToThisFrame scares me a bit.
+	return m_pRealTimeVersion->NeedsPowerOfTwoFrameBufferTexture( bCheckSpecificToThisFrame );
+}
+
+bool CMaterial_QueueFriendly::NeedsFullFrameBufferTexture( bool bCheckSpecificToThisFrame )
+{
+	//bCheckSpecificToThisFrame scares me a bit.
+	return m_pRealTimeVersion->NeedsFullFrameBufferTexture( bCheckSpecificToThisFrame );
+}
+
+void CMaterial_QueueFriendly::AlphaModulate( float alpha )
+{
+	QUEUE_MATERIAL_CALL( AlphaModulate, alpha );
+	m_fAlphaModulationOnQueueCompletion = alpha;
+}
+
+void CMaterial_QueueFriendly::ColorModulate( float r, float g, float b )
+{
+	QUEUE_MATERIAL_CALL( ColorModulate, r, g, b );
+	m_vColorModulationOnQueueCompletion.Init( r, g, b );
+}
+
+void CMaterial_QueueFriendly::SetMaterialVarFlag( MaterialVarFlags_t flag, bool on )
+{
+	QUEUE_MATERIAL_CALL( SetMaterialVarFlag, flag, on );
+}
+bool CMaterial_QueueFriendly::GetMaterialVarFlag( MaterialVarFlags_t flag ) const
+{
+	//TODO: somehow mix both queued and real time states
+	return m_pRealTimeVersion->GetMaterialVarFlag( flag );
+}
+
+void CMaterial_QueueFriendly::SetShader( const char *pShaderName )
+{
+	//TODO: queue it and investigate, seems like a grenade.
+	m_pRealTimeVersion->SetShader( pShaderName );
+}
+
+void CMaterial_QueueFriendly::SetShaderAndParams( KeyValues *pKeyValues )
+{
+	//TODO: queue it and investigate, seems like a grenade.
+	m_pRealTimeVersion->SetShaderAndParams( pKeyValues );
+}
+
+const char *CMaterial_QueueFriendly::GetShaderName() const
+{
+	//TODO: return as if the queue is up to date. Someone could have set the shader very recently
+	return m_pRealTimeVersion->GetShaderName();
+}
+
+void CMaterial_QueueFriendly::Refresh()
+{
+	//TODO: Investigate, this one seems like a grenade.
+	m_pRealTimeVersion->Refresh();
+	//QUEUE_MATERIAL_CALL( Refresh );
+}
+
+void CMaterial_QueueFriendly::RefreshPreservingMaterialVars()
+{
+	//TODO: Investigate, this one seems like a grenade.
+	m_pRealTimeVersion->RefreshPreservingMaterialVars();
+	//QUEUE_MATERIAL_CALL( RefreshPreservingMaterialVars );
+}
+
+void CMaterial_QueueFriendly::SetUseFixedFunctionBakedLighting( bool bEnable )
+{
+	QUEUE_MATERIAL_CALL( SetUseFixedFunctionBakedLighting, bEnable );
+}
+
+float CMaterial_QueueFriendly::GetAlphaModulation()
+{
+#ifdef USE_QUEUED_MATERIAL_CALLS
+	return m_fAlphaModulationOnQueueCompletion;
+#else
+	return m_pRealTimeVersion->GetAlphaModulation();
+#endif
+}
+
+void CMaterial_QueueFriendly::GetColorModulation( float *r, float *g, float *b )
+{
+#ifdef USE_QUEUED_MATERIAL_CALLS
+	*r = m_vColorModulationOnQueueCompletion.x;
+	*g = m_vColorModulationOnQueueCompletion.y;
+	*b = m_vColorModulationOnQueueCompletion.z;
+#else
+	m_pRealTimeVersion->GetColorModulation( r, g, b );
+#endif
+}
+
+void CMaterial_QueueFriendly::CallBindProxy( void *proxyData )
+{
+	//TODO: queue it? Investigate.
+	return m_pRealTimeVersion->CallBindProxy( proxyData );
+}
+
+IMaterial *CMaterial_QueueFriendly::CheckProxyReplacement( void *proxyData )
+{
+	return m_pRealTimeVersion->CheckProxyReplacement( proxyData );
+}
+
+void CMaterial_QueueFriendly::PrecacheMappingDimensions()
+{
+	return m_pRealTimeVersion->PrecacheMappingDimensions();
+}
+
+void CMaterial_QueueFriendly::FindRepresentativeTexture()
+{
+	return m_pRealTimeVersion->FindRepresentativeTexture();
+}
+
+bool CMaterial_QueueFriendly::IsRealTimeVersion( void ) const
+{
+	return false;
+}
+
+IMaterialInternal *CMaterial_QueueFriendly::GetRealTimeVersion( void )
+{
+	return m_pRealTimeVersion;
+}
+
+IMaterialInternal *CMaterial_QueueFriendly::GetQueueFriendlyVersion( void )
+{
+	return this;
+}
+
+
+void CMaterial_QueueFriendly::UpdateToRealTime( void )
+{
+	m_fAlphaModulationOnQueueCompletion = m_pRealTimeVersion->GetAlphaModulation();
+	m_pRealTimeVersion->GetColorModulation( &m_vColorModulationOnQueueCompletion.x,
+											&m_vColorModulationOnQueueCompletion.y,
+											&m_vColorModulationOnQueueCompletion.z );
+	
+	m_nReferenceCount = m_pRealTimeVersion->GetReferenceCount();
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+