d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
119 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: b296444d0c
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b296444d0c'
${ noResults }
source-engine/materialsystem/cmaterial.cpp

3596 lines
98 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implementation of a material
//
//===========================================================================//
#include "imaterialinternal.h"
#include "bitmap/tgaloader.h"
#include "colorspace.h"
#include "materialsystem/imaterialvar.h"
#include "materialsystem/itexture.h"
#include <string.h>
#include "materialsystem_global.h"
#include "shaderapi/ishaderapi.h"
#include "materialsystem/imaterialproxy.h"
#include "shadersystem.h"
#include "materialsystem/imaterialproxyfactory.h"
#include "IHardwareConfigInternal.h"
#include "utlsymbol.h"
#include <malloc.h>
#include "filesystem.h"
#include <KeyValues.h>
#include "mempool.h"
#include "shaderapi/ishaderutil.h"
#include "vtf/vtf.h"
#include "tier1/strtools.h"
#include <ctype.h>
#include "utlbuffer.h"
#include "mathlib/vmatrix.h"
#include "texturemanager.h"
#include "itextureinternal.h"
#include "mempool.h"
#include "tier1/callqueue.h"
#include "cmaterial_queuefriendly.h"
#include "ifilelist.h"
#include "tier0/icommandline.h"
#include "tier0/minidump.h"
// #define PROXY_TRACK_NAMES
//-----------------------------------------------------------------------------
// Material implementation
//-----------------------------------------------------------------------------
class CMaterial : public IMaterialInternal
{
public:
// Members of the IMaterial interface
const char *GetName() const;
const char *GetTextureGroupName() const;
PreviewImageRetVal_t GetPreviewImageProperties( int *width, int *height,
ImageFormat *imageFormat, bool* isTranslucent ) const;
PreviewImageRetVal_t GetPreviewImage( unsigned char *data, int width, int height,
ImageFormat imageFormat ) const;
int GetMappingWidth( );
int GetMappingHeight( );
int GetNumAnimationFrames( );
bool InMaterialPage( void ) { return false; }
void GetMaterialOffset( float *pOffset );
void GetMaterialScale( float *pOffset );
IMaterial *GetMaterialPage( void ) { return NULL; }
void IncrementReferenceCount( );
void DecrementReferenceCount( );
int GetEnumerationID( ) const;
void GetLowResColorSample( float s, float t, float *color ) const;
IMaterialVar * FindVar( char const *varName, bool *found, bool complain = true );
IMaterialVar * FindVarFast( char const *pVarName, unsigned int *pToken );
// Sets new VMT shader parameters for the material
virtual void SetShaderAndParams( KeyValues *pKeyValues );
bool UsesEnvCubemap( void );
bool NeedsSoftwareSkinning( void );
virtual bool NeedsSoftwareLighting( void );
bool NeedsTangentSpace( void );
bool NeedsPowerOfTwoFrameBufferTexture( bool bCheckSpecificToThisFrame = true );
bool NeedsFullFrameBufferTexture( bool bCheckSpecificToThisFrame = true );
virtual bool IsUsingVertexID( ) const;
// GR - Is lightmap alpha needed?
bool NeedsLightmapBlendAlpha( void );
virtual void AlphaModulate( float alpha );
virtual void ColorModulate( float r, float g, float b );
virtual float GetAlphaModulation();
virtual void GetColorModulation( float *r, float *g, float *b );
// Gets the morph format
virtual MorphFormat_t GetMorphFormat() const;
void SetMaterialVarFlag( MaterialVarFlags_t flag, bool on );
bool GetMaterialVarFlag( MaterialVarFlags_t flag ) const;
bool IsTranslucent();
bool IsTranslucentInternal( float fAlphaModulation ) const; //need to centralize the logic without relying on the *current* alpha modulation being that which is stored in m_pShaderParams[ALPHA].
bool IsAlphaTested();
bool IsVertexLit();
virtual bool IsSpriteCard();
void GetReflectivity( Vector& reflect );
bool GetPropertyFlag( MaterialPropertyTypes_t type );
// Is the material visible from both sides?
bool IsTwoSided();
int GetNumPasses( void );
int GetTextureMemoryBytes( void );
void SetUseFixedFunctionBakedLighting( bool bEnable );
virtual bool IsPrecached( ) const;
public:
// stuff that is visible only from within the material system
// constructor, destructor
CMaterial( char const* materialName, const char *pTextureGroupName, KeyValues *pVMTKeyValues );
virtual ~CMaterial();
void DrawMesh( VertexCompressionType_t vertexCompression );
int GetReferenceCount( ) const;
void Uncache( bool bPreserveVars = false );
void Precache();
void ReloadTextures( void );
// If provided, pKeyValues and pPatchKeyValues should come from LoadVMTFile()
bool PrecacheVars( KeyValues *pKeyValues = NULL, KeyValues *pPatchKeyValues = NULL, CUtlVector<FileNameHandle_t> *pIncludes = NULL, int nFindContext = MATERIAL_FINDCONTEXT_NONE );
void SetMinLightmapPageID( int pageID );
void SetMaxLightmapPageID( int pageID );
int GetMinLightmapPageID( ) const;
int GetMaxLightmapPageID( ) const;
void SetNeedsWhiteLightmap( bool val );
bool GetNeedsWhiteLightmap( ) const;
bool IsPrecachedVars( ) const;
IShader * GetShader() const;
const char *GetShaderName() const;
virtual void DeleteIfUnreferenced();
void SetEnumerationID( int id );
void CallBindProxy( void *proxyData );
virtual IMaterial *CheckProxyReplacement( void *proxyData );
bool HasProxy( void ) const;
// Sets the shader associated with the material
void SetShader( const char *pShaderName );
// Can we override this material in debug?
bool NoDebugOverride() const;
// Gets the vertex format
VertexFormat_t GetVertexFormat() const;
// diffuse bump lightmap?
bool IsUsingDiffuseBumpedLighting() const;
// lightmap?
bool IsUsingLightmap() const;
// Gets the vertex usage flags
VertexFormat_t GetVertexUsage() const;
// Debugs this material
bool PerformDebugTrace() const;
// Are we suppressed?
bool IsSuppressed() const;
// Do we use fog?
bool UseFog( void ) const;
// Should we draw?
void ToggleSuppression();
void ToggleDebugTrace();
// Refresh material based on current var values
void Refresh();
void RefreshPreservingMaterialVars();
// This computes the state snapshots for this material
void RecomputeStateSnapshots();
// Gets at the shader parameters
virtual int ShaderParamCount() const;
virtual IMaterialVar **GetShaderParams( void );
virtual void AddMaterialVar( IMaterialVar *pMaterialVar );
virtual bool IsErrorMaterial() const;
// Was this manually created (not read from a file?)
virtual bool IsManuallyCreated() const;
virtual bool NeedsFixedFunctionFlashlight() const;
virtual void MarkAsPreloaded( bool bSet );
virtual bool IsPreloaded() const;
virtual void ArtificialAddRef( void );
virtual void ArtificialRelease( void );
virtual void ReportVarChanged( IMaterialVar *pVar )
{
m_ChangeID++;
}
virtual void ClearContextData( void );
virtual uint32 GetChangeID() const { return m_ChangeID; }
virtual bool IsRealTimeVersion( void ) const { return true; }
virtual IMaterialInternal *GetRealTimeVersion( void ) { return this; }
virtual IMaterialInternal *GetQueueFriendlyVersion( void ) { return &m_QueueFriendlyVersion; }
void DecideShouldReloadFromWhitelist( IFileList *pFilesToReload );
void ReloadFromWhitelistIfMarked();
bool WasReloadedFromWhitelist();
private:
// Initializes, cleans up the shader params
void CleanUpShaderParams();
// Sets up an error shader when we run into problems.
void SetupErrorShader();
// Does this material have a UNC-file name?
bool UsesUNCFileName() const;
// Prints material flags.
void PrintMaterialFlags( int flags, int flagsDefined );
// Parses material flags
bool ParseMaterialFlag( KeyValues* pParseValue, IMaterialVar* pFlagVar,
IMaterialVar* pFlagDefinedVar, bool parsingOverrides, int& flagMask, int& overrideMask );
// Computes the material vars for the shader
int ParseMaterialVars( IShader* pShader, KeyValues& keyValues,
KeyValues* pOverride, bool modelDefault, IMaterialVar** ppVars, int nFindContext = MATERIAL_FINDCONTEXT_NONE );
// Figures out the preview image for worldcraft
char const* GetPreviewImageName( );
char const* GetPreviewImageFileName( void ) const;
// Hooks up the shader, returns keyvalues of fallback that was used
KeyValues* InitializeShader( KeyValues &keyValues, KeyValues &patchKeyValues, int nFindContext = MATERIAL_FINDCONTEXT_NONE );
// Finds the flag associated with a particular flag name
int FindMaterialVarFlag( char const* pFlagName ) const;
// Initializes, cleans up the state snapshots
bool InitializeStateSnapshots();
void CleanUpStateSnapshots();
// Initializes, cleans up the material proxy
void InitializeMaterialProxy( KeyValues* pFallbackKeyValues );
void CleanUpMaterialProxy();
void DetermineProxyReplacements( KeyValues *pFallbackKeyValues );
// Creates, destroys snapshots
RenderPassList_t *CreateRenderPassList();
void DestroyRenderPassList( RenderPassList_t *pPassList );
// Grabs the texture width and height from the var list for faster access
void PrecacheMappingDimensions( );
// Gets the renderstate
virtual ShaderRenderState_t *GetRenderState();
// Do we have a valid renderstate?
bool IsValidRenderState() const;
// Get the material var flags
int GetMaterialVarFlags() const;
void SetMaterialVarFlags( int flags, bool on );
int GetMaterialVarFlags2() const;
void SetMaterialVarFlags2( int flags, bool on );
// Returns a dummy material variable
IMaterialVar* GetDummyVariable();
IMaterialVar* GetShaderParam( int id );
void FindRepresentativeTexture( void );
bool ShouldSkipVar( KeyValues *pMaterialVar, bool * pWasConditional );
// Fixed-size allocator
DECLARE_FIXEDSIZE_ALLOCATOR( CMaterial );
private:
enum
{
MATERIAL_NEEDS_WHITE_LIGHTMAP = 0x1,
MATERIAL_IS_PRECACHED = 0x2,
MATERIAL_VARS_IS_PRECACHED = 0x4,
MATERIAL_VALID_RENDERSTATE = 0x8,
MATERIAL_IS_MANUALLY_CREATED = 0x10,
MATERIAL_USES_UNC_FILENAME = 0x20,
MATERIAL_IS_PRELOADED = 0x40,
MATERIAL_ARTIFICIAL_REFCOUNT = 0x80,
};
int m_iEnumerationID;
int m_minLightmapPageID;
int m_maxLightmapPageID;
unsigned short m_MappingWidth;
unsigned short m_MappingHeight;
IShader *m_pShader;
CUtlSymbol m_Name;
// Any textures created for this material go under this texture group.
CUtlSymbol m_TextureGroupName;
CInterlockedInt m_RefCount;
unsigned short m_Flags;
unsigned char m_VarCount;
CUtlVector< IMaterialProxy * > m_ProxyInfo;
#ifdef PROXY_TRACK_NAMES
// Array to track names of above material proxies. Useful for tracking down issues with proxies.
CUtlVector< CUtlString > m_ProxyInfoNames;
#endif
IMaterialVar** m_pShaderParams;
IMaterialProxy *m_pReplacementProxy;
ShaderRenderState_t m_ShaderRenderState;
// This remembers filenames of VMTs that we included so we can sv_pure/flush ourselves if any of them need to be reloaded.
CUtlVector<FileNameHandle_t> m_VMTIncludes;
bool m_bShouldReloadFromWhitelist; // Tells us if the material decided it should be reloaded due to sv_pure whitelist changes.
ITextureInternal *m_representativeTexture;
Vector m_Reflectivity;
uint32 m_ChangeID;
// Used only by procedural materials; it essentially is an in-memory .VMT file
KeyValues *m_pVMTKeyValues;
#if defined( _DEBUG )
// Makes it easier to see what's going on
char *m_pDebugName;
#endif
protected:
CMaterial_QueueFriendly m_QueueFriendlyVersion;
};
// NOTE: This must be the last file included
// Has to exist *after* fixed size allocator declaration
#include "tier0/memdbgon.h"
// Forward decls of helper functions for dealing with patch vmts.
static void ApplyPatchKeyValues( KeyValues &keyValues, KeyValues &patchKeyValues );
static bool AccumulateRecursiveVmtPatches( KeyValues &patchKeyValuesOut, KeyValues **ppBaseKeyValuesOut,
const KeyValues& keyValues, const char *pPathID, CUtlVector<FileNameHandle_t> *pIncludes );
//-----------------------------------------------------------------------------
// Parser utilities
//-----------------------------------------------------------------------------
static inline bool IsWhitespace( char c )
{
return c == ' ' || c == '\t';
}
static inline bool IsEndline( char c )
{
return c == '\n' || c == '\0';
}
static inline bool IsVector( char const* v )
{
while (IsWhitespace(*v))
{
++v;
if (IsEndline(*v))
return false;
}
return *v == '[' || *v == '{';
}
//-----------------------------------------------------------------------------
// Methods to create state snapshots
//-----------------------------------------------------------------------------
#include "tier0/memdbgoff.h"
#ifndef _CONSOLE
struct EditorRenderStateList_t
{
// Store combo of alpha, color, fixed-function baked lighting, flashlight, editor mode
RenderPassList_t m_Snapshots[SNAPSHOT_COUNT_EDITOR];
DECLARE_FIXEDSIZE_ALLOCATOR( EditorRenderStateList_t );
};
#endif
struct StandardRenderStateList_t
{
// Store combo of alpha, color, fixed-function baked lighting, flashlight
RenderPassList_t m_Snapshots[SNAPSHOT_COUNT_NORMAL];
DECLARE_FIXEDSIZE_ALLOCATOR( StandardRenderStateList_t );
};
#include "tier0/memdbgon.h"
#ifndef _CONSOLE
DEFINE_FIXEDSIZE_ALLOCATOR( EditorRenderStateList_t, 256, true );
#endif
DEFINE_FIXEDSIZE_ALLOCATOR( StandardRenderStateList_t, 256, true );
//-----------------------------------------------------------------------------
// class factory methods
//-----------------------------------------------------------------------------
DEFINE_FIXEDSIZE_ALLOCATOR( CMaterial, 256, true );
IMaterialInternal* IMaterialInternal::CreateMaterial( char const* pMaterialName, const char *pTextureGroupName, KeyValues *pVMTKeyValues )
{
MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
IMaterialInternal *pResult = new CMaterial( pMaterialName, pTextureGroupName, pVMTKeyValues );
MaterialSystem()->Unlock( hMaterialLock );
return pResult;
}
void IMaterialInternal::DestroyMaterial( IMaterialInternal* pMaterial )
{
MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
if (pMaterial)
{
Assert( pMaterial->IsRealTimeVersion() );
CMaterial* pMatImp = static_cast<CMaterial*>(pMaterial);
// Deletion of the error material is deferred until after all other materials have been deleted.
// See CMaterialSystem::CleanUpErrorMaterial() in cmaterialsystem.cpp.
if ( !pMatImp->IsErrorMaterial() )
{
delete pMatImp;
}
}
MaterialSystem()->Unlock( hMaterialLock );
}
//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------
CMaterial::CMaterial( char const* materialName, const char *pTextureGroupName, KeyValues *pKeyValues )
{
m_Reflectivity.Init( 0.2f, 0.2f, 0.2f );
int len = Q_strlen(materialName);
char* pTemp = (char*)_alloca( len + 1 );
// Strip off the extension
Q_StripExtension( materialName, pTemp, len+1 );
Q_strlower( pTemp );
#if defined( _X360 )
// material names are expected to be forward slashed for correct sort and find behavior!
// assert now to track alternate or regressed path that is source of inconsistency
Assert( strchr( pTemp, '\\' ) == NULL );
#endif
// Convert it to a symbol
m_Name = pTemp;
#if defined( _DEBUG )
m_pDebugName = new char[strlen(pTemp) + 1];
Q_strncpy( m_pDebugName, pTemp, strlen(pTemp) + 1 );
#endif
m_bShouldReloadFromWhitelist = false;
m_Flags = 0;
m_pShader = NULL;
m_pShaderParams = NULL;
m_RefCount = 0;
m_representativeTexture = NULL;
m_pReplacementProxy = NULL;
m_VarCount = 0;
m_MappingWidth = m_MappingHeight = 0;
m_iEnumerationID = 0;
m_minLightmapPageID = m_maxLightmapPageID = 0;
m_TextureGroupName = pTextureGroupName;
m_pVMTKeyValues = pKeyValues;
if (m_pVMTKeyValues)
{
m_Flags |= MATERIAL_IS_MANUALLY_CREATED;
}
if ( pTemp[0] == '/' && pTemp[1] == '/' && pTemp[2] != '/' )
{
m_Flags |= MATERIAL_USES_UNC_FILENAME;
}
// Initialize the renderstate to something indicating nothing should be drawn
m_ShaderRenderState.m_Flags = 0;
m_ShaderRenderState.m_VertexFormat = m_ShaderRenderState.m_VertexUsage = 0;
m_ShaderRenderState.m_MorphFormat = 0;
m_ShaderRenderState.m_pSnapshots = CreateRenderPassList();
m_ChangeID = 0;
m_QueueFriendlyVersion.SetRealTimeVersion( this );
}
CMaterial::~CMaterial()
{
MaterialSystem()->UnbindMaterial( this );
Uncache();
if ( m_RefCount != 0 )
{
DevWarning( 2, "Reference Count for Material %s (%d) != 0\n", GetName(), (int) m_RefCount );
}
if ( m_pVMTKeyValues )
{
m_pVMTKeyValues->deleteThis();
m_pVMTKeyValues = NULL;
}
DestroyRenderPassList( m_ShaderRenderState.m_pSnapshots );
m_representativeTexture = NULL;
#if defined( _DEBUG )
delete [] m_pDebugName;
#endif
// Deliberately stomp our VTable so that we can detect cases where code tries to access freed materials.
int *p = (int *)this;
*p = 0xc0dedbad;
}
void CMaterial::ClearContextData( void )
{
int nSnapshotCount = SnapshotTypeCount();
for( int i = 0 ; i < nSnapshotCount ; i++ )
for( int j = 0 ; j < m_ShaderRenderState.m_pSnapshots[i].m_nPassCount; j++ )
{
if ( m_ShaderRenderState.m_pSnapshots[i].m_pContextData[j] )
{
delete m_ShaderRenderState.m_pSnapshots[i].m_pContextData[j];
m_ShaderRenderState.m_pSnapshots[i].m_pContextData[j] = NULL;
}
}
}
//-----------------------------------------------------------------------------
// Sets new VMT shader parameters for the material
//-----------------------------------------------------------------------------
void CMaterial::SetShaderAndParams( KeyValues *pKeyValues )
{
Uncache();
if ( m_pVMTKeyValues )
{
m_pVMTKeyValues->deleteThis();
m_pVMTKeyValues = NULL;
}
m_pVMTKeyValues = pKeyValues ? pKeyValues->MakeCopy() : NULL;
if (m_pVMTKeyValues)
{
m_Flags |= MATERIAL_IS_MANUALLY_CREATED;
}
// Apply patches
const char *pMaterialName = GetName();
char pFileName[MAX_PATH];
const char *pPathID = "GAME";
if ( !UsesUNCFileName() )
{
Q_snprintf( pFileName, sizeof( pFileName ), "materials/%s.vmt", pMaterialName );
}
else
{
Q_snprintf( pFileName, sizeof( pFileName ), "%s.vmt", pMaterialName );
if ( pMaterialName[0] == '/' && pMaterialName[1] == '/' && pMaterialName[2] != '/' )
{
// UNC, do full search
pPathID = NULL;
}
}
KeyValues *pLoadedKeyValues = new KeyValues( "vmt" );
if ( pLoadedKeyValues->LoadFromFile( g_pFullFileSystem, pFileName, pPathID ) )
{
// Load succeeded, check if it's a patch file
if ( V_stricmp( pLoadedKeyValues->GetName(), "patch" ) == 0 )
{
// it's a patch file, recursively build up patch keyvalues
KeyValues *pPatchKeyValues = new KeyValues( "vmt_patch" );
bool bSuccess = AccumulateRecursiveVmtPatches( *pPatchKeyValues, NULL, *pLoadedKeyValues, pPathID, NULL );
if ( bSuccess )
{
// Apply accumulated patches to final vmt
ApplyPatchKeyValues( *m_pVMTKeyValues, *pPatchKeyValues );
}
pPatchKeyValues->deleteThis();
}
}
pLoadedKeyValues->deleteThis();
if ( g_pShaderDevice->IsUsingGraphics() )
{
Precache();
}
}
//-----------------------------------------------------------------------------
// Creates, destroys snapshots
//-----------------------------------------------------------------------------
RenderPassList_t *CMaterial::CreateRenderPassList()
{
RenderPassList_t *pRenderPassList;
if ( IsConsole() || !MaterialSystem()->CanUseEditorMaterials() )
{
StandardRenderStateList_t *pList = new StandardRenderStateList_t;
pRenderPassList = (RenderPassList_t*)pList->m_Snapshots;
}
#ifndef _CONSOLE
else
{
EditorRenderStateList_t *pList = new EditorRenderStateList_t;
pRenderPassList = (RenderPassList_t*)pList->m_Snapshots;
}
#endif
int nSnapshotCount = SnapshotTypeCount();
memset( pRenderPassList, 0, nSnapshotCount * sizeof(RenderPassList_t) );
return pRenderPassList;
}
void CMaterial::DestroyRenderPassList( RenderPassList_t *pPassList )
{
if ( !pPassList )
return;
int nSnapshotCount = SnapshotTypeCount();
for( int i = 0 ; i < nSnapshotCount ; i++ )
for( int j = 0 ; j < pPassList[i].m_nPassCount; j++ )
{
if ( pPassList[i].m_pContextData[j] )
{
delete pPassList[i].m_pContextData[j];
pPassList[i].m_pContextData[j] = NULL;
}
}
if ( IsConsole() || !MaterialSystem()->CanUseEditorMaterials() )
{
StandardRenderStateList_t *pList = (StandardRenderStateList_t*)pPassList;
delete pList;
}
#ifndef _CONSOLE
else
{
EditorRenderStateList_t *pList = (EditorRenderStateList_t*)pPassList;
delete pList;
}
#endif
}
//-----------------------------------------------------------------------------
// Gets the renderstate
//-----------------------------------------------------------------------------
ShaderRenderState_t *CMaterial::GetRenderState()
{
Precache();
return &m_ShaderRenderState;
}
//-----------------------------------------------------------------------------
// Returns a dummy material variable
//-----------------------------------------------------------------------------
IMaterialVar* CMaterial::GetDummyVariable()
{
static IMaterialVar* pDummyVar = 0;
if (!pDummyVar)
pDummyVar = IMaterialVar::Create( 0, "$dummyVar", 0 );
return pDummyVar;
}
//-----------------------------------------------------------------------------
// Are vars precached?
//-----------------------------------------------------------------------------
bool CMaterial::IsPrecachedVars( ) const
{
return (m_Flags & MATERIAL_VARS_IS_PRECACHED) != 0;
}
//-----------------------------------------------------------------------------
// Are we precached?
//-----------------------------------------------------------------------------
bool CMaterial::IsPrecached( ) const
{
return (m_Flags & MATERIAL_IS_PRECACHED) != 0;
}
//-----------------------------------------------------------------------------
// Cleans up shader parameters
//-----------------------------------------------------------------------------
void CMaterial::CleanUpShaderParams()
{
if( m_pShaderParams )
{
for (int i = 0; i < m_VarCount; ++i)
{
IMaterialVar::Destroy( m_pShaderParams[i] );
}
free( m_pShaderParams );
m_pShaderParams = 0;
}
m_VarCount = 0;
}
//-----------------------------------------------------------------------------
// Initializes the material proxy
//-----------------------------------------------------------------------------
void CMaterial::InitializeMaterialProxy( KeyValues* pFallbackKeyValues )
{
IMaterialProxyFactory *pMaterialProxyFactory;
pMaterialProxyFactory = MaterialSystem()->GetMaterialProxyFactory();
if( !pMaterialProxyFactory )
return;
DetermineProxyReplacements( pFallbackKeyValues );
if ( m_pReplacementProxy )
{
m_ProxyInfo.AddToTail( m_pReplacementProxy );
#ifdef PROXY_TRACK_NAMES
m_ProxyInfoNames.AddToTail( "__replacementproxy" );
#endif
}
// See if we've got a proxy section; obey fallbacks
KeyValues* pProxySection = pFallbackKeyValues->FindKey("Proxies");
if ( pProxySection )
{
// Iterate through the section + create all of the proxies
KeyValues* pProxyKey = pProxySection->GetFirstSubKey();
for ( ; pProxyKey; pProxyKey = pProxyKey->GetNextKey() )
{
// Each of the proxies should themselves be databases
IMaterialProxy* pProxy = pMaterialProxyFactory->CreateProxy( pProxyKey->GetName() );
if (!pProxy)
{
Warning( "Error: Material \"%s\" : proxy \"%s\" not found!\n", GetName(), pProxyKey->GetName() );
continue;
}
if (!pProxy->Init( this->GetQueueFriendlyVersion(), pProxyKey ))
{
pMaterialProxyFactory->DeleteProxy( pProxy );
Warning( "Error: Material \"%s\" : proxy \"%s\" unable to initialize!\n", GetName(), pProxyKey->GetName() );
}
else
{
m_ProxyInfo.AddToTail( pProxy );
#ifdef PROXY_TRACK_NAMES
m_ProxyInfoNames.AddToTail( pProxyKey->GetName() );
#endif
}
}
}
}
//-----------------------------------------------------------------------------
// Cleans up the material proxy
//-----------------------------------------------------------------------------
void CMaterial::CleanUpMaterialProxy()
{
if ( !m_ProxyInfo.Count() )
return;
IMaterialProxyFactory *pMaterialProxyFactory;
pMaterialProxyFactory = MaterialSystem()->GetMaterialProxyFactory();
if ( !pMaterialProxyFactory )
return;
// Clean up material proxies
for ( int i = m_ProxyInfo.Count() - 1; i >= 0; i-- )
{
IMaterialProxy *pProxy = m_ProxyInfo[ i ];
pMaterialProxyFactory->DeleteProxy( pProxy );
}
m_ProxyInfo.RemoveAll();
#ifdef PROXY_TRACK_NAMES
m_ProxyInfoNames.RemoveAll();
#endif
}
void CMaterial::DetermineProxyReplacements( KeyValues *pFallbackKeyValues )
{
m_pReplacementProxy = MaterialSystem()->DetermineProxyReplacements( this, pFallbackKeyValues );
}
static char const *GetVarName( KeyValues *pVar )
{
char const *pVarName = pVar->GetName();
char const *pQuestion = strchr( pVarName, '?' );
if (! pQuestion )
return pVarName;
else
return pQuestion + 1;
}
//-----------------------------------------------------------------------------
// Finds the index of the material var associated with a var
//-----------------------------------------------------------------------------
static int FindMaterialVar( IShader* pShader, char const* pVarName )
{
if ( !pShader )
return -1;
// Strip preceeding spaces
pVarName += strspn( pVarName, " \t" );
for (int i = pShader->GetNumParams(); --i >= 0; )
{
// Makes the parser a little more lenient.. strips off bogus spaces in the var name.
const char *pParamName = pShader->GetParamName(i);
const char *pFound = Q_stristr( pVarName, pParamName );
// The found string had better start with the first non-whitespace character
if ( pFound != pVarName )
continue;
// Strip spaces at the end
int nLen = Q_strlen( pParamName );
pFound += nLen;
while ( true )
{
if ( !pFound[0] )
return i;
if ( !IsWhitespace( pFound[0] ) )
break;
++pFound;
}
}
return -1;
}
//-----------------------------------------------------------------------------
// Creates a vector material var
//-----------------------------------------------------------------------------
int ParseVectorFromKeyValueString( KeyValues *pKeyValue, const char *pMaterialName, float vecVal[4] )
{
char const* pScan = pKeyValue->GetString();
bool divideBy255 = false;
// skip whitespace
while( IsWhitespace(*pScan) )
{
++pScan;
}
if( *pScan == '{' )
{
divideBy255 = true;
}
else
{
Assert( *pScan == '[' );
}
// skip the '['
++pScan;
int i;
for( i = 0; i < 4; i++ )
{
// skip whitespace
while( IsWhitespace(*pScan) )
{
++pScan;
}
if( IsEndline(*pScan) || *pScan == ']' || *pScan == '}' )
{
if (*pScan != ']' && *pScan != '}')
{
Warning( "Warning in .VMT file (%s): no ']' or '}' found in vector key \"%s\".\n"
"Did you forget to surround the vector with \"s?\n", pMaterialName, pKeyValue->GetName() );
}
// allow for vec2's, etc.
vecVal[i] = 0.0f;
break;
}
char* pEnd;
vecVal[i] = strtod( pScan, &pEnd );
if (pScan == pEnd)
{
Warning( "Error in .VMT file: error parsing vector element \"%s\" in \"%s\"\n", pKeyValue->GetName(), pMaterialName );
return 0;
}
pScan = pEnd;
}
if( divideBy255 )
{
vecVal[0] *= ( 1.0f / 255.0f );
vecVal[1] *= ( 1.0f / 255.0f );
vecVal[2] *= ( 1.0f / 255.0f );
vecVal[3] *= ( 1.0f / 255.0f );
}
return i;
}
static IMaterialVar* CreateVectorMaterialVarFromKeyValue( IMaterial* pMaterial, KeyValues* pKeyValue )
{
char const *pszName = GetVarName( pKeyValue );
float vecVal[4];
int nDim = ParseVectorFromKeyValueString( pKeyValue, pszName, vecVal );
if ( nDim == 0 )
return NULL;
// Create the variable!
return IMaterialVar::Create( pMaterial, pszName, vecVal, nDim );
}
//-----------------------------------------------------------------------------
// Creates a vector material var
//-----------------------------------------------------------------------------
static IMaterialVar* CreateMatrixMaterialVarFromKeyValue( IMaterial* pMaterial, KeyValues* pKeyValue )
{
char const* pScan = pKeyValue->GetString();
char const *pszName = GetVarName( pKeyValue );
// Matrices can be specified one of two ways:
// [ # # # # # # # # # # # # # # # # ]
// or
// center # # scale # # rotate # translate # #
VMatrix mat;
int count = sscanf( pScan, " [ %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f ]",
&mat.m[0][0], &mat.m[0][1], &mat.m[0][2], &mat.m[0][3],
&mat.m[1][0], &mat.m[1][1], &mat.m[1][2], &mat.m[1][3],
&mat.m[2][0], &mat.m[2][1], &mat.m[2][2], &mat.m[2][3],
&mat.m[3][0], &mat.m[3][1], &mat.m[3][2], &mat.m[3][3] );
if (count == 16)
{
return IMaterialVar::Create( pMaterial, pszName, mat );
}
Vector2D scale, center;
float angle;
Vector2D translation;
count = sscanf( pScan, " center %f %f scale %f %f rotate %f translate %f %f",
&center.x, &center.y, &scale.x, &scale.y, &angle, &translation.x, &translation.y );
if (count != 7)
return NULL;
VMatrix temp;
MatrixBuildTranslation( mat, -center.x, -center.y, 0.0f );
MatrixBuildScale( temp, scale.x, scale.y, 1.0f );
MatrixMultiply( temp, mat, mat );
MatrixBuildRotateZ( temp, angle );
MatrixMultiply( temp, mat, mat );
MatrixBuildTranslation( temp, center.x + translation.x, center.y + translation.y, 0.0f );
MatrixMultiply( temp, mat, mat );
// Create the variable!
return IMaterialVar::Create( pMaterial, pszName, mat );
}
//-----------------------------------------------------------------------------
// Creates a material var from a key value
//-----------------------------------------------------------------------------
static IMaterialVar* CreateMaterialVarFromKeyValue( IMaterial* pMaterial, KeyValues* pKeyValue )
{
char const *pszName = GetVarName( pKeyValue );
switch( pKeyValue->GetDataType() )
{
case KeyValues::TYPE_INT:
return IMaterialVar::Create( pMaterial, pszName, pKeyValue->GetInt() );
case KeyValues::TYPE_FLOAT:
return IMaterialVar::Create( pMaterial, pszName, pKeyValue->GetFloat() );
case KeyValues::TYPE_STRING:
{
char const* pString = pKeyValue->GetString();
if (!pString || !pString[0])
return 0;
// Look for matrices
IMaterialVar *pMatrixVar = CreateMatrixMaterialVarFromKeyValue( pMaterial, pKeyValue );
if (pMatrixVar)
return pMatrixVar;
// Look for vectors
if (!IsVector(pString))
return IMaterialVar::Create( pMaterial, pszName, pString );
// Parse the string as a vector...
return CreateVectorMaterialVarFromKeyValue( pMaterial, pKeyValue );
}
}
return 0;
}
//-----------------------------------------------------------------------------
// Reads out common flags, prevents them from becoming material vars
//-----------------------------------------------------------------------------
int CMaterial::FindMaterialVarFlag( char const* pFlagName ) const
{
// Strip preceeding spaces
while ( pFlagName[0] )
{
if ( !IsWhitespace( pFlagName[0] ) )
break;
++pFlagName;
}
for( int i = 0; *ShaderSystem()->ShaderStateString(i); ++i )
{
const char *pStateString = ShaderSystem()->ShaderStateString(i);
const char *pFound = Q_stristr( pFlagName, pStateString );
// The found string had better start with the first non-whitespace character
if ( pFound != pFlagName )
continue;
// Strip spaces at the end
int nLen = Q_strlen( pStateString );
pFound += nLen;
while ( true )
{
if ( !pFound[0] )
return (1 << i);
if ( !IsWhitespace( pFound[0] ) )
break;
++pFound;
}
}
return 0;
}
//-----------------------------------------------------------------------------
// Print material flags
//-----------------------------------------------------------------------------
void CMaterial::PrintMaterialFlags( int flags, int flagsDefined )
{
int i;
for( i = 0; *ShaderSystem()->ShaderStateString(i); i++ )
{
if( flags & ( 1<<i ) )
{
Warning( "%s|", ShaderSystem()->ShaderStateString(i) );
}
}
Warning( "\n" );
}
//-----------------------------------------------------------------------------
// Parses material flags
//-----------------------------------------------------------------------------
bool CMaterial::ParseMaterialFlag( KeyValues* pParseValue, IMaterialVar* pFlagVar,
IMaterialVar* pFlagDefinedVar, bool parsingOverrides, int& flagMask, int& overrideMask )
{
// See if the var is a flag...
int flagbit = FindMaterialVarFlag( GetVarName( pParseValue ) );
if (!flagbit)
return false;
// Allow for flag override
int testMask = parsingOverrides ? overrideMask : flagMask;
if (testMask & flagbit)
{
Warning("Error! Flag \"%s\" is multiply defined in material \"%s\"!\n", pParseValue->GetName(), GetName() );
return true;
}
// Make sure overrides win
if (overrideMask & flagbit)
return true;
if (parsingOverrides)
overrideMask |= flagbit;
else
flagMask |= flagbit;
// If so, then set the flag bit
if (pParseValue->GetInt())
pFlagVar->SetIntValue( pFlagVar->GetIntValue() | flagbit );
else
pFlagVar->SetIntValue( pFlagVar->GetIntValue() & (~flagbit) );
// Mark the flag as being defined
pFlagDefinedVar->SetIntValue( pFlagDefinedVar->GetIntValue() | flagbit );
/*
if( stristr( m_pDebugName, "glasswindow064a" ) )
{
Warning( "flags\n" );
PrintMaterialFlags( pFlagVar->GetIntValue(), pFlagDefinedVar->GetIntValue() );
}
*/
return true;
}
ConVar mat_reduceparticles( "mat_reduceparticles", "0", FCVAR_ALLOWED_IN_COMPETITIVE );
bool CMaterial::ShouldSkipVar( KeyValues *pVar, bool *pWasConditional )
{
char const *pVarName = pVar->GetName();
char const *pQuestion = strchr( pVarName, '?' );
if ( ( ! pQuestion ) || (pQuestion == pVarName ) )
{
*pWasConditional = false; // unconditional var
return false;
}
else
{
bool bShouldSkip = true;
*pWasConditional = true;
// parse the conditional part
char pszConditionName[256];
V_strncpy( pszConditionName, pVarName, 1+pQuestion-pVarName );
char const *pCond = pszConditionName;
bool bToggle = false;
if ( pCond[0] == '!' )
{
pCond++;
bToggle = true;
}
if ( ! stricmp( pCond, "lowfill" ) )
{
bShouldSkip = !mat_reduceparticles.GetBool();
}
else if ( ! stricmp( pCond, "hdr" ) )
{
bShouldSkip = ( HardwareConfig()->GetHDRType() == HDR_TYPE_NONE );
}
else if ( ! stricmp( pCond, "srgb" ) )
{
bShouldSkip = ( !HardwareConfig()->UsesSRGBCorrectBlending() );
}
else if ( ! stricmp( pCond, "ldr" ) )
{
bShouldSkip = ( HardwareConfig()->GetHDRType() != HDR_TYPE_NONE );
}
else if ( ! stricmp( pCond, "360" ) )
{
bShouldSkip = !IsX360();
}
else
{
Warning( "unrecognized conditional test %s in %s\n", pVarName, GetName() );
}
return bShouldSkip ^ bToggle;
}
}
//-----------------------------------------------------------------------------
// Computes the material vars for the shader
//-----------------------------------------------------------------------------
int CMaterial::ParseMaterialVars( IShader* pShader, KeyValues& keyValues,
KeyValues* pOverrideKeyValues, bool modelDefault, IMaterialVar** ppVars, int nFindContext )
{
IMaterialVar* pNewVar;
bool pOverride[256];
bool bWasConditional[256];
int overrideMask = 0;
int flagMask = 0;
memset( ppVars, 0, 256 * sizeof(IMaterialVar*) );
memset( pOverride, 0, sizeof( pOverride ) );
memset( bWasConditional, 0, sizeof( bWasConditional ) );
// Create the flag var...
// Set model mode if we fell back from a model mode shader
int modelFlag = modelDefault ? MATERIAL_VAR_MODEL : 0;
ppVars[FLAGS] = IMaterialVar::Create( this, "$flags", modelFlag );
ppVars[FLAGS_DEFINED] = IMaterialVar::Create( this, "$flags_defined", modelFlag );
ppVars[FLAGS2] = IMaterialVar::Create( this, "$flags2", 0 );
ppVars[FLAGS_DEFINED2] = IMaterialVar::Create( this, "$flags_defined2", 0 );
int numParams = pShader ? pShader->GetNumParams() : 0;
int varCount = numParams;
bool parsingOverrides = (pOverrideKeyValues != 0);
KeyValues* pVar = pOverrideKeyValues ? pOverrideKeyValues->GetFirstSubKey() : keyValues.GetFirstSubKey();
const char *pszMatName = pVar ? pVar->GetString() : "Unknown";
while( pVar )
{
bool bProcessThisOne = true;
bool bIsConditionalVar;
const char *pszVarName = GetVarName( pVar );
if ( (nFindContext == MATERIAL_FINDCONTEXT_ISONAMODEL) && pszVarName && pszVarName[0] )
{
// Prevent ignorez models
// Should we do 'nofog' too? For now, decided not to.
if ( Q_stristr(pszVarName,"$ignorez") )
{
Warning("Ignoring material flag '%s' on material '%s'.\n", pszVarName, pszMatName );
goto nextVar;
}
}
// See if the var is a flag...
if (
ShouldSkipVar( pVar, &bIsConditionalVar ) || // should skip?
((pVar->GetName()[0] == '%') && (g_pShaderDevice->IsUsingGraphics()) && (!MaterialSystem()->CanUseEditorMaterials() ) ) || // is an editor var?
ParseMaterialFlag( pVar, ppVars[FLAGS], ppVars[FLAGS_DEFINED], parsingOverrides, flagMask, overrideMask ) || // is a flag?
ParseMaterialFlag( pVar, ppVars[FLAGS2], ppVars[FLAGS_DEFINED2], parsingOverrides, flagMask, overrideMask )
)
bProcessThisOne = false;
if ( bProcessThisOne )
{
// See if the var is one of the shader params
int varIdx = FindMaterialVar( pShader, pszVarName );
// Check for multiply defined or overridden
if (varIdx >= 0)
{
if (ppVars[varIdx] && (! bIsConditionalVar ) )
{
if ( !pOverride[varIdx] || parsingOverrides )
{
Warning("Error! Variable \"%s\" is multiply defined in material \"%s\"!\n", pVar->GetName(), GetName() );
}
goto nextVar;
}
}
else
{
int i;
for ( i = numParams; i < varCount; ++i)
{
Assert( ppVars[i] );
if (!stricmp( ppVars[i]->GetName(), pVar->GetName() ))
break;
}
if (i != varCount)
{
if ( !pOverride[i] || parsingOverrides )
{
Warning("Error! Variable \"%s\" is multiply defined in material \"%s\"!\n", pVar->GetName(), GetName() );
}
goto nextVar;
}
}
// Create a material var for this dudely dude; could be zero...
pNewVar = CreateMaterialVarFromKeyValue( this, pVar );
if (!pNewVar)
goto nextVar;
if (varIdx < 0)
{
varIdx = varCount++;
}
if ( ppVars[varIdx] )
{
IMaterialVar::Destroy( ppVars[varIdx] );
}
ppVars[varIdx] = pNewVar;
if (parsingOverrides)
pOverride[varIdx] = true;
bWasConditional[varIdx] = bIsConditionalVar;
}
nextVar:
pVar = pVar->GetNextKey();
if (!pVar && parsingOverrides)
{
pVar = keyValues.GetFirstSubKey();
parsingOverrides = false;
}
}
// Create undefined vars for all the actual material vars
for (int i = 0; i < numParams; ++i)
{
if (!ppVars[i])
ppVars[i] = IMaterialVar::Create( this, pShader->GetParamName(i) );
}
return varCount;
}
static KeyValues *CheckConditionalFakeShaderName( char const *pShaderName, char const *pSuffixName,
KeyValues *pKeyValues )
{
KeyValues *pFallbackSection = pKeyValues->FindKey( pSuffixName );
if (pFallbackSection)
return pFallbackSection;
char nameBuf[256];
V_snprintf( nameBuf, sizeof(nameBuf), "%s_%s", pShaderName, pSuffixName );
pFallbackSection = pKeyValues->FindKey( nameBuf );
if (pFallbackSection)
return pFallbackSection;
return NULL;
}
static KeyValues *FindBuiltinFallbackBlock( char const *pShaderName, KeyValues *pKeyValues )
{
// handle "fake" shader fallbacks which are conditional upon mode. like _hdr_dx9, etc
if ( HardwareConfig()->GetDXSupportLevel() < 90 )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"<DX90", pKeyValues );
if ( pRet )
return pRet;
}
if ( HardwareConfig()->GetDXSupportLevel() < 95 )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"<DX95", pKeyValues );
if ( pRet )
return pRet;
}
if ( HardwareConfig()->GetDXSupportLevel() < 90 || !HardwareConfig()->SupportsPixelShaders_2_b() )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"<DX90_20b", pKeyValues );
if ( pRet )
return pRet;
}
if ( HardwareConfig()->GetDXSupportLevel() >= 90 && HardwareConfig()->SupportsPixelShaders_2_b() )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,">=DX90_20b", pKeyValues );
if ( pRet )
return pRet;
}
if ( HardwareConfig()->GetDXSupportLevel() <= 90 )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"<=DX90", pKeyValues );
if ( pRet )
return pRet;
}
if ( HardwareConfig()->GetDXSupportLevel() >= 90 )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,">=DX90", pKeyValues );
if ( pRet )
return pRet;
}
if ( HardwareConfig()->GetDXSupportLevel() > 90 )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,">DX90", pKeyValues );
if ( pRet )
return pRet;
}
if ( HardwareConfig()->GetHDRType() != HDR_TYPE_NONE )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"hdr_dx9", pKeyValues );
if ( pRet )
return pRet;
pRet = CheckConditionalFakeShaderName( pShaderName,"hdr", pKeyValues );
if ( pRet )
return pRet;
}
else
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"ldr", pKeyValues );
if ( pRet )
return pRet;
}
if ( HardwareConfig()->UsesSRGBCorrectBlending() )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"srgb", pKeyValues );
if ( pRet )
return pRet;
}
if ( HardwareConfig()->GetDXSupportLevel() >= 90 )
{
KeyValues *pRet = CheckConditionalFakeShaderName( pShaderName,"dx9", pKeyValues );
if ( pRet )
return pRet;
}
return NULL;
}
inline const char *MissingShaderName()
{
return (IsWindows() && !IsEmulatingGL()) ? "Wireframe_DX8" : "Wireframe_DX9";
}
//-----------------------------------------------------------------------------
// Hooks up the shader
//-----------------------------------------------------------------------------
KeyValues* CMaterial::InitializeShader( KeyValues &keyValues, KeyValues &patchKeyValues, int nFindContext )
{
MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
KeyValues* pCurrentFallback = &keyValues;
KeyValues* pFallbackSection = 0;
char szShaderName[MAX_PATH];
char const* pShaderName = pCurrentFallback->GetName();
if ( !pShaderName )
{
// I'm not quite sure how this can happen, but we'll see...
Warning( "Shader not specified in material %s\nUsing wireframe instead...\n", GetName() );
Assert( 0 );
pShaderName = MissingShaderName();
}
else
{
// can't pass a stable reference to the key values name around
// naive leaf functions can cause KV system to re-alloc
V_strncpy( szShaderName, pShaderName, sizeof( szShaderName ) );
pShaderName = szShaderName;
}
IShader* pShader;
IMaterialVar* ppVars[256];
char pFallbackShaderNameBuf[256];
char pFallbackMaterialNameBuf[256];
int varCount = 0;
bool modelDefault = false;
// Keep going until there's no more fallbacks...
while( true )
{
// Find the shader for this material. Note that this may not be
// the actual shader we use due to fallbacks...
pShader = ShaderSystem()->FindShader( pShaderName );
if ( !pShader )
{
if ( g_pShaderDevice->IsUsingGraphics() )
{
Warning( "Error: Material \"%s\" uses unknown shader \"%s\"\n", GetName(), pShaderName );
//hushed Assert( 0 );
}
pShaderName = MissingShaderName();
pShader = ShaderSystem()->FindShader( pShaderName );
if ( !HushAsserts() )
{
AssertMsg( pShader, "pShader==NULL. Shader: %s", GetName() );
}
#ifndef DEDICATED
if ( !pShader )
{
#ifdef LINUX
// Exit out here. We're running into issues where this material is returned in a horribly broken
// state and you wind up crashing in LockMesh() because the vertex and index buffer pointers
// are NULL. You can repro this by not dying here and showing the intro movie. This happens on
// Linux when you run from a symlink'd SteamApps directory.
Error( "Shader '%s' for material '%s' not found.\n",
pCurrentFallback->GetName() ? pCurrentFallback->GetName() : pShaderName, GetName() );
#endif
MaterialSystem()->Unlock( hMaterialLock );
return NULL;
}
#endif
}
bool bHasBuiltinFallbackBlock = false;
if ( !pFallbackSection )
{
pFallbackSection = FindBuiltinFallbackBlock( pShaderName, &keyValues );
if( pFallbackSection )
{
bHasBuiltinFallbackBlock = true;
pFallbackSection->ChainKeyValue( &keyValues );
pCurrentFallback = pFallbackSection;
}
}
// Here we must set up all flags + material vars that the shader needs
// because it may look at them when choosing shader fallback.
varCount = ParseMaterialVars( pShader, keyValues, pFallbackSection, modelDefault, ppVars, nFindContext );
if ( !pShader )
break;
// Make sure we set default values before the fallback is looked for
ShaderSystem()->InitShaderParameters( pShader, ppVars, GetName() );
// Now that the material vars are parsed, see if there's a fallback
// But only if we're not in the tools
/*
if (!g_pShaderAPI->IsUsingGraphics())
break;
*/
// Check for a fallback; if not, we're done
pShaderName = pShader->GetFallbackShader( ppVars );
if (!pShaderName)
{
break;
}
// Copy off the shader name, as it may be in a materialvar in the shader
// because we're about to delete all materialvars
Q_strncpy( pFallbackShaderNameBuf, pShaderName, 256 );
pShaderName = pFallbackShaderNameBuf;
// Remember the model flag if we're on dx7 or higher...
if (HardwareConfig()->SupportsVertexAndPixelShaders())
{
modelDefault = ( ppVars[FLAGS]->GetIntValue() & MATERIAL_VAR_MODEL ) != 0;
}
// Try to get the section associated with the fallback shader
// Then chain it to the base data so it can override the
// values if it wants to
if( !bHasBuiltinFallbackBlock )
{
pFallbackSection = keyValues.FindKey( pShaderName );
if (pFallbackSection)
{
pFallbackSection->ChainKeyValue( &keyValues );
pCurrentFallback = pFallbackSection;
}
}
// Now, blow away all of the material vars + try again...
for (int i = 0; i < varCount; ++i)
{
Assert( ppVars[i] );
IMaterialVar::Destroy( ppVars[i] );
}
// Check the KeyValues for '$fallbackmaterial'
// Note we have to do this *after* we chain the keyvalues
// based on the fallback shader since the names of the fallback material
// must lie within the shader-specific block usually.
const char *pFallbackMaterial = pCurrentFallback->GetString( "$fallbackmaterial" );
if ( pFallbackMaterial[0] )
{
// Don't fallback to ourselves
if ( Q_stricmp( GetName(), pFallbackMaterial ) )
{
// Gotta copy it off; clearing the keyvalues will blow the string away
Q_strncpy( pFallbackMaterialNameBuf, pFallbackMaterial, 256 );
keyValues.Clear();
if( !LoadVMTFile( keyValues, patchKeyValues, pFallbackMaterialNameBuf, UsesUNCFileName(), NULL ) )
{
Warning( "CMaterial::PrecacheVars: error loading vmt file %s for %s\n", pFallbackMaterialNameBuf, GetName() );
keyValues = *(((CMaterial *)g_pErrorMaterial)->m_pVMTKeyValues);
}
}
else
{
Warning( "CMaterial::PrecacheVars: fallback material for vmt file %s is itself!\n", GetName() );
keyValues = *(((CMaterial *)g_pErrorMaterial)->m_pVMTKeyValues);
}
pCurrentFallback = &keyValues;
pFallbackSection = NULL;
// I'm not quite sure how this can happen, but we'll see...
pShaderName = pCurrentFallback->GetName();
if (!pShaderName)
{
Warning("Shader not specified in material %s (fallback %s)\nUsing wireframe instead...\n", GetName(), pFallbackMaterialNameBuf );
pShaderName = MissingShaderName();
}
}
}
// Store off the shader
m_pShader = pShader;
// Store off the material vars + flags
m_VarCount = varCount;
m_pShaderParams = (IMaterialVar**)malloc( varCount * sizeof(IMaterialVar*) );
memcpy( m_pShaderParams, ppVars, varCount * sizeof(IMaterialVar*) );
#ifdef _DEBUG
for (int i = 0; i < varCount; ++i)
{
Assert( ppVars[i] );
}
#endif
MaterialSystem()->Unlock( hMaterialLock );
return pCurrentFallback;
}
//-----------------------------------------------------------------------------
// Gets the texturemap size
//-----------------------------------------------------------------------------
void CMaterial::PrecacheMappingDimensions( )
{
// Cache mapping width and mapping height
if (!m_representativeTexture)
{
#ifdef PARANOID
Warning( "No representative texture on material: \"%s\"\n", GetName() );
#endif
m_MappingWidth = 64;
m_MappingHeight = 64;
}
else
{
m_MappingWidth = m_representativeTexture->GetMappingWidth();
m_MappingHeight = m_representativeTexture->GetMappingHeight();
}
}
//-----------------------------------------------------------------------------
// Initialize the state snapshot
//-----------------------------------------------------------------------------
bool CMaterial::InitializeStateSnapshots()
{
if (IsPrecached())
{
if ( MaterialSystem()->GetCurrentMaterial() == this)
{
g_pShaderAPI->FlushBufferedPrimitives();
}
// Default state
CleanUpStateSnapshots();
if ( m_pShader && !ShaderSystem()->InitRenderState( m_pShader, m_VarCount, m_pShaderParams, &m_ShaderRenderState, GetName() ))
{
m_Flags &= ~MATERIAL_VALID_RENDERSTATE;
return false;
}
m_Flags |= MATERIAL_VALID_RENDERSTATE;
}
return true;
}
void CMaterial::CleanUpStateSnapshots()
{
if (IsValidRenderState())
{
ShaderSystem()->CleanupRenderState(&m_ShaderRenderState);
// -- THIS CANNOT BE HERE: m_Flags &= ~MATERIAL_VALID_RENDERSTATE;
// -- because it will cause a crash when main thread asks for material
// -- sort group it can temporarily see material in invalid render state
// -- and crash in DecalSurfaceAdd(msurface2_t*, int)
}
}
//-----------------------------------------------------------------------------
// This sets up a debugging/error shader...
//-----------------------------------------------------------------------------
void CMaterial::SetupErrorShader()
{
// Preserve the model flags
int flags = 0;
if ( m_pShaderParams && m_pShaderParams[FLAGS] )
{
flags = (m_pShaderParams[FLAGS]->GetIntValue() & MATERIAL_VAR_MODEL);
}
CleanUpShaderParams();
CleanUpMaterialProxy();
// We had a failure; replace it with a valid shader...
m_pShader = ShaderSystem()->FindShader( MissingShaderName() );
Assert( m_pShader );
// Create undefined vars for all the actual material vars
m_VarCount = m_pShader->GetNumParams();
m_pShaderParams = (IMaterialVar**)malloc( m_VarCount * sizeof(IMaterialVar*) );
for (int i = 0; i < m_VarCount; ++i)
{
m_pShaderParams[i] = IMaterialVar::Create( this, m_pShader->GetParamName(i) );
}
// Store the model flags
SetMaterialVarFlags( flags, true );
// Set the default values
ShaderSystem()->InitShaderParameters( m_pShader, m_pShaderParams, "Error" );
// Invokes the SHADER_INIT block in the various shaders,
ShaderSystem()->InitShaderInstance( m_pShader, m_pShaderParams, "Error", GetTextureGroupName() );
#ifdef DBGFLAG_ASSERT
bool ok =
#endif
InitializeStateSnapshots();
m_QueueFriendlyVersion.UpdateToRealTime();
Assert(ok);
}
//-----------------------------------------------------------------------------
// This computes the state snapshots for this material
//-----------------------------------------------------------------------------
void CMaterial::RecomputeStateSnapshots()
{
CMatCallQueue *pCallQueue = MaterialSystem()->GetRenderCallQueue();
if ( pCallQueue )
{
pCallQueue->QueueCall( this, &CMaterial::RecomputeStateSnapshots );
return;
}
bool ok = InitializeStateSnapshots();
// compute the state snapshots
if (!ok)
{
SetupErrorShader();
}
}
//-----------------------------------------------------------------------------
// Are we valid
//-----------------------------------------------------------------------------
inline bool CMaterial::IsValidRenderState() const
{
return (m_Flags & MATERIAL_VALID_RENDERSTATE) != 0;
}
//-----------------------------------------------------------------------------
// Gets/sets material var flags
//-----------------------------------------------------------------------------
inline int CMaterial::GetMaterialVarFlags() const
{
if ( m_pShaderParams && m_pShaderParams[FLAGS] )
{
return m_pShaderParams[FLAGS]->GetIntValueFast();
}
else
{
return 0;
}
}
inline void CMaterial::SetMaterialVarFlags( int flags, bool on )
{
if ( !m_pShaderParams )
{
Assert( 0 ); // are we hanging onto a material that has been cleaned up or isn't ready?
return;
}
if (on)
{
m_pShaderParams[FLAGS]->SetIntValue( GetMaterialVarFlags() | flags );
}
else
{
m_pShaderParams[FLAGS]->SetIntValue( GetMaterialVarFlags() & (~flags) );
}
// Mark it as being defined...
m_pShaderParams[FLAGS_DEFINED]->SetIntValue( m_pShaderParams[FLAGS_DEFINED]->GetIntValueFast() | flags );
}
inline int CMaterial::GetMaterialVarFlags2() const
{
if ( m_pShaderParams && m_VarCount > FLAGS2 && m_pShaderParams[FLAGS2] )
{
return m_pShaderParams[FLAGS2]->GetIntValueFast();
}
else
{
return 0;
}
}
inline void CMaterial::SetMaterialVarFlags2( int flags, bool on )
{
if ( m_pShaderParams && m_VarCount > FLAGS2 && m_pShaderParams[FLAGS2] )
{
if (on)
m_pShaderParams[FLAGS2]->SetIntValue( GetMaterialVarFlags2() | flags );
else
m_pShaderParams[FLAGS2]->SetIntValue( GetMaterialVarFlags2() & (~flags) );
}
if ( m_pShaderParams && m_VarCount > FLAGS_DEFINED2 && m_pShaderParams[FLAGS_DEFINED2] )
{
// Mark it as being defined...
m_pShaderParams[FLAGS_DEFINED2]->SetIntValue(
m_pShaderParams[FLAGS_DEFINED2]->GetIntValueFast() | flags );
}
}
//-----------------------------------------------------------------------------
// Gets the morph format
//-----------------------------------------------------------------------------
MorphFormat_t CMaterial::GetMorphFormat() const
{
const_cast<CMaterial*>(this)->Precache();
Assert( IsValidRenderState() );
return m_ShaderRenderState.m_MorphFormat;
}
//-----------------------------------------------------------------------------
// Gets the vertex format
//-----------------------------------------------------------------------------
VertexFormat_t CMaterial::GetVertexFormat() const
{
Assert( IsValidRenderState() );
return m_ShaderRenderState.m_VertexFormat;
}
VertexFormat_t CMaterial::GetVertexUsage() const
{
Assert( IsValidRenderState() );
return m_ShaderRenderState.m_VertexUsage;
}
bool CMaterial::PerformDebugTrace() const
{
return IsValidRenderState() && ((GetMaterialVarFlags() & MATERIAL_VAR_DEBUG ) != 0);
}
//-----------------------------------------------------------------------------
// Are we suppressed?
//-----------------------------------------------------------------------------
bool CMaterial::IsSuppressed() const
{
if ( !IsValidRenderState() )
return true;
return ((GetMaterialVarFlags() & MATERIAL_VAR_NO_DRAW) != 0);
}
void CMaterial::ToggleSuppression()
{
if (IsValidRenderState())
{
if ((GetMaterialVarFlags() & MATERIAL_VAR_NO_DEBUG_OVERRIDE) != 0)
return;
SetMaterialVarFlags( MATERIAL_VAR_NO_DRAW,
(GetMaterialVarFlags() & MATERIAL_VAR_NO_DRAW) == 0 );
}
}
void CMaterial::ToggleDebugTrace()
{
if (IsValidRenderState())
{
SetMaterialVarFlags( MATERIAL_VAR_DEBUG,
(GetMaterialVarFlags() & MATERIAL_VAR_DEBUG) == 0 );
}
}
//-----------------------------------------------------------------------------
// Can we override this material in debug?
//-----------------------------------------------------------------------------
bool CMaterial::NoDebugOverride() const
{
return IsValidRenderState() && (GetMaterialVarFlags() & MATERIAL_VAR_NO_DEBUG_OVERRIDE) != 0;
}
//-----------------------------------------------------------------------------
// Material Var flags
//-----------------------------------------------------------------------------
void CMaterial::SetMaterialVarFlag( MaterialVarFlags_t flag, bool on )
{
CMatCallQueue *pCallQueue = MaterialSystem()->GetRenderCallQueue();
if ( pCallQueue )
{
pCallQueue->QueueCall( this, &CMaterial::SetMaterialVarFlag, flag, on );
return;
}
bool oldOn = (GetMaterialVarFlags( ) & flag) != 0;
if (oldOn != on)
{
SetMaterialVarFlags( flag, on );
// This is going to be called from client code; recompute snapshots!
RecomputeStateSnapshots();
}
}
bool CMaterial::GetMaterialVarFlag( MaterialVarFlags_t flag ) const
{
return (GetMaterialVarFlags() & flag) != 0;
}
//-----------------------------------------------------------------------------
// Do we use the env_cubemap entity to get cubemaps from the level?
//-----------------------------------------------------------------------------
bool CMaterial::UsesEnvCubemap( void )
{
Precache();
if( !m_pShader )
{
if ( !HushAsserts() )
{
AssertMsg( m_pShader, "m_pShader==NULL. Shader: %s", GetName() );
}
return false;
}
Assert( m_pShaderParams );
return IsFlag2Set( m_pShaderParams, MATERIAL_VAR2_USES_ENV_CUBEMAP );
}
//-----------------------------------------------------------------------------
// Do we need a tangent space at the vertex level?
//-----------------------------------------------------------------------------
bool CMaterial::NeedsTangentSpace( void )
{
Precache();
if( !m_pShader )
{
if ( !HushAsserts() )
{
AssertMsg( m_pShader, "m_pShader==NULL. Shader: %s", GetName() );
}
return false;
}
Assert( m_pShaderParams );
return IsFlag2Set( m_pShaderParams, MATERIAL_VAR2_NEEDS_TANGENT_SPACES );
}
bool CMaterial::NeedsPowerOfTwoFrameBufferTexture( bool bCheckSpecificToThisFrame )
{
PrecacheVars();
if( !m_pShader )
{
if ( !HushAsserts() )
{
AssertMsg( m_pShader, "m_pShader==NULL. Shader: %s", GetName() );
}
return false;
}
Assert( m_pShaderParams );
return m_pShader->NeedsPowerOfTwoFrameBufferTexture( m_pShaderParams, bCheckSpecificToThisFrame );
}
bool CMaterial::NeedsFullFrameBufferTexture( bool bCheckSpecificToThisFrame )
{
PrecacheVars();
if( !m_pShader )
{
if ( !HushAsserts() )
{
AssertMsg( m_pShader, "m_pShader==NULL. Shader: %s", GetName() );
}
return false;
}
Assert( m_pShaderParams );
return m_pShader->NeedsFullFrameBufferTexture( m_pShaderParams, bCheckSpecificToThisFrame );
}
// GR - Is lightmap alpha needed?
bool CMaterial::NeedsLightmapBlendAlpha( void )
{
Precache();
return (GetMaterialVarFlags2() & MATERIAL_VAR2_BLEND_WITH_LIGHTMAP_ALPHA ) != 0;
}
//-----------------------------------------------------------------------------
// Do we need software skinning?
//-----------------------------------------------------------------------------
bool CMaterial::NeedsSoftwareSkinning( void )
{
Precache();
Assert( m_pShader );
if( !m_pShader )
{
return false;
}
Assert( m_pShaderParams );
return IsFlagSet( m_pShaderParams, MATERIAL_VAR_NEEDS_SOFTWARE_SKINNING );
}
//-----------------------------------------------------------------------------
// Do we need software lighting?
//-----------------------------------------------------------------------------
bool CMaterial::NeedsSoftwareLighting( void )
{
Precache();
Assert( m_pShader );
if( !m_pShader )
{
return false;
}
Assert( m_pShaderParams );
return IsFlag2Set( m_pShaderParams, MATERIAL_VAR2_NEEDS_SOFTWARE_LIGHTING );
}
//-----------------------------------------------------------------------------
// Alpha/color modulation
//-----------------------------------------------------------------------------
void CMaterial::AlphaModulate( float alpha )
{
Precache();
if ( m_VarCount > ALPHA )
m_pShaderParams[ALPHA]->SetFloatValue(alpha);
}
void CMaterial::ColorModulate( float r, float g, float b )
{
Precache();
if ( m_VarCount > COLOR )
m_pShaderParams[COLOR]->SetVecValue( r, g, b );
}
float CMaterial::GetAlphaModulation()
{
Precache();
if ( m_VarCount > ALPHA )
return m_pShaderParams[ALPHA]->GetFloatValue();
return 0.0f;
}
void CMaterial::GetColorModulation( float *r, float *g, float *b )
{
Precache();
float pColor[3] = { 0.0f, 0.0f, 0.0f };
if ( m_VarCount > COLOR )
m_pShaderParams[COLOR]->GetVecValue( pColor, 3 );
*r = pColor[0];
*g = pColor[1];
*b = pColor[2];
}
//-----------------------------------------------------------------------------
// Do we use fog?
//-----------------------------------------------------------------------------
bool CMaterial::UseFog() const
{
Assert( m_VarCount > 0 );
return IsValidRenderState() && ((GetMaterialVarFlags() & MATERIAL_VAR_NOFOG) == 0);
}
//-----------------------------------------------------------------------------
// diffuse bump?
//-----------------------------------------------------------------------------
bool CMaterial::IsUsingDiffuseBumpedLighting() const
{
return (GetMaterialVarFlags2() & MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP ) != 0;
}
//-----------------------------------------------------------------------------
// lightmap?
//-----------------------------------------------------------------------------
bool CMaterial::IsUsingLightmap() const
{
return (GetMaterialVarFlags2() & MATERIAL_VAR2_LIGHTING_LIGHTMAP ) != 0;
}
bool CMaterial::IsManuallyCreated() const
{
return (m_Flags & MATERIAL_IS_MANUALLY_CREATED) != 0;
}
bool CMaterial::UsesUNCFileName() const
{
return (m_Flags & MATERIAL_USES_UNC_FILENAME) != 0;
}
void CMaterial::DecideShouldReloadFromWhitelist( IFileList *pFilesToReload )
{
m_bShouldReloadFromWhitelist = false;
if ( IsManuallyCreated() || !IsPrecached() )
return;
// Materials loaded with an absolute pathname are usually debug materials.
if ( V_IsAbsolutePath( GetName() ) )
return;
char vmtFilename[MAX_PATH];
V_ComposeFileName( "materials", GetName(), vmtFilename, sizeof( vmtFilename ) );
V_strncat( vmtFilename, ".vmt", sizeof( vmtFilename ) );
// Check if either this file or any of the files it included need to be reloaded.
bool bShouldReload = pFilesToReload->IsFileInList( vmtFilename );
if ( !bShouldReload )
{
for ( int i=0; i < m_VMTIncludes.Count(); i++ )
{
g_pFullFileSystem->String( m_VMTIncludes[i], vmtFilename, sizeof( vmtFilename ) );
if ( pFilesToReload->IsFileInList( vmtFilename ) )
{
bShouldReload = true;
break;
}
}
}
m_bShouldReloadFromWhitelist = bShouldReload;
}
void CMaterial::ReloadFromWhitelistIfMarked()
{
if ( !m_bShouldReloadFromWhitelist )
return;
#ifdef PURE_SERVER_DEBUG_SPEW
{
char vmtFilename[MAX_PATH];
V_ComposeFileName( "materials", GetName(), vmtFilename, sizeof( vmtFilename ) );
V_strncat( vmtFilename, ".vmt", sizeof( vmtFilename ) );
Msg( "Reloading %s due to pure server whitelist change\n", GetName() );
}
#endif
Uncache();
Precache();
if ( !GetShader() )
{
// We can get in here if we previously loaded this material off disk and now the whitelist
// says to get it out of Steam but it's not in Steam. So just setup a wireframe thingy
// to draw the material with.
m_Flags |= MATERIAL_IS_PRECACHED | MATERIAL_VARS_IS_PRECACHED;
#if DEBUG
if (IsOSX())
{
printf("\n ##### CMaterial::ReloadFromWhitelistIfMarked: GetShader failed on %s, calling SetupErrorShader", m_pDebugName );
}
#endif
SetupErrorShader();
}
}
bool CMaterial::WasReloadedFromWhitelist()
{
return m_bShouldReloadFromWhitelist;
}
//-----------------------------------------------------------------------------
// Loads the material vars
//-----------------------------------------------------------------------------
bool CMaterial::PrecacheVars( KeyValues *pVMTKeyValues, KeyValues *pPatchKeyValues, CUtlVector<FileNameHandle_t> *pIncludes, int nFindContext )
{
// We should get both parameters or neither
Assert( ( pVMTKeyValues == NULL ) ? ( pPatchKeyValues == NULL ) : ( pPatchKeyValues != NULL ) );
// Don't bother if we're already precached
if( IsPrecachedVars() )
return true;
if ( pIncludes )
m_VMTIncludes = *pIncludes;
else
m_VMTIncludes.Purge();
MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
bool bOk = false;
bool bError = false;
KeyValues *vmtKeyValues = NULL;
KeyValues *patchKeyValues = NULL;
if ( m_pVMTKeyValues )
{
// Use the procedural KeyValues
vmtKeyValues = m_pVMTKeyValues;
patchKeyValues = new KeyValues( "vmt_patches" );
// The caller should not be passing in KeyValues if we have procedural ones
Assert( ( pVMTKeyValues == NULL ) && ( pPatchKeyValues == NULL ) );
}
else if ( pVMTKeyValues )
{
// Use the passed-in (already-loaded) KeyValues
vmtKeyValues = pVMTKeyValues;
patchKeyValues = pPatchKeyValues;
}
else
{
m_VMTIncludes.Purge();
// load data from the vmt file
vmtKeyValues = new KeyValues( "vmt" );
patchKeyValues = new KeyValues( "vmt_patches" );
if( !LoadVMTFile( *vmtKeyValues, *patchKeyValues, GetName(), UsesUNCFileName(), &m_VMTIncludes ) )
{
Warning( "CMaterial::PrecacheVars: error loading vmt file for %s\n", GetName() );
bError = true;
}
}
if ( ! bError )
{
// Needed to prevent re-entrancy
m_Flags |= MATERIAL_VARS_IS_PRECACHED;
// Create shader and the material vars...
KeyValues *pFallbackKeyValues = InitializeShader( *vmtKeyValues, *patchKeyValues, nFindContext );
if ( pFallbackKeyValues )
{
// Gotta initialize the proxies too, using the fallback proxies
InitializeMaterialProxy(pFallbackKeyValues);
bOk = true;
}
}
// Clean up
if ( ( vmtKeyValues != m_pVMTKeyValues ) && ( vmtKeyValues != pVMTKeyValues ) )
{
vmtKeyValues->deleteThis();
}
if ( patchKeyValues != pPatchKeyValues )
{
patchKeyValues->deleteThis();
}
MaterialSystem()->Unlock( hMaterialLock );
return bOk;
}
//-----------------------------------------------------------------------------
// Loads the material info from the VMT file
//-----------------------------------------------------------------------------
void CMaterial::Precache()
{
// Don't bother if we're already precached
if ( IsPrecached() )
return;
// load data from the vmt file
if ( !PrecacheVars() )
return;
MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
m_Flags |= MATERIAL_IS_PRECACHED;
// Invokes the SHADER_INIT block in the various shaders,
if ( m_pShader )
{
ShaderSystem()->InitShaderInstance( m_pShader, m_pShaderParams, GetName(), GetTextureGroupName() );
}
// compute the state snapshots
RecomputeStateSnapshots();
FindRepresentativeTexture();
// Reads in the texture width and height from the material var
PrecacheMappingDimensions();
Assert( IsValidRenderState() );
if( m_pShaderParams )
m_QueueFriendlyVersion.UpdateToRealTime();
MaterialSystem()->Unlock( hMaterialLock );
}
//-----------------------------------------------------------------------------
// Unloads the material data from memory
//-----------------------------------------------------------------------------
void CMaterial::Uncache( bool bPreserveVars )
{
MaterialLock_t hMaterialLock = MaterialSystem()->Lock();
// Don't bother if we're not cached
if ( IsPrecached() )
{
// Clean up the state snapshots
CleanUpStateSnapshots();
m_Flags &= ~MATERIAL_VALID_RENDERSTATE;
m_Flags &= ~MATERIAL_IS_PRECACHED;
}
if ( !bPreserveVars )
{
if ( IsPrecachedVars() )
{
// Clean up the shader + params
CleanUpShaderParams();
m_pShader = 0;
// Clean up the material proxy
CleanUpMaterialProxy();
m_Flags &= ~MATERIAL_VARS_IS_PRECACHED;
}
}
MaterialSystem()->Unlock( hMaterialLock );
// Whether we just now did it, or we were already unloaded,
// notify the pure system that the material is unloaded,
// so it doesn't caue us to fail sv_pure checks
if ( ( m_Flags & ( MATERIAL_VARS_IS_PRECACHED | MATERIAL_IS_MANUALLY_CREATED | MATERIAL_USES_UNC_FILENAME ) ) == 0 )
{
char szName[ MAX_PATH ];
V_sprintf_safe( szName, "materials/%s.vmt", GetName() );
g_pFullFileSystem->NotifyFileUnloaded( szName, "GAME" );
}
}
//-----------------------------------------------------------------------------
// reload all textures used by this materals
//-----------------------------------------------------------------------------
void CMaterial::ReloadTextures( void )
{
Precache();
int i;
int nParams = ShaderParamCount();
IMaterialVar **ppVars = GetShaderParams();
for( i = 0; i < nParams; i++ )
{
if( ppVars[i] )
{
if( ppVars[i]->IsTexture() )
{
ITextureInternal *pTexture = ( ITextureInternal * )ppVars[i]->GetTextureValue();
pTexture->Download();
}
}
}
}
//-----------------------------------------------------------------------------
// Meant to be used with materials created using CreateMaterial
// It updates the materials to reflect the current values stored in the material vars
//-----------------------------------------------------------------------------
void CMaterial::Refresh()
{
if ( g_pShaderDevice->IsUsingGraphics() )
{
Uncache();
Precache();
}
}
void CMaterial::RefreshPreservingMaterialVars()
{
if ( g_pShaderDevice->IsUsingGraphics() )
{
Uncache( true );
Precache();
}
}
//-----------------------------------------------------------------------------
// Gets the material name
//-----------------------------------------------------------------------------
char const* CMaterial::GetName() const
{
return m_Name.String();
}
char const* CMaterial::GetTextureGroupName() const
{
return m_TextureGroupName.String();
}
//-----------------------------------------------------------------------------
// Material dimensions
//-----------------------------------------------------------------------------
int CMaterial::GetMappingWidth( )
{
Precache();
return m_MappingWidth;
}
int CMaterial::GetMappingHeight( )
{
Precache();
return m_MappingHeight;
}
//-----------------------------------------------------------------------------
// Animated material info
//-----------------------------------------------------------------------------
int CMaterial::GetNumAnimationFrames( )
{
Precache();
if( m_representativeTexture )
{
return m_representativeTexture->GetNumAnimationFrames();
}
else
{
#ifndef POSIX
Warning( "CMaterial::GetNumAnimationFrames:\nno representative texture for material %s\n", GetName() );
#endif
return 1;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMaterial::GetMaterialOffset( float *pOffset )
{
// Identity.
pOffset[0] = 0.0f;
pOffset[1] = 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMaterial::GetMaterialScale( float *pScale )
{
// Identity.
pScale[0] = 1.0f;
pScale[1] = 1.0f;
}
//-----------------------------------------------------------------------------
// Reference count
//-----------------------------------------------------------------------------
void CMaterial::IncrementReferenceCount( )
{
++m_RefCount;
}
void CMaterial::DecrementReferenceCount( )
{
--m_RefCount;
}
int CMaterial::GetReferenceCount( ) const
{
return m_RefCount;
}
//-----------------------------------------------------------------------------
// Sets the shader associated with the material
//-----------------------------------------------------------------------------
void CMaterial::SetShader( const char *pShaderName )
{
Assert( pShaderName );
int i;
IShader* pShader;
IMaterialVar* ppVars[256];
int iVarCount = 0;
// Clean up existing state
Uncache();
// Keep going until there's no more fallbacks...
while( true )
{
// Find the shader for this material. Note that this may not be
// the actual shader we use due to fallbacks...
pShader = ShaderSystem()->FindShader( pShaderName );
if (!pShader)
{
// Couldn't find the shader we wanted to use; it's not defined...
Warning( "SetShader: Couldn't find shader %s for material %s!\n", pShaderName, GetName() );
pShaderName = MissingShaderName();
pShader = ShaderSystem()->FindShader( pShaderName );
Assert( pShader );
}
// Create undefined vars for all the actual material vars
iVarCount = pShader->GetNumParams();
for (i = 0; i < iVarCount; ++i)
{
ppVars[i] = IMaterialVar::Create( this, pShader->GetParamName(i) );
}
// Make sure we set default values before the fallback is looked for
ShaderSystem()->InitShaderParameters( pShader, ppVars, pShaderName );
// Now that the material vars are parsed, see if there's a fallback
// But only if we're not in the tools
if (!g_pShaderDevice->IsUsingGraphics())
break;
// Check for a fallback; if not, we're done
pShaderName = pShader->GetFallbackShader( ppVars );
if (!pShaderName)
break;
// Now, blow away all of the material vars + try again...
for (i = 0; i < iVarCount; ++i)
{
Assert( ppVars[i] );
IMaterialVar::Destroy( ppVars[i] );
}
}
// Store off the shader
m_pShader = pShader;
// Store off the material vars + flags
m_VarCount = iVarCount;
m_pShaderParams = (IMaterialVar**)malloc( iVarCount * sizeof(IMaterialVar*) );
memcpy( m_pShaderParams, ppVars, iVarCount * sizeof(IMaterialVar*) );
// Invokes the SHADER_INIT block in the various shaders,
ShaderSystem()->InitShaderInstance( m_pShader, m_pShaderParams, GetName(), GetTextureGroupName() );
// Precache our initial state...
// NOTE: What happens here for textures???
// Pretend that we precached our material vars; we certainly don't have any!
m_Flags |= MATERIAL_VARS_IS_PRECACHED;
// NOTE: The caller has to call 'Refresh' for the shader to be ready...
}
const char *CMaterial::GetShaderName() const
{
const_cast< CMaterial* >( this )->PrecacheVars();
return m_pShader ? m_pShader->GetName() : "shader_error";
}
//-----------------------------------------------------------------------------
// Enumeration ID
//-----------------------------------------------------------------------------
int CMaterial::GetEnumerationID( ) const
{
return m_iEnumerationID;
}
void CMaterial::SetEnumerationID( int id )
{
m_iEnumerationID = id;
}
//-----------------------------------------------------------------------------
// Preview image
//-----------------------------------------------------------------------------
char const* CMaterial::GetPreviewImageName( void )
{
if ( IsConsole() )
{
// not supporting
return NULL;
}
PrecacheVars();
bool found;
IMaterialVar *pRepresentativeTextureVar;
FindVar( "%noToolTexture", &found, false );
if (found)
return NULL;
pRepresentativeTextureVar = FindVar( "%toolTexture", &found, false );
if( found )
{
if (pRepresentativeTextureVar->GetType() == MATERIAL_VAR_TYPE_STRING )
return pRepresentativeTextureVar->GetStringValue();
if (pRepresentativeTextureVar->GetType() == MATERIAL_VAR_TYPE_TEXTURE )
return pRepresentativeTextureVar->GetTextureValue()->GetName();
}
pRepresentativeTextureVar = FindVar( "$baseTexture", &found, false );
if( found )
{
if (pRepresentativeTextureVar->GetType() == MATERIAL_VAR_TYPE_STRING )
return pRepresentativeTextureVar->GetStringValue();
if (pRepresentativeTextureVar->GetType() == MATERIAL_VAR_TYPE_TEXTURE )
return pRepresentativeTextureVar->GetTextureValue()->GetName();
}
return GetName();
}
char const* CMaterial::GetPreviewImageFileName( void ) const
{
char const* pName = const_cast<CMaterial*>(this)->GetPreviewImageName();
if( !pName )
return NULL;
static char vtfFilename[MATERIAL_MAX_PATH];
if( Q_strlen( pName ) >= MATERIAL_MAX_PATH - 5 )
{
Warning( "MATERIAL_MAX_PATH to short for %s.vtf\n", pName );
return NULL;
}
if ( !UsesUNCFileName() )
{
Q_snprintf( vtfFilename, sizeof( vtfFilename ), "materials/%s.vtf", pName );
}
else
{
Q_snprintf( vtfFilename, sizeof( vtfFilename ), "%s.vtf", pName );
}
return vtfFilename;
}
PreviewImageRetVal_t CMaterial::GetPreviewImageProperties( int *width, int *height,
ImageFormat *imageFormat, bool* isTranslucent ) const
{
char const* pFileName = GetPreviewImageFileName();
if ( IsX360() || !pFileName )
{
*width = *height = 0;
*imageFormat = IMAGE_FORMAT_RGBA8888;
*isTranslucent = false;
return MATERIAL_NO_PREVIEW_IMAGE;
}
int nHeaderSize = VTFFileHeaderSize( VTF_MAJOR_VERSION );
unsigned char *pMem = (unsigned char *)stackalloc( nHeaderSize );
CUtlBuffer buf( pMem, nHeaderSize );
if( !g_pFullFileSystem->ReadFile( pFileName, NULL, buf, nHeaderSize ) )
{
Warning( "\"%s\" - \"%s\": cached version doesn't exist\n", GetName(), pFileName );
return MATERIAL_PREVIEW_IMAGE_BAD;
}
IVTFTexture *pVTFTexture = CreateVTFTexture();
if (!pVTFTexture->Unserialize( buf, true ))
{
Warning( "Error reading material \"%s\"\n", pFileName );
DestroyVTFTexture( pVTFTexture );
return MATERIAL_PREVIEW_IMAGE_BAD;
}
*width = pVTFTexture->Width();
*height = pVTFTexture->Height();
*imageFormat = pVTFTexture->Format();
*isTranslucent = (pVTFTexture->Flags() & (TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA)) != 0;
DestroyVTFTexture( pVTFTexture );
return MATERIAL_PREVIEW_IMAGE_OK;
}
PreviewImageRetVal_t CMaterial::GetPreviewImage( unsigned char *pData, int width, int height,
ImageFormat imageFormat ) const
{
CUtlBuffer buf;
int nHeaderSize;
int nImageOffset, nImageSize;
char const* pFileName = GetPreviewImageFileName();
if ( IsX360() || !pFileName )
{
return MATERIAL_NO_PREVIEW_IMAGE;
}
IVTFTexture *pVTFTexture = CreateVTFTexture();
FileHandle_t fileHandle = g_pFullFileSystem->Open( pFileName, "rb" );
if( !fileHandle )
{
Warning( "\"%s\": cached version doesn't exist\n", pFileName );
goto fail;
}
nHeaderSize = VTFFileHeaderSize( VTF_MAJOR_VERSION );
buf.EnsureCapacity( nHeaderSize );
// read the header first.. it's faster!!
int nBytesRead; // GCC won't let this be initialized right away
nBytesRead = g_pFullFileSystem->Read( buf.Base(), nHeaderSize, fileHandle );
buf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );
// Unserialize the header
if (!pVTFTexture->Unserialize( buf, true ))
{
Warning( "Error reading material \"%s\"\n", pFileName );
goto fail;
}
// FIXME: Make sure the preview image size requested is the same
// size as mip level 0 of the texture
Assert( (width == pVTFTexture->Width()) && (height == pVTFTexture->Height()) );
// Determine where in the file to start reading (frame 0, face 0, mip 0)
pVTFTexture->ImageFileInfo( 0, 0, 0, &nImageOffset, &nImageSize );
if ( nImageSize == 0 )
{
Warning( "Couldn't determine offset and size of material \"%s\"\n", pFileName );
goto fail;
}
// Prep the utlbuffer for reading
buf.EnsureCapacity( nImageSize );
buf.SeekPut( CUtlBuffer::SEEK_HEAD, 0 );
// Read in the bits at the specified location
g_pFullFileSystem->Seek( fileHandle, nImageOffset, FILESYSTEM_SEEK_HEAD );
g_pFullFileSystem->Read( buf.Base(), nImageSize, fileHandle );
g_pFullFileSystem->Close( fileHandle );
// Convert from the format read in to the requested format
ImageLoader::ConvertImageFormat( (unsigned char*)buf.Base(), pVTFTexture->Format(),
pData, imageFormat, width, height );
DestroyVTFTexture( pVTFTexture );
return MATERIAL_PREVIEW_IMAGE_OK;
fail:
if( fileHandle )
{
g_pFullFileSystem->Close( fileHandle );
}
int nSize = ImageLoader::GetMemRequired( width, height, 1, imageFormat, false );
memset( pData, 0xff, nSize );
DestroyVTFTexture( pVTFTexture );
return MATERIAL_PREVIEW_IMAGE_BAD;
}
//-----------------------------------------------------------------------------
// Material variables
//-----------------------------------------------------------------------------
IMaterialVar *CMaterial::FindVar( char const *pVarName, bool *pFound, bool complain )
{
PrecacheVars();
// FIXME: Could look for flags here too...
MaterialVarSym_t sym = IMaterialVar::FindSymbol(pVarName);
if ( sym != UTL_INVAL_SYMBOL )
{
for (int i = m_VarCount; --i >= 0; )
{
if (m_pShaderParams[i]->GetNameAsSymbol() == sym)
{
if( pFound )
*pFound = true;
return m_pShaderParams[i];
}
}
}
if( pFound )
*pFound = false;
if( complain )
{
static int complainCount = 0;
if( complainCount < 100 )
{
Warning( "No such variable \"%s\" for material \"%s\"\n", pVarName, GetName() );
complainCount++;
}
}
return GetDummyVariable();
}
struct tokencache_t
{
unsigned short symbol;
unsigned char varIndex;
unsigned char cached;
};
IMaterialVar *CMaterial::FindVarFast( char const *pVarName, unsigned int *pCacheData )
{
tokencache_t *pToken = reinterpret_cast<tokencache_t *>(pCacheData);
PrecacheVars();
if ( pToken->cached )
{
if ( pToken->varIndex < m_VarCount && m_pShaderParams[pToken->varIndex]->GetNameAsSymbol() == pToken->symbol )
return m_pShaderParams[pToken->varIndex];
// FIXME: Could look for flags here too...
if ( !IMaterialVar::SymbolMatches(pVarName, pToken->symbol) )
{
pToken->symbol = IMaterialVar::FindSymbol(pVarName);
}
}
else
{
pToken->cached = true;
pToken->symbol = IMaterialVar::FindSymbol(pVarName);
}
if ( pToken->symbol != UTL_INVAL_SYMBOL )
{
for (int i = m_VarCount; --i >= 0; )
{
if (m_pShaderParams[i]->GetNameAsSymbol() == pToken->symbol)
{
pToken->varIndex = i;
return m_pShaderParams[i];
}
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Lovely material properties
//-----------------------------------------------------------------------------
void CMaterial::GetReflectivity( Vector& reflect )
{
Precache();
reflect = m_Reflectivity;
}
bool CMaterial::GetPropertyFlag( MaterialPropertyTypes_t type )
{
Precache();
if (!IsValidRenderState())
return false;
switch( type )
{
case MATERIAL_PROPERTY_NEEDS_LIGHTMAP:
return IsUsingLightmap();
case MATERIAL_PROPERTY_NEEDS_BUMPED_LIGHTMAPS:
return IsUsingDiffuseBumpedLighting();
}
return false;
}
//-----------------------------------------------------------------------------
// Is the material visible from both sides?
//-----------------------------------------------------------------------------
bool CMaterial::IsTwoSided()
{
PrecacheVars();
return GetMaterialVarFlag(MATERIAL_VAR_NOCULL);
}
//-----------------------------------------------------------------------------
// Are we translucent?
//-----------------------------------------------------------------------------
bool CMaterial::IsTranslucent()
{
Precache();
if ( m_VarCount > ALPHA )
return IsTranslucentInternal( m_pShaderParams? m_pShaderParams[ALPHA]->GetFloatValue() : 0.0 );
return false;
}
bool CMaterial::IsTranslucentInternal( float fAlphaModulation ) const
{
if (m_pShader && IsValidRenderState())
{
// I have to check for alpha modulation here because it isn't
// factored into the shader's notion of whether or not it's transparent
return ::IsTranslucent(&m_ShaderRenderState) ||
(fAlphaModulation < 1.0f) ||
m_pShader->IsTranslucent( m_pShaderParams );
}
return false;
}
//-----------------------------------------------------------------------------
// Are we alphatested?
//-----------------------------------------------------------------------------
bool CMaterial::IsAlphaTested()
{
Precache();
if (m_pShader && IsValidRenderState())
{
return ::IsAlphaTested(&m_ShaderRenderState) ||
GetMaterialVarFlag( MATERIAL_VAR_ALPHATEST );
}
return false;
}
//-----------------------------------------------------------------------------
// Are we vertex lit?
//-----------------------------------------------------------------------------
bool CMaterial::IsVertexLit()
{
Precache();
if (IsValidRenderState())
{
return ( GetMaterialVarFlags2() & MATERIAL_VAR2_LIGHTING_VERTEX_LIT ) != 0;
}
return false;
}
//-----------------------------------------------------------------------------
// Is the shader a sprite card shader?
//-----------------------------------------------------------------------------
bool CMaterial::IsSpriteCard()
{
Precache();
if (IsValidRenderState())
{
return ( GetMaterialVarFlags2() & MATERIAL_VAR2_IS_SPRITECARD ) != 0;
}
return false;
}
//-----------------------------------------------------------------------------
// Proxies
//-----------------------------------------------------------------------------
void CMaterial::CallBindProxy( void *proxyData )
{
CMatCallQueue *pCallQueue = MaterialSystem()->GetRenderCallQueue();
bool bIsThreaded = ( pCallQueue != NULL );
switch (g_config.proxiesTestMode)
{
case 0:
{
// Make sure we call the proxies in the order in which they show up
// in the .vmt file
if ( m_ProxyInfo.Count() )
{
if ( bIsThreaded )
{
EnableThreadedMaterialVarAccess( true, m_pShaderParams, m_VarCount );
}
for( int i = 0; i < m_ProxyInfo.Count(); ++i )
{
m_ProxyInfo[i]->OnBind( proxyData );
}
if ( bIsThreaded )
{
EnableThreadedMaterialVarAccess( false, m_pShaderParams, m_VarCount );
}
}
}
break;
case 2:
// alpha mod all....
{
float value = ( sin( 2.0f * M_PI * Plat_FloatTime() / 10.0f ) * 0.5f ) + 0.5f;
m_pShaderParams[ALPHA]->SetFloatValue( value );
}
break;
case 3:
// color mod all...
{
float value = ( sin( 2.0f * M_PI * Plat_FloatTime() / 10.0f ) * 0.5f ) + 0.5f;
m_pShaderParams[COLOR]->SetVecValue( value, 1.0f, 1.0f );
}
break;
}
}
IMaterial *CMaterial::CheckProxyReplacement( void *proxyData )
{
if ( m_pReplacementProxy != NULL )
{
IMaterial *pReplaceMaterial = m_pReplacementProxy->GetMaterial();
if ( pReplaceMaterial )
{
return pReplaceMaterial;
}
}
return this;
}
bool CMaterial::HasProxy( ) const
{
const_cast< CMaterial* >( this )->PrecacheVars();
return m_ProxyInfo.Count() > 0;
}
//-----------------------------------------------------------------------------
// Main draw method
//-----------------------------------------------------------------------------
#ifdef _WIN32
#pragma warning (disable: 4189)
#endif
void CMaterial::DrawMesh( VertexCompressionType_t vertexCompression )
{
if ( m_pShader )
{
#ifdef _DEBUG
if ( GetMaterialVarFlags() & MATERIAL_VAR_DEBUG )
{
// Putcher breakpoint here to catch the rendering of a material
// marked for debugging ($debug = 1 in a .vmt file) dynamic state version
int x = 0;
}
#endif
if ((GetMaterialVarFlags() & MATERIAL_VAR_NO_DRAW) == 0)
{
const char *pName = m_pShader->GetName();
ShaderSystem()->DrawElements( m_pShader, m_pShaderParams, &m_ShaderRenderState, vertexCompression, m_ChangeID ^ g_nDebugVarsSignature );
}
}
else
{
Warning( "CMaterial::DrawElements: No bound shader\n" );
}
}
#ifdef _WIN32
#pragma warning (default: 4189)
#endif
IShader *CMaterial::GetShader( ) const
{
return m_pShader;
}
IMaterialVar *CMaterial::GetShaderParam( int id )
{
return m_pShaderParams[id];
}
//-----------------------------------------------------------------------------
// Adds a material variable to the material
//-----------------------------------------------------------------------------
void CMaterial::AddMaterialVar( IMaterialVar *pMaterialVar )
{
++m_VarCount;
m_pShaderParams = (IMaterialVar**)realloc( m_pShaderParams, m_VarCount * sizeof( IMaterialVar*) );
m_pShaderParams[m_VarCount-1] = pMaterialVar;
}
bool CMaterial::IsErrorMaterial() const
{
extern IMaterialInternal *g_pErrorMaterial;
const IMaterialInternal *pThis = this;
return g_pErrorMaterial == pThis;
}
void CMaterial::FindRepresentativeTexture( void )
{
Precache();
// First try to find the base texture...
bool found;
IMaterialVar *textureVar = FindVar( "$baseTexture", &found, false );
if( found && textureVar->GetType() == MATERIAL_VAR_TYPE_TEXTURE )
{
ITextureInternal *pTexture = ( ITextureInternal * )textureVar->GetTextureValue();
if( pTexture )
{
pTexture->GetReflectivity( m_Reflectivity );
}
}
if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
{
// Try the env map mask if the base texture doesn't work...
// this is needed for specular decals
textureVar = FindVar( "$envmapmask", &found, false );
if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
{
// Try the bumpmap
textureVar = FindVar( "$bumpmap", &found, false );
if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
{
textureVar = FindVar( "$dudvmap", &found, false );
if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
{
textureVar = FindVar( "$normalmap", &found, false );
if( !found || textureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
{
// Warning( "Can't find representative texture for material \"%s\"\n", GetName() );
m_representativeTexture = TextureManager()->ErrorTexture();
return;
}
}
}
}
}
m_representativeTexture = static_cast<ITextureInternal *>( textureVar->GetTextureValue() );
if (m_representativeTexture)
{
m_representativeTexture->Precache();
}
else
{
m_representativeTexture = TextureManager()->ErrorTexture();
Assert( m_representativeTexture );
}
}
void CMaterial::GetLowResColorSample( float s, float t, float *color ) const
{
if( !m_representativeTexture )
{
return;
}
m_representativeTexture->GetLowResColorSample( s, t, color);
}
//-----------------------------------------------------------------------------
// Lightmap-related methods
//-----------------------------------------------------------------------------
void CMaterial::SetMinLightmapPageID( int pageID )
{
m_minLightmapPageID = pageID;
}
void CMaterial::SetMaxLightmapPageID( int pageID )
{
m_maxLightmapPageID = pageID;
}
int CMaterial::GetMinLightmapPageID( ) const
{
return m_minLightmapPageID;
}
int CMaterial::GetMaxLightmapPageID( ) const
{
return m_maxLightmapPageID;
}
void CMaterial::SetNeedsWhiteLightmap( bool val )
{
if ( val )
m_Flags |= MATERIAL_NEEDS_WHITE_LIGHTMAP;
else
m_Flags &= ~MATERIAL_NEEDS_WHITE_LIGHTMAP;
}
bool CMaterial::GetNeedsWhiteLightmap( ) const
{
return (m_Flags & MATERIAL_NEEDS_WHITE_LIGHTMAP) != 0;
}
void CMaterial::MarkAsPreloaded( bool bSet )
{
if ( bSet )
{
m_Flags |= MATERIAL_IS_PRELOADED;
}
else
{
m_Flags &= ~MATERIAL_IS_PRELOADED;
}
}
bool CMaterial::IsPreloaded() const
{
return ( m_Flags & MATERIAL_IS_PRELOADED ) != 0;
}
void CMaterial::ArtificialAddRef( void )
{
if ( m_Flags & MATERIAL_ARTIFICIAL_REFCOUNT )
{
// already done
return;
}
m_Flags |= MATERIAL_ARTIFICIAL_REFCOUNT;
m_RefCount++;
}
void CMaterial::ArtificialRelease( void )
{
if ( !( m_Flags & MATERIAL_ARTIFICIAL_REFCOUNT ) )
{
return;
}
m_Flags &= ~MATERIAL_ARTIFICIAL_REFCOUNT;
m_RefCount--;
}
//-----------------------------------------------------------------------------
// Return the shader params
//-----------------------------------------------------------------------------
IMaterialVar **CMaterial::GetShaderParams( void )
{
return m_pShaderParams;
}
int CMaterial::ShaderParamCount() const
{
return m_VarCount;
}
//-----------------------------------------------------------------------------
// VMT parser
//-----------------------------------------------------------------------------
void InsertKeyValues( KeyValues& dst, KeyValues& src, bool bCheckForExistence, bool bRecursive )
{
KeyValues *pSrcVar = src.GetFirstSubKey();
while( pSrcVar )
{
if ( !bCheckForExistence || dst.FindKey( pSrcVar->GetName() ) )
{
switch( pSrcVar->GetDataType() )
{
case KeyValues::TYPE_STRING:
dst.SetString( pSrcVar->GetName(), pSrcVar->GetString() );
break;
case KeyValues::TYPE_INT:
dst.SetInt( pSrcVar->GetName(), pSrcVar->GetInt() );
break;
case KeyValues::TYPE_FLOAT:
dst.SetFloat( pSrcVar->GetName(), pSrcVar->GetFloat() );
break;
case KeyValues::TYPE_PTR:
dst.SetPtr( pSrcVar->GetName(), pSrcVar->GetPtr() );
break;
case KeyValues::TYPE_NONE:
{
// Subkey. Recurse.
KeyValues *pNewDest = dst.FindKey( pSrcVar->GetName(), true );
Assert( pNewDest );
InsertKeyValues( *pNewDest, *pSrcVar, bCheckForExistence, true );
}
break;
}
}
pSrcVar = pSrcVar->GetNextKey();
}
if ( bRecursive && !dst.GetFirstSubKey() )
{
// Insert a dummy key to an empty subkey to make sure it doesn't get removed
dst.SetInt( "__vmtpatchdummy", 1 );
}
if( bCheckForExistence )
{
for( KeyValues *pScan = dst.GetFirstTrueSubKey(); pScan; pScan = pScan->GetNextTrueSubKey() )
{
KeyValues *pTmp = src.FindKey( pScan->GetName() );
if( !pTmp )
continue;
// make sure that this is a subkey.
if( pTmp->GetDataType() != KeyValues::TYPE_NONE )
continue;
InsertKeyValues( *pScan, *pTmp, bCheckForExistence );
}
}
}
void WriteKeyValuesToFile( const char *pFileName, KeyValues& keyValues )
{
keyValues.SaveToFile( g_pFullFileSystem, pFileName );
}
void ApplyPatchKeyValues( KeyValues &keyValues, KeyValues &patchKeyValues )
{
KeyValues *pInsertSection = patchKeyValues.FindKey( "insert" );
KeyValues *pReplaceSection = patchKeyValues.FindKey( "replace" );
if ( pInsertSection )
{
InsertKeyValues( keyValues, *pInsertSection, false );
}
if ( pReplaceSection )
{
InsertKeyValues( keyValues, *pReplaceSection, true );
}
// Could add other commands here, like "delete", "rename", etc.
}
//-----------------------------------------------------------------------------
// Adds keys from srcKeys to destKeys, overwriting any keys that are already
// there.
//-----------------------------------------------------------------------------
void MergeKeyValues( KeyValues &srcKeys, KeyValues &destKeys )
{
for( KeyValues *pKV = srcKeys.GetFirstValue(); pKV; pKV = pKV->GetNextValue() )
{
switch( pKV->GetDataType() )
{
case KeyValues::TYPE_STRING:
destKeys.SetString( pKV->GetName(), pKV->GetString() );
break;
case KeyValues::TYPE_INT:
destKeys.SetInt( pKV->GetName(), pKV->GetInt() );
break;
case KeyValues::TYPE_FLOAT:
destKeys.SetFloat( pKV->GetName(), pKV->GetFloat() );
break;
case KeyValues::TYPE_PTR:
destKeys.SetPtr( pKV->GetName(), pKV->GetPtr() );
break;
}
}
for( KeyValues *pKV = srcKeys.GetFirstTrueSubKey(); pKV; pKV = pKV->GetNextTrueSubKey() )
{
KeyValues *pDestKV = destKeys.FindKey( pKV->GetName(), true );
MergeKeyValues( *pKV, *pDestKV );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void AccumulatePatchKeyValues( KeyValues &srcKeyValues, KeyValues &patchKeyValues )
{
KeyValues *pDestInsertSection = patchKeyValues.FindKey( "insert" );
if ( pDestInsertSection == NULL )
{
pDestInsertSection = new KeyValues( "insert" );
patchKeyValues.AddSubKey( pDestInsertSection );
}
KeyValues *pDestReplaceSection = patchKeyValues.FindKey( "replace" );
if ( pDestReplaceSection == NULL )
{
pDestReplaceSection = new KeyValues( "replace" );
patchKeyValues.AddSubKey( pDestReplaceSection );
}
KeyValues *pSrcInsertSection = srcKeyValues.FindKey( "insert" );
if ( pSrcInsertSection )
{
MergeKeyValues( *pSrcInsertSection, *pDestInsertSection );
}
KeyValues *pSrcReplaceSection = srcKeyValues.FindKey( "replace" );
if ( pSrcReplaceSection )
{
MergeKeyValues( *pSrcReplaceSection, *pDestReplaceSection );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool AccumulateRecursiveVmtPatches( KeyValues &patchKeyValuesOut, KeyValues **ppBaseKeyValuesOut, const KeyValues& keyValues, const char *pPathID, CUtlVector<FileNameHandle_t> *pIncludes )
{
if ( pIncludes )
{
pIncludes->Purge();
}
patchKeyValuesOut.Clear();
if ( V_stricmp( keyValues.GetName(), "patch" ) != 0 )
{
// Not a patch file, nothing to do
if ( ppBaseKeyValuesOut )
{
// flag to the caller that the passed in keyValues are in fact final non-patch values
*ppBaseKeyValuesOut = NULL;
}
return true;
}
KeyValues *pCurrentKeyValues = keyValues.MakeCopy();
// Recurse down through all patch files:
int nCount = 0;
while( ( nCount < 10 ) && ( V_stricmp( pCurrentKeyValues->GetName(), "patch" ) == 0 ) )
{
// Accumulate the new patch keys from this file
AccumulatePatchKeyValues( *pCurrentKeyValues, patchKeyValuesOut );
// Load the included file
const char *pIncludeFileName = pCurrentKeyValues->GetString( "include" );
if ( pIncludeFileName == NULL )
{
// A patch file without an include key? Not good...
Warning( "VMT patch file has no include key - invalid!\n" );
Assert( pIncludeFileName );
break;
}
CUtlString includeFileName( pIncludeFileName ); // copy off the string before we clear the keyvalues it lives in
pCurrentKeyValues->Clear();
bool bSuccess = pCurrentKeyValues->LoadFromFile( g_pFullFileSystem, includeFileName, pPathID );
if( bSuccess )
{
if ( pIncludes )
{
// Remember that we included this file for the pure server stuff.
pIncludes->AddToTail( g_pFullFileSystem->FindOrAddFileName( includeFileName ) );
}
}
else
{
pCurrentKeyValues->deleteThis();
#ifndef DEDICATED
Warning( "Failed to load $include VMT file (%s)\n", includeFileName.String() );
#endif
if ( !HushAsserts() )
{
AssertMsg( false, "Failed to load $include VMT file (%s)", includeFileName.String() );
}
return false;
}
nCount++;
}
if ( ppBaseKeyValuesOut )
{
*ppBaseKeyValuesOut = pCurrentKeyValues;
}
else
{
pCurrentKeyValues->deleteThis();
}
if( nCount >= 10 )
{
Warning( "Infinite recursion in patch file?\n" );
}
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ExpandPatchFile( KeyValues& keyValues, KeyValues &patchKeyValues, const char *pPathID, CUtlVector<FileNameHandle_t> *pIncludes )
{
KeyValues *pNonPatchKeyValues = NULL;
if ( !patchKeyValues.IsEmpty() )
{
pNonPatchKeyValues = keyValues.MakeCopy();
}
else
{
bool bSuccess = AccumulateRecursiveVmtPatches( patchKeyValues, &pNonPatchKeyValues, keyValues, pPathID, pIncludes );
if ( !bSuccess )
{
return;
}
}
if ( pNonPatchKeyValues != NULL )
{
// We're dealing with a patch file. Apply accumulated patches to final vmt
ApplyPatchKeyValues( *pNonPatchKeyValues, patchKeyValues );
keyValues = *pNonPatchKeyValues;
pNonPatchKeyValues->deleteThis();
}
}
bool LoadVMTFile( KeyValues &vmtKeyValues, KeyValues &patchKeyValues, const char *pMaterialName, bool bAbsolutePath, CUtlVector<FileNameHandle_t> *pIncludes )
{
char pFileName[MAX_PATH];
const char *pPathID = "GAME";
if ( !bAbsolutePath )
{
Q_snprintf( pFileName, sizeof( pFileName ), "materials/%s.vmt", pMaterialName );
}
else
{
Q_snprintf( pFileName, sizeof( pFileName ), "%s.vmt", pMaterialName );
if ( pMaterialName[0] == '/' && pMaterialName[1] == '/' && pMaterialName[2] != '/' )
{
// UNC, do full search
pPathID = NULL;
}
}
if ( !vmtKeyValues.LoadFromFile( g_pFullFileSystem, pFileName, pPathID ) )
{
return false;
}
ExpandPatchFile( vmtKeyValues, patchKeyValues, pPathID, pIncludes );
return true;
}
int CMaterial::GetNumPasses( void )
{
Precache();
// int mod = m_ShaderRenderState.m_Modulation;
int mod = 0;
return m_ShaderRenderState.m_pSnapshots[mod].m_nPassCount;
}
int CMaterial::GetTextureMemoryBytes( void )
{
Precache();
int bytes = 0;
int i;
for( i = 0; i < m_VarCount; i++ )
{
IMaterialVar *pVar = m_pShaderParams[i];
if( pVar->GetType() == MATERIAL_VAR_TYPE_TEXTURE )
{
ITexture *pTexture = pVar->GetTextureValue();
if( pTexture && pTexture != ( ITexture * )0xffffffff )
{
bytes += pTexture->GetApproximateVidMemBytes();
}
}
}
return bytes;
}
void CMaterial::SetUseFixedFunctionBakedLighting( bool bEnable )
{
SetMaterialVarFlags2( MATERIAL_VAR2_USE_FIXED_FUNCTION_BAKED_LIGHTING, bEnable );
}
bool CMaterial::NeedsFixedFunctionFlashlight() const
{
return ( GetMaterialVarFlags2() & MATERIAL_VAR2_NEEDS_FIXED_FUNCTION_FLASHLIGHT ) &&
MaterialSystem()->InFlashlightMode();
}
bool CMaterial::IsUsingVertexID( ) const
{
return ( GetMaterialVarFlags2() & MATERIAL_VAR2_USES_VERTEXID ) != 0;
}
void CMaterial::DeleteIfUnreferenced()
{
if ( m_RefCount > 0 )
return;
IMaterialVar::DeleteUnreferencedTextures( true );
IMaterialInternal::DestroyMaterial( this );
IMaterialVar::DeleteUnreferencedTextures( false );
}