expvintl/source-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
3458c36d5a
source-engine/materialsystem/cmaterialsystem.cpp

5551 lines
180 KiB
C++
Raw Normal View History

1
2020-04-23 00:56:21 +08:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include "pch_materialsystem.h"
#define MATSYS_INTERNAL
#include "cmaterialsystem.h"
#include "colorspace.h"
#include "materialsystem/materialsystem_config.h"
#include "IHardwareConfigInternal.h"
#include "shadersystem.h"
#include "texturemanager.h"
#include "shaderlib/ShaderDLL.h"
#include "tier1/callqueue.h"
#include "vstdlib/jobthread.h"
#include "cmatnullrendercontext.h"
#include "filesystem/IQueuedLoader.h"
#include "datacache/idatacache.h"
#include "materialsystem/imaterialproxy.h"
#include "vstdlib/IKeyValuesSystem.h"
#include "ctexturecompositor.h"
#if defined( _X360 )
#include "xbox/xbox_console.h"
#include "xbox/xbox_win32stubs.h"
#endif
// NOTE: This must be the last file included!!!
#include "tier0/memdbgon.h"
#ifdef POSIX
#define _finite finite
#endif
// this is hooked into the engines convar
ConVar mat_debugalttab( "mat_debugalttab", "0", FCVAR_CHEAT );
ConVar mat_forcemanagedtextureintohardware( "mat_forcemanagedtextureintohardware", "1", FCVAR_HIDDEN | FCVAR_ALLOWED_IN_COMPETITIVE );
ConVar mat_supportflashlight( "mat_supportflashlight", "-1", FCVAR_HIDDEN, "0 - do not support flashlight (don't load flashlight shader combos), 1 - flashlight is supported" );
#ifdef OSX
#define CV_FRAME_SWAP_WORKAROUND_DEFAULT "1"
#else
#define CV_FRAME_SWAP_WORKAROUND_DEFAULT "0"
#endif
ConVar mat_texture_reload_frame_swap_workaround( "mat_texture_reload_frame_swap_workaround", CV_FRAME_SWAP_WORKAROUND_DEFAULT, FCVAR_INTERNAL_USE,
"Workaround certain GL drivers holding unnecessary amounts of data when loading many materials by forcing synthetic frame swaps" );
// This ConVar allows us to skip ~40% of our map load time, but it doesn't work on GPUs older
// than ~2005. We set it automatically and don't expose it to players.
ConVar mat_requires_rt_alloc_first( "mat_requires_rt_alloc_first", "0", FCVAR_HIDDEN );
// Make sure this convar gets created before videocfg.lib is initialized, so it can be driven by dxsupport.cfg
static ConVar mat_tonemapping_occlusion_use_stencil( "mat_tonemapping_occlusion_use_stencil", "0" );
#ifdef DX_TO_GL_ABSTRACTION
// In GL mode, we currently require mat_dxlevel to be between 90-92
static ConVar mat_dxlevel( "mat_dxlevel", "92", 0, "", true, 90, true, 92, NULL );
#else
static ConVar mat_dxlevel( "mat_dxlevel", "0", 0, "Current DirectX Level. Competitive play requires at least mat_dxlevel 90", false, 0, false, 0, true, 90, false, 0, NULL );
#endif
IMaterialInternal *g_pErrorMaterial = NULL;
CreateInterfaceFn g_fnMatSystemConnectCreateInterface = NULL;
static int ReadListFromFile(CUtlVector<char*>* outReplacementMaterials, const char *pszPathName);
//#define PERF_TESTING 1
//-----------------------------------------------------------------------------
// Implementational structures
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Singleton instance exposed to the engine
//-----------------------------------------------------------------------------
CMaterialSystem g_MaterialSystem;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CMaterialSystem, IMaterialSystem,
MATERIAL_SYSTEM_INTERFACE_VERSION, g_MaterialSystem );
// Expose this to the external shader DLLs
MaterialSystem_Config_t g_config;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( MaterialSystem_Config_t, MaterialSystem_Config_t, MATERIALSYSTEM_CONFIG_VERSION, g_config );
//-----------------------------------------------------------------------------
CThreadFastMutex g_MatSysMutex;
//-----------------------------------------------------------------------------
// Purpose: additional materialsystem information, internal use only
//-----------------------------------------------------------------------------
#ifndef _X360
struct MaterialSystem_Config_Internal_t
{
int r_waterforceexpensive;
};
MaterialSystem_Config_Internal_t g_config_internal;
#endif
//-----------------------------------------------------------------------------
// Necessary to allow the shader DLLs to get ahold of IMaterialSystemHardwareConfig
//-----------------------------------------------------------------------------
IHardwareConfigInternal* g_pHWConfig = 0;
static void *GetHardwareConfig()
{
if ( g_pHWConfig )
return (IMaterialSystemHardwareConfig*)g_pHWConfig;
// can't call QueryShaderAPI here because it calls a factory function
// and we end up in an infinite recursion
return NULL;
}
EXPOSE_INTERFACE_FN( GetHardwareConfig, IMaterialSystemHardwareConfig, MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION );
//-----------------------------------------------------------------------------
// Necessary to allow the shader DLLs to get ahold of ICvar
//-----------------------------------------------------------------------------
static void *GetICVar()
{
return g_pCVar;
}
EXPOSE_INTERFACE_FN( GetICVar, ICVar, CVAR_INTERFACE_VERSION );
//-----------------------------------------------------------------------------
// Accessor to get at the material system
//-----------------------------------------------------------------------------
IMaterialSystemInternal *g_pInternalMaterialSystem = &g_MaterialSystem;
IShaderUtil *g_pShaderUtil = &g_MaterialSystem;
#if defined(USE_SDL)
#include "appframework/ilaunchermgr.h"
ILauncherMgr *g_pLauncherMgr = NULL; // set in CMaterialSystem::Connect
#endif
//-----------------------------------------------------------------------------
// Factory used to get at internal interfaces (used by shaderapi + shader dlls)
//-----------------------------------------------------------------------------
void *ShaderFactory( const char *pName, int *pReturnCode )
{
if (pReturnCode)
{
*pReturnCode = IFACE_OK;
}
if ( !Q_stricmp( pName, FILESYSTEM_INTERFACE_VERSION ))
return g_pFullFileSystem;
if ( !Q_stricmp( pName, QUEUEDLOADER_INTERFACE_VERSION ))
return g_pQueuedLoader;
if ( !Q_stricmp( pName, SHADER_UTIL_INTERFACE_VERSION ))
return g_pShaderUtil;
#ifdef USE_SDL
if ( !Q_stricmp( pName, "SDLMgrInterface001" /*SDLMGR_INTERFACE_VERSION*/ ))
return g_pLauncherMgr;
#endif
void * pInterface = g_MaterialSystem.QueryInterface( pName );
if ( pInterface )
return pInterface;
if ( pReturnCode )
{
*pReturnCode = IFACE_FAILED;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Resource preloading for materials.
//-----------------------------------------------------------------------------
class CResourcePreloadMaterial : public CResourcePreload
{
virtual bool CreateResource( const char *pName )
{
IMaterial *pMaterial = g_MaterialSystem.FindMaterial( pName, TEXTURE_GROUP_WORLD, false );
IMaterialInternal *pMatInternal = static_cast< IMaterialInternal * >( pMaterial );
if ( pMatInternal )
{
// always work with the realtime material internally
pMatInternal = pMatInternal->GetRealTimeVersion();
// tag these for later identification (prevents an unwanted purge)
pMatInternal->MarkAsPreloaded( true );
if ( !pMatInternal->IsErrorMaterial() )
{
// force material's textures to create now
pMatInternal->Precache();
return true;
}
else
{
if ( IsPosix() )
{
printf("\n ##### CResourcePreloadMaterial::CreateResource can't find material %s\n", pName);
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// Called before queued loader i/o jobs are actually performed. Must free up memory
// to ensure i/o requests have enough memory to succeed. The materials that were
// touched by the CreateResource() are inhibited from purging (as is their textures,
// by virtue of ref counts), all others are candidates. The preloaded materials
// are by definition zero ref'd until owned by the normal loading process. Any material
// that stays zero ref'd is a candidate for the post load purge.
//-----------------------------------------------------------------------------
virtual void PurgeUnreferencedResources()
{
bool bSpew = ( g_pQueuedLoader->GetSpewDetail() & LOADER_DETAIL_PURGES ) != 0;
bool bDidUncacheMaterial = false;
MaterialHandle_t hNext;
for ( MaterialHandle_t hMaterial = g_MaterialSystem.FirstMaterial(); hMaterial != g_MaterialSystem.InvalidMaterial(); hMaterial = hNext )
{
hNext = g_MaterialSystem.NextMaterial( hMaterial );
IMaterialInternal *pMatInternal = g_MaterialSystem.GetMaterialInternal( hMaterial );
Assert( pMatInternal->GetReferenceCount() >= 0 );
// preloaded materials are safe from this pre-purge
if ( !pMatInternal->IsPreloaded() )
{
// undo any possible artifical ref count
pMatInternal->ArtificialRelease();
if ( pMatInternal->GetReferenceCount() <= 0 )
{
if ( bSpew )
{
Msg( "CResourcePreloadMaterial: Purging: %s (%d)\n", pMatInternal->GetName(), pMatInternal->GetReferenceCount() );
}
bDidUncacheMaterial = true;
pMatInternal->Uncache();
pMatInternal->DeleteIfUnreferenced();
}
}
else
{
// clear the bit
pMatInternal->MarkAsPreloaded( false );
}
}
// purged materials unreference their textures
// purge any zero ref'd textures
TextureManager()->RemoveUnusedTextures();
// fixup any excluded textures, may cause some new batch requests
MaterialSystem()->UpdateExcludedTextures();
}
virtual void PurgeAll()
{
bool bSpew = ( g_pQueuedLoader->GetSpewDetail() & LOADER_DETAIL_PURGES ) != 0;
bool bDidUncacheMaterial = false;
MaterialHandle_t hNext;
for ( MaterialHandle_t hMaterial = g_MaterialSystem.FirstMaterial(); hMaterial != g_MaterialSystem.InvalidMaterial(); hMaterial = hNext )
{
hNext = g_MaterialSystem.NextMaterial( hMaterial );
IMaterialInternal *pMatInternal = g_MaterialSystem.GetMaterialInternal( hMaterial );
Assert( pMatInternal->GetReferenceCount() >= 0 );
pMatInternal->MarkAsPreloaded( false );
// undo any possible artifical ref count
pMatInternal->ArtificialRelease();
if ( pMatInternal->GetReferenceCount() <= 0 )
{
if ( bSpew )
{
Msg( "CResourcePreloadMaterial: Purging: %s (%d)\n", pMatInternal->GetName(), pMatInternal->GetReferenceCount() );
}
bDidUncacheMaterial = true;
pMatInternal->Uncache();
pMatInternal->DeleteIfUnreferenced();
}
}
// purged materials unreference their textures
// purge any zero ref'd textures
TextureManager()->RemoveUnusedTextures();
}
};
static CResourcePreloadMaterial s_ResourcePreloadMaterial;
//-----------------------------------------------------------------------------
// Resource preloading for cubemaps.
//-----------------------------------------------------------------------------
class CResourcePreloadCubemap : public CResourcePreload
{
virtual bool CreateResource( const char *pName )
{
ITexture *pTexture = g_MaterialSystem.FindTexture( pName, TEXTURE_GROUP_CUBE_MAP, true );
ITextureInternal *pTexInternal = static_cast< ITextureInternal * >( pTexture );
if ( pTexInternal )
{
// There can be cubemaps that are unbound by materials. To prevent an unwanted purge,
// mark and increase the ref count. Otherwise the pre-purge discards these zero
// ref'd textures, and then the normal loading process hitches on the miss.
// The zombie cubemaps DO get discarded after the normal loading process completes
// if no material references them.
pTexInternal->MarkAsPreloaded( true );
pTexInternal->IncrementReferenceCount();
if ( !IsErrorTexture( pTexInternal ) )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// All valid cubemaps should have been owned by their materials. Undo the preloaded
// cubemap locks. Any zero ref'd cubemaps will be purged by the normal loading path conclusion.
//-----------------------------------------------------------------------------
virtual void OnEndMapLoading( bool bAbort )
{
int iIndex = -1;
for ( ;; )
{
ITextureInternal *pTexInternal;
iIndex = TextureManager()->FindNext( iIndex, &pTexInternal );
if ( iIndex == -1 || !pTexInternal )
{
// end of list
break;
}
if ( pTexInternal->IsPreloaded() )
{
// undo the artificial increase
pTexInternal->MarkAsPreloaded( false );
pTexInternal->DecrementReferenceCount();
}
}
}
};
static CResourcePreloadCubemap s_ResourcePreloadCubemap;
//-----------------------------------------------------------------------------
// Creates the debugging materials
//-----------------------------------------------------------------------------
void CMaterialSystem::CreateDebugMaterials()
{
if ( !m_pDrawFlatMaterial )
{
KeyValues *pVMTKeyValues = new KeyValues( "UnlitGeneric" );
pVMTKeyValues->SetInt( "$model", 1 );
pVMTKeyValues->SetFloat( "$decalscale", 0.05f );
pVMTKeyValues->SetString( "$basetexture", "error" ); // This is the "error texture"
g_pErrorMaterial = static_cast<IMaterialInternal*>(CreateMaterial( "___error.vmt", pVMTKeyValues ))->GetRealTimeVersion();
pVMTKeyValues = new KeyValues( "UnlitGeneric" );
pVMTKeyValues->SetInt( "$flat", 1 );
pVMTKeyValues->SetInt( "$vertexcolor", 1 );
m_pDrawFlatMaterial = static_cast<IMaterialInternal*>(CreateMaterial( "___flat.vmt", pVMTKeyValues ))->GetRealTimeVersion();
pVMTKeyValues = new KeyValues( "BufferClearObeyStencil" );
pVMTKeyValues->SetInt( "$nocull", 1 );
m_pBufferClearObeyStencil[BUFFER_CLEAR_NONE] = static_cast<IMaterialInternal*>(CreateMaterial( "___buffer_clear_obey_stencil0.vmt", pVMTKeyValues ))->GetRealTimeVersion();
pVMTKeyValues = new KeyValues( "BufferClearObeyStencil" );
pVMTKeyValues->SetInt( "$nocull", 1 );
pVMTKeyValues->SetInt( "$clearcolor", 1 );
pVMTKeyValues->SetInt( "$vertexcolor", 1 );
m_pBufferClearObeyStencil[BUFFER_CLEAR_COLOR] = static_cast<IMaterialInternal*>(CreateMaterial( "___buffer_clear_obey_stencil1.vmt", pVMTKeyValues ))->GetRealTimeVersion();
pVMTKeyValues = new KeyValues( "BufferClearObeyStencil" );
pVMTKeyValues->SetInt( "$nocull", 1 );
pVMTKeyValues->SetInt( "$clearalpha", 1 );
pVMTKeyValues->SetInt( "$vertexcolor", 1 );
m_pBufferClearObeyStencil[BUFFER_CLEAR_ALPHA] = static_cast<IMaterialInternal*>(CreateMaterial( "___buffer_clear_obey_stencil2.vmt", pVMTKeyValues ))->GetRealTimeVersion();
pVMTKeyValues = new KeyValues( "BufferClearObeyStencil" );
pVMTKeyValues->SetInt( "$nocull", 1 );
pVMTKeyValues->SetInt( "$clearcolor", 1 );
pVMTKeyValues->SetInt( "$clearalpha", 1 );
pVMTKeyValues->SetInt( "$vertexcolor", 1 );
m_pBufferClearObeyStencil[BUFFER_CLEAR_COLOR_AND_ALPHA] = static_cast<IMaterialInternal*>(CreateMaterial( "___buffer_clear_obey_stencil3.vmt", pVMTKeyValues ))->GetRealTimeVersion();
pVMTKeyValues = new KeyValues( "BufferClearObeyStencil" );
pVMTKeyValues->SetInt( "$nocull", 1 );
pVMTKeyValues->SetInt( "$cleardepth", 1 );
m_pBufferClearObeyStencil[BUFFER_CLEAR_DEPTH] = static_cast<IMaterialInternal*>(CreateMaterial( "___buffer_clear_obey_stencil4.vmt", pVMTKeyValues ))->GetRealTimeVersion();
pVMTKeyValues = new KeyValues( "BufferClearObeyStencil" );
pVMTKeyValues->SetInt( "$nocull", 1 );
pVMTKeyValues->SetInt( "$cleardepth", 1 );
pVMTKeyValues->SetInt( "$clearcolor", 1 );
pVMTKeyValues->SetInt( "$vertexcolor", 1 );
m_pBufferClearObeyStencil[BUFFER_CLEAR_COLOR_AND_DEPTH] = static_cast<IMaterialInternal*>(CreateMaterial( "___buffer_clear_obey_stencil5.vmt", pVMTKeyValues ))->GetRealTimeVersion();
pVMTKeyValues = new KeyValues( "BufferClearObeyStencil" );
pVMTKeyValues->SetInt( "$nocull", 1 );
pVMTKeyValues->SetInt( "$cleardepth", 1 );
pVMTKeyValues->SetInt( "$clearalpha", 1 );
pVMTKeyValues->SetInt( "$vertexcolor", 1 );
m_pBufferClearObeyStencil[BUFFER_CLEAR_ALPHA_AND_DEPTH] = static_cast<IMaterialInternal*>(CreateMaterial( "___buffer_clear_obey_stencil6.vmt", pVMTKeyValues ))->GetRealTimeVersion();
pVMTKeyValues = new KeyValues( "BufferClearObeyStencil" );
pVMTKeyValues->SetInt( "$nocull", 1 );
pVMTKeyValues->SetInt( "$cleardepth", 1 );
pVMTKeyValues->SetInt( "$clearcolor", 1 );
pVMTKeyValues->SetInt( "$clearalpha", 1 );
pVMTKeyValues->SetInt( "$vertexcolor", 1 );
m_pBufferClearObeyStencil[BUFFER_CLEAR_COLOR_AND_ALPHA_AND_DEPTH] = static_cast<IMaterialInternal*>(CreateMaterial( "___buffer_clear_obey_stencil7.vmt", pVMTKeyValues ))->GetRealTimeVersion();
if ( IsX360() )
{
pVMTKeyValues = new KeyValues( "RenderTargetBlit_X360" );
m_pRenderTargetBlitMaterial = static_cast<IMaterialInternal*>(CreateMaterial( "___renderTargetBlit.vmt", pVMTKeyValues ))->GetRealTimeVersion();
}
ShaderSystem()->CreateDebugMaterials();
}
}
//-----------------------------------------------------------------------------
// Creates compositor materials
//-----------------------------------------------------------------------------
void CMaterialSystem::CreateCompositorMaterials()
{
// precache composite materials
for ( int i = ECO_FirstPrecacheMaterial; i < ECO_LastPrecacheMaterial; i++ )
{
const char *pszMaterial = GetCombinedMaterialName( ( ECombineOperation ) i );
if ( pszMaterial[ 0 ] == '\0' )
continue;
IMaterialInternal *pMatqf = assert_cast< IMaterialInternal* >( FindMaterial( pszMaterial, TEXTURE_GROUP_RUNTIME_COMPOSITE ) );
Assert( pMatqf );
materialsystem: unlock mat_picmip cvar again
2022-08-03 21:30:27 +08:00
//Assert( !pMatqf->IsErrorMaterial() );
1
2020-04-23 00:56:21 +08:00
IMaterialInternal *pMatrt = pMatqf->GetRealTimeVersion();
Assert( pMatrt );
pMatrt->IncrementReferenceCount(); // Hold a ref.
m_pCompositorMaterials.AddToTail( pMatrt );
}
}
//-----------------------------------------------------------------------------
// Cleanup compositor materials
//-----------------------------------------------------------------------------
void CMaterialSystem::CleanUpCompositorMaterials()
{
FOR_EACH_VEC( m_pCompositorMaterials, i )
{
if ( m_pCompositorMaterials[ i ] == NULL )
continue;
m_pCompositorMaterials[ i ]->DecrementReferenceCount();
RemoveMaterial( m_pCompositorMaterials[ i ] );
}
m_pCompositorMaterials.RemoveAll();
}
//-----------------------------------------------------------------------------
// Creates the debugging materials
//-----------------------------------------------------------------------------
void CMaterialSystem::CleanUpDebugMaterials()
{
if ( m_pDrawFlatMaterial )
{
m_pDrawFlatMaterial->DecrementReferenceCount();
RemoveMaterial( m_pDrawFlatMaterial );
m_pDrawFlatMaterial = NULL;
for ( int i = BUFFER_CLEAR_NONE; i < BUFFER_CLEAR_TYPE_COUNT; ++i )
{
m_pBufferClearObeyStencil[i]->DecrementReferenceCount();
RemoveMaterial( m_pBufferClearObeyStencil[i] );
m_pBufferClearObeyStencil[i] = NULL;
}
if ( IsX360() )
{
m_pRenderTargetBlitMaterial->DecrementReferenceCount();
RemoveMaterial( m_pRenderTargetBlitMaterial );
m_pRenderTargetBlitMaterial = NULL;
}
ShaderSystem()->CleanUpDebugMaterials();
}
}
void CMaterialSystem::CleanUpErrorMaterial()
{
// Destruction of g_pErrorMaterial is deferred until after CMaterialDict::Shutdown.
// The global g_pErrorMaterial is set to NULL so that IsErrorMaterial() will return false and
// RemoveMaterial() / DestroyMaterial() will delete it.
IMaterialInternal *pErrorMaterial = g_pErrorMaterial;
g_pErrorMaterial = NULL;
pErrorMaterial->DecrementReferenceCount();
RemoveMaterial( pErrorMaterial );
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CMaterialSystem::CMaterialSystem()
{
amd64: fix multithread, fix vgui, fix physmodels
2022-06-05 06:44:42 +08:00
m_nRenderThreadID = (uintp)-1;
1
2020-04-23 00:56:21 +08:00
m_hAsyncLoadFileCache = NULL;
m_ShaderHInst = 0;
m_pMaterialProxyFactory = NULL;
m_nAdapter = 0;
m_nAdapterFlags = 0;
m_bRequestedEditorMaterials = false;
m_bCanUseEditorMaterials = false;
m_StandardTexturesAllocated = false;
m_bInFrame = false;
m_bThreadHasOwnership = false;
m_ThreadOwnershipID = 0;
m_pShaderDLL = NULL;
m_FullbrightLightmapTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_FullbrightBumpedLightmapTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_BlackTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_FlatNormalTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_GreyTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_GreyAlphaZeroTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_WhiteTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_LinearToGammaTableTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_LinearToGammaIdentityTableTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_MaxDepthTextureHandle = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_bInStubMode = false;
m_pForcedTextureLoadPathID = NULL;
m_bAllocatingRenderTargets = false;
m_pRenderContext.Set( &m_HardwareRenderContext );
m_iCurQueuedContext = 0;
#if defined(DEDICATED)
m_bThreadingNotAvailable = true;
m_bForcedSingleThreaded = true;
m_bAllowQueuedRendering = false;
#else
m_bThreadingNotAvailable = false;
m_bForcedSingleThreaded = false;
m_bAllowQueuedRendering = true;
#endif
m_bGeneratedConfig = false;
m_pActiveAsyncJob = NULL;
m_pMatQueueThreadPool = NULL;
m_IdealThreadMode = m_ThreadMode = MATERIAL_SINGLE_THREADED;
m_nServiceThread = 0;
m_nRenderTargetFrameBufferHeightOverride = m_nRenderTargetFrameBufferWidthOverride = 0;
m_bReplacementFilesValid = false;
}
CMaterialSystem::~CMaterialSystem()
{
if (m_pShaderDLL)
{
delete[] m_pShaderDLL;
}
}
//-----------------------------------------------------------------------------
// Creates/destroys the shader implementation for the selected API
//-----------------------------------------------------------------------------
CreateInterfaceFn CMaterialSystem::CreateShaderAPI( char const* pShaderDLL )
{
if ( !pShaderDLL )
return 0;
// Clean up the old shader
DestroyShaderAPI();
// Load the new shader
m_ShaderHInst = Sys_LoadModule( pShaderDLL );
// Error loading the shader
if ( !m_ShaderHInst )
return 0;
// Get our class factory methods...
return Sys_GetFactory( m_ShaderHInst );
}
void CMaterialSystem::DestroyShaderAPI()
{
if (m_ShaderHInst)
{
// NOTE: By unloading the library, this will destroy m_pShaderAPI
Sys_UnloadModule( m_ShaderHInst );
g_pShaderAPI = 0;
g_pHWConfig = 0;
g_pShaderShadow = 0;
m_ShaderHInst = 0;
}
}
//-----------------------------------------------------------------------------
// Sets which shader we should be using. Has to be done before connect!
//-----------------------------------------------------------------------------
void CMaterialSystem::SetShaderAPI( char const *pShaderAPIDLL )
{
if ( m_ShaderAPIFactory )
{
Error( "Cannot set the shader API twice!\n" );
}
if ( !pShaderAPIDLL )
{
pShaderAPIDLL = "shaderapidx9";
}
// m_pShaderDLL is needed to spew driver info
Assert( pShaderAPIDLL );
int len = Q_strlen( pShaderAPIDLL ) + 1;
m_pShaderDLL = new char[len];
memcpy( m_pShaderDLL, pShaderAPIDLL, len );
m_ShaderAPIFactory = CreateShaderAPI( pShaderAPIDLL );
if ( !m_ShaderAPIFactory )
{
DestroyShaderAPI();
}
}
//-----------------------------------------------------------------------------
// Connect/disconnect
//-----------------------------------------------------------------------------
bool CMaterialSystem::Connect( CreateInterfaceFn factory )
{
// __stop__();
if ( !factory )
return false;
if ( !BaseClass::Connect( factory ) )
return false;
if ( !g_pFullFileSystem )
{
Warning( "The material system requires the filesystem to run!\n" );
return false;
}
// Get at the interfaces exported by the shader DLL
g_pShaderDeviceMgr = (IShaderDeviceMgr*)m_ShaderAPIFactory( SHADER_DEVICE_MGR_INTERFACE_VERSION, 0 );
if ( !g_pShaderDeviceMgr )
return false;
g_pHWConfig = (IHardwareConfigInternal*)m_ShaderAPIFactory( MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION, 0 );
if ( !g_pHWConfig )
return false;
#if !defined(DEDICATED)
#if defined( USE_SDL )
g_pLauncherMgr = (ILauncherMgr *)factory( "SDLMgrInterface001" /*SDL_MGR_INTERFACE_VERSION*/, NULL );
if ( !g_pLauncherMgr )
{
return false;
}
#endif // USE_SDL
#endif // !DEDICATED
// FIXME: ShaderAPI, ShaderDevice, and ShaderShadow should only come in after setting mode
g_pShaderAPI = (IShaderAPI*)m_ShaderAPIFactory( SHADERAPI_INTERFACE_VERSION, 0 );
if ( !g_pShaderAPI )
return false;
g_pShaderDevice = (IShaderDevice*)m_ShaderAPIFactory( SHADER_DEVICE_INTERFACE_VERSION, 0 );
if ( !g_pShaderDevice )
return false;
g_pShaderShadow = (IShaderShadow*)m_ShaderAPIFactory( SHADERSHADOW_INTERFACE_VERSION, 0 );
if ( !g_pShaderShadow )
return false;
// Remember the factory for connect
g_fnMatSystemConnectCreateInterface = factory;
return g_pShaderDeviceMgr->Connect( ShaderFactory );
}
void CMaterialSystem::Disconnect()
{
// Forget the factory for connect
g_fnMatSystemConnectCreateInterface = NULL;
if ( g_pShaderDeviceMgr )
{
g_pShaderDeviceMgr->Disconnect();
g_pShaderDeviceMgr = NULL;
// Unload the DLL
DestroyShaderAPI();
}
g_pShaderAPI = NULL;
g_pHWConfig = NULL;
g_pShaderShadow = NULL;
g_pShaderDevice = NULL;
BaseClass::Disconnect();
}
//-----------------------------------------------------------------------------
// Used to enable editor materials. Must be called before Init.
//-----------------------------------------------------------------------------
void CMaterialSystem::EnableEditorMaterials()
{
m_bRequestedEditorMaterials = true;
}
//-----------------------------------------------------------------------------
// Method to get at interfaces supported by the SHADDERAPI
//-----------------------------------------------------------------------------
void *CMaterialSystem::QueryShaderAPI( const char *pInterfaceName )
{
// Returns various interfaces supported by the shader API dll
void *pInterface = NULL;
if (m_ShaderAPIFactory)
{
pInterface = m_ShaderAPIFactory( pInterfaceName, NULL );
}
return pInterface;
}
//-----------------------------------------------------------------------------
// Method to get at different interfaces supported by the material system
//-----------------------------------------------------------------------------
void *CMaterialSystem::QueryInterface( const char *pInterfaceName )
{
// Returns various interfaces supported by the shader API dll
void *pInterface = QueryShaderAPI( pInterfaceName );
if ( pInterface )
return pInterface;
CreateInterfaceFn factory = Sys_GetFactoryThis(); // This silly construction is necessary
return factory( pInterfaceName, NULL ); // to prevent the LTCG compiler from crashing.
}
//-----------------------------------------------------------------------------
// Must be called before Init(), if you're going to call it at all...
//-----------------------------------------------------------------------------
void CMaterialSystem::SetAdapter( int nAdapter, int nAdapterFlags )
{
m_nAdapter = nAdapter;
m_nAdapterFlags = nAdapterFlags;
}
//-----------------------------------------------------------------------------
// Initializes the color correction terms
//-----------------------------------------------------------------------------
void CMaterialSystem::InitColorCorrection( )
{
if ( ColorCorrectionSystem() )
{
ColorCorrectionSystem()->Init();
}
}
//-----------------------------------------------------------------------------
// Initialization + shutdown of the material system
//-----------------------------------------------------------------------------
InitReturnVal_t CMaterialSystem::Init()
{
InitReturnVal_t nRetVal = BaseClass::Init();
if ( nRetVal != INIT_OK )
return nRetVal;
// NOTE! : Overbright is 1.0 so that Hammer will work properly with the white bumped and unbumped lightmaps.
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
g_pShaderDeviceMgr->SetAdapter( m_nAdapter, m_nAdapterFlags );
if ( g_pShaderDeviceMgr->Init( ) != INIT_OK )
{
DestroyShaderAPI();
return INIT_FAILED;
}
// Texture manager...
TextureManager()->Init( m_nAdapterFlags );
// Shader system!
ShaderSystem()->Init();
#if defined( WIN32 ) && !defined( _X360 )
// HACKHACK: <sigh> This horrible hack is possibly the only way to reliably detect an old
// version of hammer initializing the material system. We need to know this so that we set
// up the editor materials properly. If we don't do this, we never allocate the white lightmap,
// for example. We can remove this when we update the SDK!!
char szExeName[_MAX_PATH];
if ( ::GetModuleFileName( ( HINSTANCE )GetModuleHandle( NULL ), szExeName, sizeof( szExeName ) ) )
{
char szRight[20];
Q_StrRight( szExeName, 11, szRight, sizeof( szRight ) );
if ( !Q_stricmp( szRight, "\\hammer.exe" ) )
{
m_bRequestedEditorMaterials = true;
}
}
#endif // WIN32
m_bCanUseEditorMaterials = m_bRequestedEditorMaterials;
InitColorCorrection();
// Set up debug materials...
CreateDebugMaterials();
#if !defined(DEDICATED)
CreateCompositorMaterials();
#endif
if ( IsX360() )
{
g_pQueuedLoader->InstallLoader( RESOURCEPRELOAD_MATERIAL, &s_ResourcePreloadMaterial );
g_pQueuedLoader->InstallLoader( RESOURCEPRELOAD_CUBEMAP, &s_ResourcePreloadCubemap );
}
// Set up a default material system config
// GenerateConfigFromConfigKeyValues( &g_config, false );
// UpdateConfig( false );
// JAY: Added this command line parameter to force creating <32x32 mips
// to test for reported performance regressions on some systems
if ( CommandLine()->FindParm("-forceallmips") )
{
extern bool g_bForceTextureAllMips;
g_bForceTextureAllMips = true;
}
#if defined(DEDICATED)
m_bThreadingNotAvailable = true;
#else
for ( int i = 0; i < ARRAYSIZE( m_QueuedRenderContexts ); i++ )
{
if ( !m_QueuedRenderContexts[i].IsInitialized() )
{
if ( !m_QueuedRenderContexts[i].Init( this, &m_HardwareRenderContext ) )
{
m_bThreadingNotAvailable = true;
break;
}
}
}
#endif
return m_HardwareRenderContext.Init( this );
}
//-----------------------------------------------------------------------------
// For backwards compatability
//-----------------------------------------------------------------------------
static CreateInterfaceFn s_TempCVarFactory;
static CreateInterfaceFn s_TempFileSystemFactory;
void* TempCreateInterface( const char *pName, int *pReturnCode )
{
void *pRetVal = NULL;
if ( s_TempCVarFactory )
{
pRetVal = s_TempCVarFactory( pName, pReturnCode );
if (pRetVal)
return pRetVal;
}
pRetVal = s_TempFileSystemFactory( pName, pReturnCode );
if (pRetVal)
return pRetVal;
return NULL;
}
//-----------------------------------------------------------------------------
// Initializes and shuts down the shader API
//-----------------------------------------------------------------------------
CreateInterfaceFn CMaterialSystem::Init( char const* pShaderAPIDLL,
IMaterialProxyFactory *pMaterialProxyFactory,
CreateInterfaceFn fileSystemFactory,
CreateInterfaceFn cvarFactory )
{
SetShaderAPI( pShaderAPIDLL );
s_TempCVarFactory = cvarFactory;
s_TempFileSystemFactory = fileSystemFactory;
if ( !Connect( TempCreateInterface ) )
return 0;
if (Init() != INIT_OK)
return NULL;
// save the proxy factory
m_pMaterialProxyFactory = pMaterialProxyFactory;
return m_ShaderAPIFactory;
}
void CMaterialSystem::Shutdown( )
{
DestroyMatQueueThreadPool();
m_HardwareRenderContext.Shutdown();
// Clean up standard textures
ReleaseStandardTextures();
CleanUpCompositorMaterials();
// Clean up the debug materials
CleanUpDebugMaterials();
g_pMorphMgr->FreeMaterials();
g_pOcclusionQueryMgr->FreeOcclusionQueryObjects();
GetLightmaps()->Shutdown();
m_MaterialDict.Shutdown();
CleanUpErrorMaterial();
// Shader system!
ShaderSystem()->Shutdown();
// Texture manager...
TextureManager()->Shutdown();
if (g_pShaderDeviceMgr)
{
g_pShaderDeviceMgr->Shutdown();
}
BaseClass::Shutdown();
}
void CMaterialSystem::ModInit()
{
// Set up a default material system config
GenerateConfigFromConfigKeyValues( &g_config, false );
UpdateConfig( false );
// Shader system!
ShaderSystem()->ModInit();
}
void CMaterialSystem::ModShutdown()
{
// Shader system!
ShaderSystem()->ModShutdown();
// HACK - this is here to unhook ourselves from the client interface, since we're not actually notified when it happens
m_pMaterialProxyFactory = NULL;
}
//-----------------------------------------------------------------------------
// Returns the current adapter in use
//-----------------------------------------------------------------------------
IMaterialSystemHardwareConfig *CMaterialSystem::GetHardwareConfig( const char *pVersion, int *returnCode )
{
return ( IMaterialSystemHardwareConfig * )m_ShaderAPIFactory( pVersion, returnCode );
}
//-----------------------------------------------------------------------------
// Returns the current adapter in use
//-----------------------------------------------------------------------------
int CMaterialSystem::GetCurrentAdapter() const
{
return g_pShaderDevice->GetCurrentAdapter();
}
//-----------------------------------------------------------------------------
// Returns the device name for the current adapter
//-----------------------------------------------------------------------------
char *CMaterialSystem::GetDisplayDeviceName() const
{
return g_pShaderDevice->GetDisplayDeviceName();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CMaterialSystem::SetThreadMode( MaterialThreadMode_t nextThreadMode, int nServiceThread )
{
m_IdealThreadMode = nextThreadMode;
m_nServiceThread = nServiceThread;
}
MaterialThreadMode_t CMaterialSystem::GetThreadMode()
{
return m_ThreadMode;
}
bool CMaterialSystem::IsRenderThreadSafe( )
{
return ( m_ThreadMode != MATERIAL_QUEUED_THREADED && ThreadInMainThread() ) ||
( m_ThreadMode == MATERIAL_QUEUED_THREADED && m_nRenderThreadID == ThreadGetCurrentId() );
}
bool CMaterialSystem::AllowThreading( bool bAllow, int nServiceThread )
{
#if defined(DEDICATED)
return false;
#else
if ( CommandLine()->ParmValue( "-threads", 2 ) < 2 ) // if -threads specified on command line to restrict all the pools then obey and not turn on QMS
bAllow = false;
bool bOldAllow = m_bAllowQueuedRendering;
if ( GetCPUInformation()->m_nPhysicalProcessors >= 2 )
{
m_bAllowQueuedRendering = bAllow;
bool bQueued = m_IdealThreadMode != MATERIAL_SINGLE_THREADED;
if ( bAllow && !bQueued )
{
// go into queued mode
DevMsg( "Queued Material System: ENABLED!\n" );
SetThreadMode( MATERIAL_QUEUED_THREADED, nServiceThread );
}
else if ( !bAllow && bQueued )
{
// disabling queued mode just needs to stop the queuing of drawing
// but still allow other threaded access to the Material System
// flush the queue
DevMsg( "Queued Material System: DISABLED!\n" );
ForceSingleThreaded();
MaterialLock_t hMaterialLock = Lock();
SetThreadMode( MATERIAL_SINGLE_THREADED, -1 );
Unlock( hMaterialLock );
}
}
else
{
m_bAllowQueuedRendering = false;
}
return bOldAllow;
#endif // !DEDICATED
}
void CMaterialSystem::ExecuteQueued()
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
IMatRenderContext *CMaterialSystem::GetRenderContext()
{
IMatRenderContext *pResult = m_pRenderContext.Get();
if ( !pResult )
{
pResult = &m_HardwareRenderContext;
m_pRenderContext.Set( &m_HardwareRenderContext );
}
return RetAddRef( pResult );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
IMatRenderContext *CMaterialSystem::CreateRenderContext( MaterialContextType_t type )
{
switch ( type )
{
case MATERIAL_HARDWARE_CONTEXT:
return NULL;
case MATERIAL_QUEUED_CONTEXT:
{
CMatQueuedRenderContext *pQueuedContext = new CMatQueuedRenderContext;
pQueuedContext->Init( this, &m_HardwareRenderContext );
pQueuedContext->BeginQueue( &m_HardwareRenderContext );
return pQueuedContext;
}
case MATERIAL_NULL_CONTEXT:
{
CMatRenderContextBase *pNullContext = CreateNullRenderContext();
pNullContext->Init();
pNullContext->InitializeFrom( &m_HardwareRenderContext );
return pNullContext;
}
}
Assert(0);
return NULL;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
IMatRenderContext *CMaterialSystem::SetRenderContext( IMatRenderContext *pNewContext )
{
IMatRenderContext *pOldContext = m_pRenderContext.Get();
if ( pNewContext )
{
pNewContext->AddRef();
m_pRenderContext.Set( assert_cast<IMatRenderContextInternal *>(pNewContext) );
}
else
{
m_pRenderContext.Set( NULL );
}
return pOldContext;
}
//-----------------------------------------------------------------------------
// Get/Set Material proxy factory
//-----------------------------------------------------------------------------
IMaterialProxyFactory* CMaterialSystem::GetMaterialProxyFactory()
{
return m_pMaterialProxyFactory;
}
void CMaterialSystem::SetMaterialProxyFactory( IMaterialProxyFactory* pFactory )
{
// Changing the factory requires an uncaching of all materials
// since the factory may contain different proxies
UncacheAllMaterials();
m_pMaterialProxyFactory = pFactory;
}
//-----------------------------------------------------------------------------
// Can we use editor materials?
//-----------------------------------------------------------------------------
bool CMaterialSystem::CanUseEditorMaterials() const
{
return m_bCanUseEditorMaterials;
}
//-----------------------------------------------------------------------------
// Methods related to mode setting...
//-----------------------------------------------------------------------------
// Gets the number of adapters...
int CMaterialSystem::GetDisplayAdapterCount() const
{
return g_pShaderDeviceMgr->GetAdapterCount( );
}
// Returns info about each adapter
void CMaterialSystem::GetDisplayAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const
{
g_pShaderDeviceMgr->GetAdapterInfo( adapter, info );
}
// Returns the number of modes
int CMaterialSystem::GetModeCount( int adapter ) const
{
return g_pShaderDeviceMgr->GetModeCount( adapter );
}
//-----------------------------------------------------------------------------
// Compatability function, should go away eventually
//-----------------------------------------------------------------------------
static void ConvertModeStruct( ShaderDeviceInfo_t *pMode, const MaterialSystem_Config_t &config )
{
pMode->m_DisplayMode.m_nWidth = config.m_VideoMode.m_Width;
pMode->m_DisplayMode.m_nHeight = config.m_VideoMode.m_Height;
pMode->m_DisplayMode.m_Format = config.m_VideoMode.m_Format;
pMode->m_DisplayMode.m_nRefreshRateNumerator = config.m_VideoMode.m_RefreshRate;
pMode->m_DisplayMode.m_nRefreshRateDenominator = config.m_VideoMode.m_RefreshRate ? 1 : 0;
pMode->m_nBackBufferCount = 1;
pMode->m_nAASamples = config.m_nAASamples;
pMode->m_nAAQuality = config.m_nAAQuality;
pMode->m_nDXLevel = MAX( ABSOLUTE_MINIMUM_DXLEVEL, config.dxSupportLevel );
pMode->m_nWindowedSizeLimitWidth = (int)config.m_WindowedSizeLimitWidth;
pMode->m_nWindowedSizeLimitHeight = (int)config.m_WindowedSizeLimitHeight;
pMode->m_bWindowed = config.Windowed();
pMode->m_bResizing = config.Resizing();
pMode->m_bUseStencil = config.Stencil();
pMode->m_bLimitWindowedSize = config.LimitWindowedSize();
pMode->m_bWaitForVSync = config.WaitForVSync();
pMode->m_bScaleToOutputResolution = config.ScaleToOutputResolution();
pMode->m_bUsingMultipleWindows = config.UsingMultipleWindows();
}
static void ConvertModeStruct( MaterialVideoMode_t *pMode, const ShaderDisplayMode_t &info )
{
pMode->m_Width = info.m_nWidth;
pMode->m_Height = info.m_nHeight;
pMode->m_Format = info.m_Format;
pMode->m_RefreshRate = info.m_nRefreshRateDenominator ? ( info.m_nRefreshRateNumerator / info.m_nRefreshRateDenominator ) : 0;
}
//-----------------------------------------------------------------------------
// Returns mode information..
//-----------------------------------------------------------------------------
void CMaterialSystem::GetModeInfo( int nAdapter, int nMode, MaterialVideoMode_t& info ) const
{
ShaderDisplayMode_t shaderInfo;
g_pShaderDeviceMgr->GetModeInfo( &shaderInfo, nAdapter, nMode );
ConvertModeStruct( &info, shaderInfo );
}
//-----------------------------------------------------------------------------
// Returns the mode info for the current display device
//-----------------------------------------------------------------------------
void CMaterialSystem::GetDisplayMode( MaterialVideoMode_t& info ) const
{
ShaderDisplayMode_t shaderInfo;
g_pShaderDeviceMgr->GetCurrentModeInfo( &shaderInfo, m_nAdapter );
ConvertModeStruct( &info, shaderInfo );
}
void CMaterialSystem::ForceSingleThreaded()
{
if ( !ThreadInMainThread() )
{
Error("Can't force single thread from within thread!\n");
}
if ( GetThreadMode() != MATERIAL_SINGLE_THREADED )
{
if ( m_pActiveAsyncJob && !m_pActiveAsyncJob->IsFinished() )
{
m_pActiveAsyncJob->WaitForFinish();
}
SafeRelease( m_pActiveAsyncJob );
ThreadRelease();
g_pShaderAPI->EnableShaderShaderMutex( false );
m_HardwareRenderContext.InitializeFrom(&m_QueuedRenderContexts[m_iCurQueuedContext]);
m_pRenderContext.Set( &m_HardwareRenderContext );
for ( int i = 0; i < ARRAYSIZE( m_QueuedRenderContexts ); i++ )
{
Assert( m_QueuedRenderContexts[i].IsInitialized() );
m_QueuedRenderContexts[i].EndQueue(true);
}
if( mat_debugalttab.GetBool() )
{
Warning("Forcing queued mode off!\n");
}
// NOTE: Must happen after EndQueue or proxies get bound again, which is bad.
m_ThreadMode = MATERIAL_SINGLE_THREADED;
m_bForcedSingleThreaded = true;
}
}
//-----------------------------------------------------------------------------
// Sets the mode...
//-----------------------------------------------------------------------------
bool CMaterialSystem::SetMode( void* hwnd, const MaterialSystem_Config_t &config )
{
Assert( m_bGeneratedConfig );
ForceSingleThreaded();
ShaderDeviceInfo_t info;
ConvertModeStruct( &info, config );
bool bPreviouslyUsingGraphics = g_pShaderDevice->IsUsingGraphics();
if( config.m_nVRModeAdapter != -1 && config.m_nVRModeAdapter < GetDisplayAdapterCount() && !bPreviouslyUsingGraphics )
{
// if this is init-time, we need to override the adapter with the
// VR mode adapter
m_nAdapter = config.m_nVRModeAdapter;
}
bool bOk = g_pShaderAPI->SetMode( hwnd, m_nAdapter, info );
if ( !bOk )
return false;
#if defined( USE_SDL )
uint width = info.m_DisplayMode.m_nWidth;
uint height = info.m_DisplayMode.m_nHeight;
g_pLauncherMgr->RenderedSize( width, height, true ); // true = set
#endif
TextureManager()->FreeStandardRenderTargets();
TextureManager()->AllocateStandardRenderTargets();
// FIXME: There's gotta be a better way of doing this?
// After the first mode set, make sure to download any textures created
// before the first mode set. After the first mode set, all textures
// will be reloaded via the reaquireresources call. Same goes for procedural materials
if ( !bPreviouslyUsingGraphics )
{
if ( IsPC() )
{
TextureManager()->RestoreRenderTargets();
TextureManager()->RestoreNonRenderTargetTextures();
if ( MaterialSystem()->CanUseEditorMaterials() )
{
// We are in Hammer. Allocate these here since we aren't going to allocate
// lightmaps.
// HACK!
// NOTE! : Overbright is 1.0 so that Hammer will work properly with the white bumped and unbumped lightmaps.
MathLib_Init( 2.2f, 2.2f, 0.0f, OVERBRIGHT );
}
AllocateStandardTextures();
TextureManager()->WarmTextureCache();
}
if ( IsX360() )
{
// shaderapi was not viable at init time, it is now
TextureManager()->ReloadTextures();
AllocateStandardTextures();
}
}
g_pShaderDevice->SetHardwareGammaRamp( config.m_fMonitorGamma, config.m_fGammaTVRangeMin, config.m_fGammaTVRangeMax,
config.m_fGammaTVExponent, config.m_bGammaTVEnabled );
// Copy over that state which isn't stored currently in convars
g_config.m_VideoMode = config.m_VideoMode;
g_config.SetFlag( MATSYS_VIDCFG_FLAGS_WINDOWED, config.Windowed() );
g_config.SetFlag( MATSYS_VIDCFG_FLAGS_STENCIL, config.Stencil() );
g_config.SetFlag( MATSYS_VIDCFG_FLAGS_VR_MODE, config.VRMode() );
WriteConfigIntoConVars( config );
extern void SetupDirtyDiskReportFunc();
SetupDirtyDiskReportFunc();
return true;
}
// Creates/ destroys a child window
bool CMaterialSystem::AddView( void* hwnd )
{
return g_pShaderDevice->AddView( hwnd );
}
void CMaterialSystem::RemoveView( void* hwnd )
{
g_pShaderDevice->RemoveView( hwnd );
}
// Activates a view
void CMaterialSystem::SetView( void* hwnd )
{
g_pShaderDevice->SetView( hwnd );
}
//-----------------------------------------------------------------------------
// Installs a function to be called when we need to release vertex buffers
//-----------------------------------------------------------------------------
void CMaterialSystem::AddReleaseFunc( MaterialBufferReleaseFunc_t func )
{
// Shouldn't have two copies in our list
Assert( m_ReleaseFunc.Find( func ) == -1 );
m_ReleaseFunc.AddToTail( func );
}
void CMaterialSystem::RemoveReleaseFunc( MaterialBufferReleaseFunc_t func )
{
int i = m_ReleaseFunc.Find( func );
if( i != -1 )
m_ReleaseFunc.Remove(i);
}
//-----------------------------------------------------------------------------
// Installs a function to be called when we need to restore vertex buffers
//-----------------------------------------------------------------------------
void CMaterialSystem::AddRestoreFunc( MaterialBufferRestoreFunc_t func )
{
// Shouldn't have two copies in our list
Assert( m_RestoreFunc.Find( func ) == -1 );
m_RestoreFunc.AddToTail( func );
}
void CMaterialSystem::RemoveRestoreFunc( MaterialBufferRestoreFunc_t func )
{
int i = m_RestoreFunc.Find( func );
Assert( i != -1 );
m_RestoreFunc.Remove(i);
}
//-----------------------------------------------------------------------------
// Called by the shader API when it's just about to lose video memory
//-----------------------------------------------------------------------------
void CMaterialSystem::ReleaseShaderObjects()
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: CMaterialSystem::ReleaseShaderObjects\n" );
}
m_HardwareRenderContext.OnReleaseShaderObjects();
g_pOcclusionQueryMgr->FreeOcclusionQueryObjects();
TextureManager()->ReleaseTextures();
ReleaseStandardTextures();
GetLightmaps()->ReleaseLightmapPages();
for (int i = 0; i < m_ReleaseFunc.Count(); ++i)
{
m_ReleaseFunc[i]();
}
}
void CMaterialSystem::RestoreShaderObjects( CreateInterfaceFn shaderFactory, int nChangeFlags )
{
if ( shaderFactory )
{
g_pShaderAPI = (IShaderAPI*)shaderFactory( SHADERAPI_INTERFACE_VERSION, NULL );
g_pShaderDevice = (IShaderDevice*)shaderFactory( SHADER_DEVICE_INTERFACE_VERSION, NULL );
g_pShaderShadow = (IShaderShadow*)shaderFactory( SHADERSHADOW_INTERFACE_VERSION, NULL );
}
for( MaterialHandle_t i = m_MaterialDict.FirstMaterial(); i != m_MaterialDict.InvalidMaterial(); i = m_MaterialDict.NextMaterial( i ) )
{
IMaterialInternal *pMat = m_MaterialDict.GetMaterialInternal( i );
if ( pMat )
pMat->ReportVarChanged( NULL );
}
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: CMaterialSystem::RestoreShaderObjects\n" );
}
// Shader API sets this to the max value the card supports when it resets
// the state, so restore this value.
g_pShaderAPI->SetAnisotropicLevel( GetCurrentConfigForVideoCard().m_nForceAnisotropicLevel );
// NOTE: render targets must be restored first, then vb/ibs, then managed textures
// FIXME: Gotta restore lightmap pages + standard textures before restore funcs are called
// because they use them both.
TextureManager()->RestoreRenderTargets();
AllocateStandardTextures();
GetLightmaps()->RestoreLightmapPages();
g_pOcclusionQueryMgr->AllocOcclusionQueryObjects();
for (int i = 0; i < m_RestoreFunc.Count(); ++i)
{
m_RestoreFunc[i]( nChangeFlags );
}
TextureManager()->RestoreNonRenderTargetTextures( );
}
//-----------------------------------------------------------------------------
// Use this to spew information about the 3D layer
//-----------------------------------------------------------------------------
void CMaterialSystem::SpewDriverInfo() const
{
Warning( "ShaderAPI: %s\n", m_pShaderDLL );
g_pShaderDevice->SpewDriverInfo();
}
//-----------------------------------------------------------------------------
// Color converting blitter
//-----------------------------------------------------------------------------
bool CMaterialSystem::ConvertImageFormat( unsigned char *src, enum ImageFormat srcImageFormat,
unsigned char *dst, enum ImageFormat dstImageFormat,
int width, int height, int srcStride, int dstStride )
{
return ImageLoader::ConvertImageFormat( src, srcImageFormat,
dst, dstImageFormat, width, height, srcStride, dstStride );
}
//-----------------------------------------------------------------------------
// Figures out the amount of memory needed by a bitmap
//-----------------------------------------------------------------------------
int CMaterialSystem::GetMemRequired( int width, int height, int depth, ImageFormat format, bool mipmap )
{
return ImageLoader::GetMemRequired( width, height, depth, format, mipmap );
}
//-----------------------------------------------------------------------------
// Method to allow clients access to the MaterialSystem_Config
//-----------------------------------------------------------------------------
MaterialSystem_Config_t& CMaterialSystem::GetConfig()
{
//hushed Assert( m_bGeneratedConfig );
return g_config;
}
//-----------------------------------------------------------------------------
// Gets image format info
//-----------------------------------------------------------------------------
ImageFormatInfo_t const& CMaterialSystem::ImageFormatInfo( ImageFormat fmt) const
{
return ImageLoader::ImageFormatInfo(fmt);
}
//-----------------------------------------------------------------------------
// Reads keyvalues for information
//-----------------------------------------------------------------------------
static void ReadInt( KeyValues *pGroup, const char *pName, int nDefaultVal, int nUndefinedVal, int *pDest )
{
*pDest = pGroup->GetInt( pName, nDefaultVal );
// Warning( "\t%s = %d\n", pName, *pDest );
Assert( *pDest != nUndefinedVal );
}
static void ReadFlt( KeyValues *pGroup, const char *pName, float flDefaultVal, float flUndefinedVal, float *pDest )
{
*pDest = pGroup->GetFloat( pName, flDefaultVal );
// Warning( "\t%s = %f\n", pName, *pDest );
Assert( *pDest != flUndefinedVal );
}
static void LoadFlags( KeyValues *pGroup, const char *pName, bool bDefaultValue, unsigned int nFlag, unsigned int *pFlags )
{
int nValue = pGroup->GetInt( pName, bDefaultValue ? 1 : 0 );
// Warning( "\t%s = %s\n", pName, nValue ? "true" : "false" );
if ( nValue )
{
*pFlags |= nFlag;
}
}
#define ASPECT_4x3 0
#define ASPECT_16x9 1
#define ASPECT_16x10 2
//-----------------------------------------------------------------------------
// Purpose: aspect ratio mappings (for normal/widescreen combo)
//-----------------------------------------------------------------------------
struct RatioToAspectMode_t
{
int nAspectCode;
float flAspectRatio;
};
RatioToAspectMode_t g_RatioToAspectModes[] =
{
{ ASPECT_4x3, 4.0f / 3.0f },
{ ASPECT_16x9, 16.0f / 9.0f },
{ ASPECT_16x10, 16.0f / 10.0f },
{ ASPECT_16x10, 1.0f },
};
//-----------------------------------------------------------------------------
// Purpose: returns the aspect ratio mode number for the given resolution
//-----------------------------------------------------------------------------
int GetScreenAspectMode( int width, int height )
{
float flAspectRatio = (float)width / (float)height;
// Just find the closest ratio
float flClosestAspectRatioDist = 99999.0f;
int nClosestAspectCode = ASPECT_4x3;
for ( int i = 0; i < ARRAYSIZE(g_RatioToAspectModes); i++ )
{
float flDist = fabs( g_RatioToAspectModes[i].flAspectRatio - flAspectRatio );
if ( flDist < flClosestAspectRatioDist )
{
flClosestAspectRatioDist = flDist;
nClosestAspectCode = g_RatioToAspectModes[i].nAspectCode;
}
}
return nClosestAspectCode;
}
// Heuristic similar to one we put into L4D
bool BetterResolution( int nRecommendedNumPixels, int nBestNumPixels, int nNewNumPixels )
{
float flRecommendedNumPixels = (float) nRecommendedNumPixels;
float flBestNumPixels = (float) nBestNumPixels;
float flNewNumPixels = (float) nNewNumPixels;
// Give ourselves a little head room
float flTooBig = flRecommendedNumPixels * 1.1f;
// If our best is too big and the new resolution is no bigger, pick it
if ( ( flBestNumPixels > flTooBig ) && ( flNewNumPixels < flBestNumPixels ) )
return true;
// Don't allow resolutions which are too big
if ( flNewNumPixels > flTooBig )
return false;
// Finally, just check for nearness to desired number of pixels
float flDelta = fabs( flRecommendedNumPixels - flNewNumPixels );
float flBestDelta = fabs( flRecommendedNumPixels - flBestNumPixels );
if ( flDelta >= flBestDelta )
return false;
return true;
}
//-----------------------------------------------------------------------------
// This is called when the config changes
//-----------------------------------------------------------------------------
void CMaterialSystem::GenerateConfigFromConfigKeyValues( MaterialSystem_Config_t *pConfig, bool bOverwriteCommandLineValues )
{
if ( !g_pShaderDeviceMgr || !pConfig )
return;
// Look for the default recommended dx support level
MaterialAdapterInfo_t adapterInfo;
g_pShaderDeviceMgr->GetAdapterInfo( m_nAdapter, adapterInfo );
pConfig->dxSupportLevel = MAX( ABSOLUTE_MINIMUM_DXLEVEL, adapterInfo.m_nDXSupportLevel );
KeyValues *pKeyValues = new KeyValues( "config" );
if ( !GetRecommendedConfigurationInfo( pConfig->dxSupportLevel, pKeyValues ) )
{
pKeyValues->deleteThis();
return;
}
pConfig->m_Flags = 0;
#ifdef LINUX
uint width = 0;
uint height = 0;
uint refreshHz = 0; // Not used
#ifdef USE_SDL
// query backbuffer size (window size whether FS or windowed)
if( g_pLauncherMgr )
{
g_pLauncherMgr->GetNativeDisplayInfo( -1, width, height, refreshHz );
}
#endif
pConfig->m_VideoMode.m_Width = width;
pConfig->m_VideoMode.m_Height = height;
#else
// Get the recommended resolution from dxsupport.cfg, this assumes a 4:3 aspect ratio
int nRecommendedWidth, nRecommendedHeight;
ReadInt( pKeyValues, "DefaultRes", 640, -1, &nRecommendedWidth );
nRecommendedHeight = ( nRecommendedWidth * 3 ) / 4;
int nRecommendedPixels = nRecommendedHeight * nRecommendedWidth;
// Get the desktop resolution and aspect ratio
ShaderDisplayMode_t displayMode;
g_pShaderDeviceMgr->GetCurrentModeInfo( &displayMode, 0 );
int nCurrentScreenAspect = GetScreenAspectMode( displayMode.m_nWidth, displayMode.m_nHeight );
// Let's see what the device supports and pick the most appropriate mode
g_pShaderDeviceMgr->GetModeInfo( &displayMode, 0, 0 );
int nBestMode, nBestWidth, nBestHeight;
nBestMode = nBestWidth = nBestHeight = -1;
int nBestPixels = displayMode.m_nHeight * displayMode.m_nWidth;
int nNumVideoModes = g_pShaderDeviceMgr->GetModeCount( 0 );
// Pick the resolution with the right aspect ratio which matches the recommended resolution most closely
for ( int i=0; i<nNumVideoModes; i++ )
{
g_pShaderDeviceMgr->GetModeInfo( &displayMode, 0, i );
if ( nCurrentScreenAspect == GetScreenAspectMode( displayMode.m_nWidth, displayMode.m_nHeight ) )
{
int nNumPixels = displayMode.m_nWidth * displayMode.m_nHeight;
// Initially select the first mode we find of the correct aspect ratio for the display
if ( ( nBestMode == -1) || BetterResolution( nRecommendedPixels, nBestPixels, nNumPixels ) )
{
nBestMode = i;
nBestPixels = nNumPixels;
nBestWidth = displayMode.m_nWidth;
nBestHeight = displayMode.m_nHeight;
}
}
}
// We found a good mode
if ( nBestMode != -1 )
{
pConfig->m_VideoMode.m_Width = nBestWidth;
pConfig->m_VideoMode.m_Height = nBestHeight;
}
else // Fall back to 4:3 mode from the cfg file. This should never happen
{
pConfig->m_VideoMode.m_Width = nRecommendedWidth;
pConfig->m_VideoMode.m_Height = nRecommendedHeight;
}
#if defined( _X360 )
pConfig->m_VideoMode.m_Width = GetSystemMetrics( SM_CXSCREEN );
pConfig->m_VideoMode.m_Height = GetSystemMetrics( SM_CYSCREEN );
#endif
pKeyValues->deleteThis();
#endif // LINUX
WriteConfigurationInfoToConVars( bOverwriteCommandLineValues );
m_bGeneratedConfig = true;
}
//-----------------------------------------------------------------------------
// If mat_proxy goes to 0, we need to reload all materials, because their shader
// params might have been messed with.
//-----------------------------------------------------------------------------
static void MatProxyCallback( IConVar *pConVar, const char *old, float flOldValue )
{
ConVarRef var( pConVar );
int oldVal = (int)flOldValue;
if ( var.GetInt() == 0 && oldVal != 0 )
{
g_MaterialSystem.ReloadMaterials();
}
}
//-----------------------------------------------------------------------------
// Convars that control the config record
//-----------------------------------------------------------------------------
static ConVar mat_vsync( "mat_vsync", "0", FCVAR_ALLOWED_IN_COMPETITIVE, "Force sync to vertical retrace", true, 0.0, true, 1.0 );
static ConVar mat_forcehardwaresync( "mat_forcehardwaresync", IsPC() ? "1" : "0", FCVAR_ALLOWED_IN_COMPETITIVE );
// Texture-related
static ConVar mat_trilinear( "mat_trilinear", "0", FCVAR_ALLOWED_IN_COMPETITIVE );
#ifdef _X360 // The code that reads this out of moddefaults.txt is #if'd out for the 360, so force aniso to 2 here.
static ConVar mat_forceaniso( "mat_forceaniso", "2", FCVAR_ARCHIVE ); // 0 = Bilinear, 1 = Trilinear, 2+ = Aniso
#elif defined ( OSX )
static ConVar mat_forceaniso( "mat_forceaniso", "1", FCVAR_ARCHIVE, "Filtering level", true, 0, true, 8 ); // 0 = Bilinear, 1 = Trilinear, 2+ = Aniso
#else
static ConVar mat_forceaniso( "mat_forceaniso", "1", FCVAR_ARCHIVE ); // 0 = Bilinear, 1 = Trilinear, 2+ = Aniso
#endif
static ConVar mat_filterlightmaps( "mat_filterlightmaps", "1" );
static ConVar mat_filtertextures( "mat_filtertextures", "1" );
static ConVar mat_mipmaptextures( "mat_mipmaptextures", "1" );
static ConVar mat_vrmode_adapter( "mat_vrmode_adapter", "-1" );
static void mat_showmiplevels_Callback_f( IConVar *var, const char *pOldValue, float flOldValue )
{
// turn off texture filtering if we are showing mip levels.
mat_filtertextures.SetValue( ( ( ConVar * )var )->GetInt() == 0 );
}
// Debugging textures
static ConVar mat_showmiplevels( "mat_showmiplevels", "0", FCVAR_CHEAT, "color-code miplevels 2: normalmaps, 1: everything else", mat_showmiplevels_Callback_f );
static ConVar mat_specular( "mat_specular", "1", FCVAR_ALLOWED_IN_COMPETITIVE, "Enable/Disable specularity for perf testing. Will cause a material reload upon change." );
static ConVar mat_bumpmap( "mat_bumpmap", "1", FCVAR_ALLOWED_IN_COMPETITIVE );
static ConVar mat_phong( "mat_phong", "1" );
static ConVar mat_parallaxmap( "mat_parallaxmap", "1", FCVAR_HIDDEN | FCVAR_ALLOWED_IN_COMPETITIVE );
static ConVar mat_reducefillrate( "mat_reducefillrate", "0", FCVAR_ALLOWED_IN_COMPETITIVE );
materialsystem: unlock mat_picmip cvar again
2022-08-03 21:30:27 +08:00
static ConVar mat_picmip( "mat_picmip", "0", FCVAR_ARCHIVE, "", true, -32, true, 8 );
1
2020-04-23 00:56:21 +08:00
static ConVar mat_slopescaledepthbias_normal( "mat_slopescaledepthbias_normal", "0.0f", FCVAR_CHEAT );
static ConVar mat_depthbias_normal( "mat_depthbias_normal", "0.0f", FCVAR_CHEAT | FCVAR_ALLOWED_IN_COMPETITIVE );
static ConVar mat_slopescaledepthbias_decal( "mat_slopescaledepthbias_decal", "-0.5", FCVAR_CHEAT ); // Reciprocals of these biases sent to API
static ConVar mat_depthbias_decal( "mat_depthbias_decal", "-262144", FCVAR_CHEAT | FCVAR_ALLOWED_IN_COMPETITIVE ); //
static ConVar mat_slopescaledepthbias_shadowmap( "mat_slopescaledepthbias_shadowmap", "16", FCVAR_CHEAT );
static ConVar mat_depthbias_shadowmap( "mat_depthbias_shadowmap", "0.0005", FCVAR_CHEAT );
static ConVar mat_monitorgamma( "mat_monitorgamma", "2.2", FCVAR_ARCHIVE, "monitor gamma (typically 2.2 for CRT and 1.7 for LCD)", true, 1.6f, true, 2.6f );
static ConVar mat_monitorgamma_tv_range_min( "mat_monitorgamma_tv_range_min", "16" );
static ConVar mat_monitorgamma_tv_range_max( "mat_monitorgamma_tv_range_max", "255" );
// TV's generally have a 2.5 gamma, so we need to convert our 2.2 frame buffer into a 2.5 frame buffer for display on a TV
static ConVar mat_monitorgamma_tv_exp( "mat_monitorgamma_tv_exp", "2.5", 0, "", true, 1.0f, true, 4.0f );
#ifdef _X360
static ConVar mat_monitorgamma_tv_enabled( "mat_monitorgamma_tv_enabled", "1", FCVAR_ARCHIVE, "" );
#else
static ConVar mat_monitorgamma_tv_enabled( "mat_monitorgamma_tv_enabled", "0", FCVAR_ARCHIVE, "" );
#endif
static ConVar mat_antialias( "mat_antialias", "0", FCVAR_ARCHIVE );
static ConVar mat_aaquality( "mat_aaquality", "0", FCVAR_ARCHIVE );
static ConVar mat_diffuse( "mat_diffuse", "1", FCVAR_CHEAT );
//=============================================================================
// HPE_BEGIN:
// [Forrest] Make this a cheat variable because low res textures makes enemy
// players and bullet impacts stand out more.
//=============================================================================
static ConVar mat_showlowresimage( "mat_showlowresimage", "0", FCVAR_CHEAT );
//=============================================================================
// HPE_END
//=============================================================================
static ConVar mat_fullbright( "mat_fullbright","0", FCVAR_CHEAT );
static ConVar mat_normalmaps( "mat_normalmaps", "0", FCVAR_CHEAT );
static ConVar mat_measurefillrate( "mat_measurefillrate", "0", FCVAR_CHEAT );
static ConVar mat_fillrate( "mat_fillrate", "0", FCVAR_CHEAT );
static ConVar mat_reversedepth( "mat_reversedepth", "0", FCVAR_CHEAT );
#ifdef DX_TO_GL_ABSTRACTION
static ConVar mat_bufferprimitives( "mat_bufferprimitives", "0" ); // I'm not seeing any benefit speed wise for buffered primitives on GLM/POSIX (checked via TF2 timedemo) - default to zero
#else
static ConVar mat_bufferprimitives( "mat_bufferprimitives", "1" );
#endif
static ConVar mat_drawflat( "mat_drawflat","0", FCVAR_CHEAT );
static ConVar mat_softwarelighting( "mat_softwarelighting", "0", FCVAR_ALLOWED_IN_COMPETITIVE );
static ConVar mat_proxy( "mat_proxy", "0", FCVAR_CHEAT, "", MatProxyCallback );
static ConVar mat_norendering( "mat_norendering", "0", FCVAR_CHEAT );
static ConVar mat_compressedtextures( "mat_compressedtextures", "1" );
static ConVar mat_fastspecular( "mat_fastspecular", "1", 0, "Enable/Disable specularity for visual testing. Will not reload materials and will not affect perf." );
static ConVar mat_fastnobump( "mat_fastnobump", "0", FCVAR_CHEAT ); // Binds 1-texel normal map for quick internal testing
// These are not controlled by the material system, but are limited by settings in the material system
static ConVar r_shadowrendertotexture( "r_shadowrendertotexture", "0", FCVAR_ARCHIVE );
static ConVar r_flashlightdepthtexture( "r_flashlightdepthtexture", "1" );
#ifndef _X360
static ConVar r_waterforceexpensive( "r_waterforceexpensive", "0", FCVAR_ARCHIVE );
#endif
static ConVar r_waterforcereflectentities( "r_waterforcereflectentities", "0", FCVAR_ALLOWED_IN_COMPETITIVE );
static ConVar mat_motion_blur_enabled( "mat_motion_blur_enabled", "0", FCVAR_ARCHIVE );
uint32 g_nDebugVarsSignature = 0;
//-----------------------------------------------------------------------------
// This is called when the config changes
//-----------------------------------------------------------------------------
void CMaterialSystem::ReadConfigFromConVars( MaterialSystem_Config_t *pConfig )
{
if ( !g_pCVar )
return;
// video panel config items
#ifndef CSS_PERF_TEST
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_NO_WAIT_FOR_VSYNC, !mat_vsync.GetBool() );
#endif
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_FORCE_TRILINEAR, mat_trilinear.GetBool() );
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_DISABLE_SPECULAR, !mat_specular.GetBool() );
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_DISABLE_BUMPMAP, !mat_bumpmap.GetBool() );
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_DISABLE_PHONG, !mat_phong.GetBool() );
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_ENABLE_PARALLAX_MAPPING, mat_parallaxmap.GetBool() );
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_REDUCE_FILLRATE, mat_reducefillrate.GetBool() );
pConfig->m_nForceAnisotropicLevel = max( mat_forceaniso.GetInt(), 1 );
pConfig->dxSupportLevel = MAX( ABSOLUTE_MINIMUM_DXLEVEL, mat_dxlevel.GetInt() );
pConfig->skipMipLevels = mat_picmip.GetInt();
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_FORCE_HWSYNC, mat_forcehardwaresync.GetBool() );
pConfig->m_SlopeScaleDepthBias_Decal = mat_slopescaledepthbias_decal.GetFloat();
pConfig->m_DepthBias_Decal = mat_depthbias_decal.GetFloat();
pConfig->m_SlopeScaleDepthBias_Normal = mat_slopescaledepthbias_normal.GetFloat();
pConfig->m_DepthBias_Normal = mat_depthbias_normal.GetFloat();
pConfig->m_SlopeScaleDepthBias_ShadowMap = mat_slopescaledepthbias_shadowmap.GetFloat();
pConfig->m_DepthBias_ShadowMap = mat_depthbias_shadowmap.GetFloat();
pConfig->m_fMonitorGamma = mat_monitorgamma.GetFloat();
pConfig->m_fGammaTVRangeMin = mat_monitorgamma_tv_range_min.GetFloat();
pConfig->m_fGammaTVRangeMax = mat_monitorgamma_tv_range_max.GetFloat();
pConfig->m_fGammaTVExponent = mat_monitorgamma_tv_exp.GetFloat();
pConfig->m_bGammaTVEnabled = mat_monitorgamma_tv_enabled.GetBool();
Update ToGLES( fix occlusion query and other small things )
2022-01-10 00:32:21 +08:00
#ifdef TOGLES
pConfig->m_nAASamples = 0;
#else
1
2020-04-23 00:56:21 +08:00
pConfig->m_nAASamples = mat_antialias.GetInt();
Update ToGLES( fix occlusion query and other small things )
2022-01-10 00:32:21 +08:00
#endif
1
2020-04-23 00:56:21 +08:00
pConfig->m_nAAQuality = mat_aaquality.GetInt();
pConfig->bShowDiffuse = mat_diffuse.GetInt() ? true : false;
// pConfig->bAllowCheats = false; // hack
pConfig->bShowNormalMap = mat_normalmaps.GetInt() ? true : false;
pConfig->bShowLowResImage = mat_showlowresimage.GetInt() ? true : false;
pConfig->bMeasureFillRate = mat_measurefillrate.GetInt() ? true : false;
pConfig->bVisualizeFillRate = mat_fillrate.GetInt() ? true : false;
pConfig->bFilterLightmaps = mat_filterlightmaps.GetInt() ? true : false;
pConfig->bFilterTextures = mat_filtertextures.GetInt() ? true : false;
pConfig->bMipMapTextures = mat_mipmaptextures.GetInt() ? true : false;
pConfig->nShowMipLevels = mat_showmiplevels.GetInt();
pConfig->bReverseDepth = mat_reversedepth.GetInt() ? true : false;
pConfig->bBufferPrimitives = mat_bufferprimitives.GetInt() ? true : false;
pConfig->bDrawFlat = mat_drawflat.GetInt() ? true : false;
pConfig->bSoftwareLighting = mat_softwarelighting.GetInt() ? true : false;
pConfig->proxiesTestMode = mat_proxy.GetInt();
pConfig->m_bSuppressRendering = mat_norendering.GetInt() != 0;
pConfig->bCompressedTextures = mat_compressedtextures.GetBool();
pConfig->bShowSpecular = mat_fastspecular.GetInt() ? true : false;
pConfig->nFullbright = mat_fullbright.GetInt();
pConfig->m_bFastNoBump = mat_fastnobump.GetInt() != 0;
pConfig->m_bMotionBlur = mat_motion_blur_enabled.GetBool();
pConfig->m_bSupportFlashlight = mat_supportflashlight.GetInt() != 0;
pConfig->m_bShadowDepthTexture = r_flashlightdepthtexture.GetBool();
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_ENABLE_HDR, HardwareConfig() && HardwareConfig()->GetHDREnabled() );
// Render-to-texture shadows are disabled for dxlevel 70 because of material issues
if ( pConfig->dxSupportLevel < 80 )
{
r_shadowrendertotexture.SetValue( 0 );
#ifndef _X360
r_waterforceexpensive.SetValue( 0 );
#endif
r_waterforcereflectentities.SetValue( 0 );
}
if ( pConfig->dxSupportLevel < 90 )
{
mat_requires_rt_alloc_first.SetValue( 1 );
r_flashlightdepthtexture.SetValue( 0 );
mat_motion_blur_enabled.SetValue( 0 );
pConfig->m_bShadowDepthTexture = false;
pConfig->m_bMotionBlur = false;
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_ENABLE_HDR, false );
}
// VR mode adapter will generally be -1 if VR mode is not disabled
pConfig->m_nVRModeAdapter = mat_vrmode_adapter.GetInt();
if( pConfig->m_nVRModeAdapter != -1 )
{
// we must always be windowed in the config in VR mode
// so that we will start up on the main display. Once
// VR overrides the adapter the only place we can go
// full screen is on the HMD.
pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_WINDOWED, true );
}
}
//-----------------------------------------------------------------------------
// Was the convar specified on the command-line?
//-----------------------------------------------------------------------------
static bool WasConVarSpecifiedOnCommandLine( const char *pConfigName )
{
// mat_dxlevel cannot be used on the command-line. Use -dxlevel instead.
if ( !Q_stricmp( pConfigName, "mat_dxlevel" ) )
return false;
return ( g_pCVar->GetCommandLineValue( pConfigName ) != NULL);
}
static const char *pConvarsAllowedInDXSupport[]={
"cl_detaildist",
"cl_detailfade",
"cl_ejectbrass",
"dsp_off",
"dsp_slow_cpu",
"mat_antialias",
"mat_aaquality",
"mat_bumpmap",
"mat_colorcorrection",
"mat_depthbias_decal",
"mat_depthbias_normal",
"mat_disable_ps_patch",
"mat_forceaniso",
"mat_forcehardwaresync",
"mat_forcemanagedtextureintohardware",
"mat_hdr_level",
"mat_parallaxmap",
"mat_picmip",
"mat_reducefillrate",
"mat_reduceparticles",
"mat_slopescaledepthbias_decal",
"mat_slopescaledepthbias_normal",
"mat_softwarelighting",
"mat_specular",
"mat_trilinear",
"mat_vsync",
"props_break_max_pieces",
"r_VehicleViewDampen",
"r_decal_cullsize",
"r_dopixelvisibility",
"r_drawdetailprops",
"r_drawflecks",
"r_drawmodeldecals",
"r_dynamic",
"r_lightcache_zbuffercache",
"r_fastzreject",
"r_overlayfademax",
"r_overlayfademin",
"r_rootlod",
"r_screenfademaxsize",
"r_screenfademinsize",
"r_shadowrendertotexture",
"r_shadows",
"r_waterforceexpensive",
"r_waterforcereflectentities",
"sv_alternateticks",
"mat_dxlevel",
"mat_fallbackEyeRefract20",
"r_shader_srgb",
"mat_motion_blur_enabled",
"r_flashlightdepthtexture",
"mat_disablehwmorph",
"r_portal_stencil_depth",
"cl_blobbyshadows",
"r_flex",
"r_drawropes",
"props_break_max_pieces",
"cl_ragdoll_fade_time",
"cl_ragdoll_forcefade",
"tf_impactwatertimeenable",
"fx_drawimpactdebris",
"fx_drawimpactdust",
"fx_drawmetalspark",
"mem_min_heapsize",
"mem_max_heapsize",
"mem_max_heapsize_dedicated",
"snd_spatialize_roundrobin",
"snd_cull_duplicates",
"cl_particle_retire_cost",
"mat_phong"
};
//-----------------------------------------------------------------------------
// Write dxsupport info to configvars
//-----------------------------------------------------------------------------
void CMaterialSystem::WriteConfigurationInfoToConVars( bool bOverwriteCommandLineValues )
{
if ( !g_pCVar )
return;
KeyValues *pKeyValues = new KeyValues( "config" );
if ( !GetRecommendedConfigurationInfo( g_config.dxSupportLevel, pKeyValues ) )
{
pKeyValues->deleteThis();
return;
}
for( KeyValues *pKey = pKeyValues->GetFirstSubKey(); pKey; pKey = pKey->GetNextKey() )
{
const char *pConfigName = pKey->GetName();
if ( Q_strnicmp( pConfigName, "convar.", 7 ))
continue;
pConfigName += 7;
// check if legal
bool bLegalVar = false;
for(int i=0; i< NELEMS( pConvarsAllowedInDXSupport ) ; i++)
{
if (! stricmp( pConvarsAllowedInDXSupport[i], pConfigName ) )
{
bLegalVar = true;
break;
}
}
if (! bLegalVar )
{
Msg(" Bad convar found in dxsupport - %s\n", pConfigName );
continue;
}
if ( bOverwriteCommandLineValues || !WasConVarSpecifiedOnCommandLine( pConfigName ) )
{
ConVar *pConVar = g_pCVar->FindVar( pConfigName );
if ( !pConVar )
{
// NOTE: This is essential for dealing with convars that
// are not specified in either the app that uses the materialsystem
// or the materialsystem itself
// Yes, this causes a memory leak. Too bad!
int nLen = Q_strlen( pConfigName ) + 1;
char *pString = new char[nLen];
Q_strncpy( pString, pConfigName, nLen );
// Actually, we need two memory leaks, or we lose the default string.
int nDefaultLen = Q_strlen( pKey->GetString() ) + 1;
char *pDefaultString = new char[nDefaultLen];
Q_strncpy( pDefaultString, pKey->GetString(), nDefaultLen );
pConVar = new ConVar( pString, pDefaultString );
}
pConVar->SetValue( pKey->GetString() );
}
}
pKeyValues->deleteThis();
}
//-----------------------------------------------------------------------------
// This is called when the config changes
//-----------------------------------------------------------------------------
void CMaterialSystem::WriteConfigIntoConVars( const MaterialSystem_Config_t &config )
{
if ( !g_pCVar )
return;
mat_vsync.SetValue( config.WaitForVSync() );
mat_trilinear.SetValue( config.ForceTrilinear() );
mat_specular.SetValue( config.UseSpecular() );
mat_bumpmap.SetValue( config.UseBumpmapping() );
mat_phong.SetValue( config.UsePhong() );
mat_parallaxmap.SetValue( config.UseParallaxMapping() );
mat_reducefillrate.SetValue( config.ReduceFillrate() );
mat_forceaniso.SetValue( config.m_nForceAnisotropicLevel );
mat_dxlevel.SetValue( MAX( ABSOLUTE_MINIMUM_DXLEVEL, config.dxSupportLevel ) );
mat_picmip.SetValue( config.skipMipLevels );
mat_forcehardwaresync.SetValue( config.ForceHWSync() );
mat_slopescaledepthbias_normal.SetValue( config.m_SlopeScaleDepthBias_Normal );
mat_depthbias_normal.SetValue( config.m_DepthBias_Normal );
mat_slopescaledepthbias_decal.SetValue( config.m_SlopeScaleDepthBias_Decal );
mat_depthbias_decal.SetValue( config.m_DepthBias_Decal );
mat_slopescaledepthbias_shadowmap.SetValue( config.m_SlopeScaleDepthBias_ShadowMap );
mat_depthbias_shadowmap.SetValue( config.m_DepthBias_ShadowMap );
mat_monitorgamma.SetValue( config.m_fMonitorGamma );
mat_monitorgamma_tv_range_min.SetValue( config.m_fGammaTVRangeMin );
mat_monitorgamma_tv_range_max.SetValue( config.m_fGammaTVRangeMax );
mat_monitorgamma_tv_exp.SetValue( config.m_fGammaTVExponent );
mat_monitorgamma_tv_enabled.SetValue( config.m_bGammaTVEnabled );
mat_antialias.SetValue( config.m_nAASamples );
mat_aaquality.SetValue( config.m_nAAQuality );
mat_diffuse.SetValue( config.bShowDiffuse ? 1 : 0 );
// config.bAllowCheats = false; // hack
mat_normalmaps.SetValue( config.bShowNormalMap ? 1 : 0 );
mat_showlowresimage.SetValue( config.bShowLowResImage ? 1 : 0 );
mat_measurefillrate.SetValue( config.bMeasureFillRate ? 1 : 0 );
mat_fillrate.SetValue( config.bVisualizeFillRate ? 1 : 0 );
mat_filterlightmaps.SetValue( config.bFilterLightmaps ? 1 : 0 );
mat_filtertextures.SetValue( config.bFilterTextures ? 1 : 0 );
mat_mipmaptextures.SetValue( config.bMipMapTextures ? 1 : 0 );
mat_showmiplevels.SetValue( config.nShowMipLevels );
mat_reversedepth.SetValue( config.bReverseDepth ? 1 : 0 );
mat_bufferprimitives.SetValue( config.bBufferPrimitives ? 1 : 0 );
mat_drawflat.SetValue( config.bDrawFlat ? 1 : 0 );
mat_softwarelighting.SetValue( config.bSoftwareLighting ? 1 : 0 );
mat_proxy.SetValue( config.proxiesTestMode );
mat_norendering.SetValue( config.m_bSuppressRendering ? 1 : 0 );
mat_compressedtextures.SetValue( config.bCompressedTextures ? 1 : 0 );
mat_fastspecular.SetValue( config.bShowSpecular ? 1 : 0 );
mat_fullbright.SetValue( config.nFullbright );
mat_fastnobump.SetValue( config.m_bFastNoBump ? 1 : 0 );
bool hdre = config.HDREnabled();
HardwareConfig()->SetHDREnabled( hdre );
r_flashlightdepthtexture.SetValue( config.m_bShadowDepthTexture ? 1 : 0 );
mat_motion_blur_enabled.SetValue( config.m_bMotionBlur ? 1 : 0 );
mat_supportflashlight.SetValue( config.m_bSupportFlashlight ? 1 : 0 );
}
//-----------------------------------------------------------------------------
// This is called constantly to catch for config changes
//-----------------------------------------------------------------------------
bool CMaterialSystem::OverrideConfig( const MaterialSystem_Config_t &_config, bool forceUpdate )
{
Assert( m_bGeneratedConfig );
if ( memcmp( &_config, &g_config, sizeof(_config) ) == 0 )
{
return false;
}
MaterialLock_t hLock = Lock();
MaterialSystem_Config_t config = _config;
bool bRedownloadLightmaps = false;
bool bRedownloadTextures = false;
bool recomputeSnapshots = false;
bool dxSupportLevelChanged = false;
bool bReloadMaterials = false;
bool bResetAnisotropy = false;
bool bSetStandardVertexShaderConstants = false;
bool bMonitorGammaChanged = false;
bool bVideoModeChange = false;
bool bResetTextureFilter = false;
bool bForceAltTab = false;
// internal config settings
#ifndef _X360
MaterialSystem_Config_Internal_t config_internal;
config_internal.r_waterforceexpensive = r_waterforceexpensive.GetInt();
#endif
if ( !g_pShaderDevice->IsUsingGraphics() )
{
g_config = config;
#ifndef _X360
g_config_internal = config_internal;
#endif
// Shouldn't call this more than once.
ColorSpace::SetGamma( 2.2f, 2.2f, OVERBRIGHT, g_config.bAllowCheats, false );
Unlock( hLock );
return bRedownloadLightmaps;
}
// set the default state since we might be changing the number of
// texture units, etc. (i.e. we don't want to leave unit 2 in overbright mode
// if it isn't going to be reset upon each SetDefaultState because there is
// effectively only one texture unit.)
g_pShaderAPI->SetDefaultState();
// toggle dx emulation level
if ( config.dxSupportLevel != g_config.dxSupportLevel )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: Setting dxSupportLevelChanged, bResetAnisotropy, and bReloadMaterials because new dxlevel = %d and old dxlevel = %d\n",
( int )config.dxSupportLevel, g_config.dxSupportLevel );
}
dxSupportLevelChanged = true;
bResetAnisotropy = true;
// Necessary for DXSupportLevelChanged to work
g_config.dxSupportLevel = config.dxSupportLevel;
// This will reset config to match whatever the dxlevel wants
// and slam to convars to match
g_pShaderAPI->DXSupportLevelChanged( );
WriteConfigurationInfoToConVars();
ReadConfigFromConVars( &config );
bReloadMaterials = true;
}
if ( config.HDREnabled() != g_config.HDREnabled() )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: Setting forceUpdate, bReloadMaterials, and bForceAltTab because new hdr level = %d and old hdr level = %d\n",
( int )config.HDREnabled(), g_config.HDREnabled() );
}
forceUpdate = true;
bReloadMaterials = true;
bForceAltTab = true;
}
if ( config.ShadowDepthTexture() != g_config.ShadowDepthTexture() )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: Setting forceUpdate, bReloadMaterials and recomputeSnapshots (ShadowDepthTexture changed: %d -> %d)\n",
g_config.ShadowDepthTexture() ? 1 : 0, config.ShadowDepthTexture() ? 1 : 0 );
}
forceUpdate = true;
bReloadMaterials = true;
recomputeSnapshots = true;
}
if ( config.VRMode() != g_config.VRMode() || config.m_nVRModeAdapter != g_config.m_nVRModeAdapter )
{
bVideoModeChange = true;
}
// Don't use compressed textures for the moment if we don't support them
if ( HardwareConfig() && !HardwareConfig()->SupportsCompressedTextures() )
{
config.bCompressedTextures = false;
}
if ( forceUpdate )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: forceUpdate is true, therefore setting recomputeSnapshots, bRedownloadLightmaps, bRedownloadTextures, bResetAnisotropy, and bSetStandardVertexShaderConstants\n" );
}
GetLightmaps()->EnableLightmapFiltering( config.bFilterLightmaps );
recomputeSnapshots = true;
bRedownloadLightmaps = true;
bRedownloadTextures = true;
bResetAnisotropy = true;
bSetStandardVertexShaderConstants = true;
}
// toggle bump mapping
if ( config.UseBumpmapping() != g_config.UseBumpmapping() || config.UsePhong() != g_config.UsePhong() )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: forceUpdate is true, therefore setting recomputeSnapshots, bRedownloadLightmaps, bRedownloadTextures, bResetAnisotropy, and bSetStandardVertexShaderConstants\n" );
}
recomputeSnapshots = true;
bReloadMaterials = true;
bResetAnisotropy = true;
}
// toggle specularity
if ( config.UseSpecular() != g_config.UseSpecular() )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new usespecular=%d, old usespecular=%d, setting recomputeSnapshots, bReloadMaterials, and bResetAnisotropy\n",
( int )config.UseSpecular(), ( int )g_config.UseSpecular() );
}
recomputeSnapshots = true;
bReloadMaterials = true;
bResetAnisotropy = true;
}
// toggle parallax mapping
if ( config.UseParallaxMapping() != g_config.UseParallaxMapping() )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new UseParallaxMapping=%d, old UseParallaxMapping=%d, setting bReloadMaterials\n",
( int )config.UseParallaxMapping(), ( int )g_config.UseParallaxMapping() );
}
bReloadMaterials = true;
}
// Reload materials if we want reduced fillrate
if ( config.ReduceFillrate() != g_config.ReduceFillrate() )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new ReduceFillrate=%d, old ReduceFillrate=%d, setting bReloadMaterials\n",
( int )config.ReduceFillrate(), ( int )g_config.ReduceFillrate() );
}
bReloadMaterials = true;
}
// toggle reverse depth
if ( config.bReverseDepth != g_config.bReverseDepth )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new ReduceFillrate=%d, old ReduceFillrate=%d, setting bReloadMaterials\n",
( int )config.ReduceFillrate(), ( int )g_config.ReduceFillrate() );
}
recomputeSnapshots = true;
bResetAnisotropy = true;
}
// toggle no transparency
if ( config.bNoTransparency != g_config.bNoTransparency )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new bNoTransparency=%d, old bNoTransparency=%d, setting recomputeSnapshots and bResetAnisotropy\n",
( int )config.bNoTransparency, ( int )g_config.bNoTransparency );
}
recomputeSnapshots = true;
bResetAnisotropy = true;
}
// toggle lightmap filtering
if ( config.bFilterLightmaps != g_config.bFilterLightmaps )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new bFilterLightmaps=%d, old bFilterLightmaps=%d, setting EnableLightmapFiltering\n",
( int )config.bFilterLightmaps, ( int )g_config.bFilterLightmaps );
}
GetLightmaps()->EnableLightmapFiltering( config.bFilterLightmaps );
}
// toggle software lighting
if ( config.bSoftwareLighting != g_config.bSoftwareLighting )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new bSoftwareLighting=%d, old bSoftwareLighting=%d, setting bReloadMaterials\n",
( int )config.bFilterLightmaps, ( int )g_config.bFilterLightmaps );
}
bReloadMaterials = true;
}
#ifndef _X360
if ( config_internal.r_waterforceexpensive != g_config_internal.r_waterforceexpensive )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new r_waterforceexpensive=%d, old r_waterforceexpensive=%d, setting bReloadMaterials\n",
( int )config_internal.r_waterforceexpensive, ( int )g_config_internal.r_waterforceexpensive );
}
bReloadMaterials = true;
}
#endif
// generic things that cause us to redownload lightmaps
if ( config.bAllowCheats != g_config.bAllowCheats )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new bAllowCheats=%d, old bAllowCheats=%d, setting bRedownloadLightmaps\n",
( int )config.bAllowCheats, ( int )g_config.bAllowCheats );
}
bRedownloadLightmaps = true;
}
// generic things that cause us to redownload textures
if ( config.bAllowCheats != g_config.bAllowCheats ||
config.skipMipLevels != g_config.skipMipLevels ||
config.nShowMipLevels != g_config.nShowMipLevels ||
((config.bCompressedTextures != g_config.bCompressedTextures) && HardwareConfig()->SupportsCompressedTextures())||
config.bShowLowResImage != g_config.bShowLowResImage
)
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: setting bRedownloadTextures, recomputeSnapshots, and bResetAnisotropy\n" );
}
bRedownloadTextures = true;
recomputeSnapshots = true;
bResetAnisotropy = true;
}
if ( config.ForceTrilinear() != g_config.ForceTrilinear() )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new forcetrilinear: %d, old forcetrilinear: %d, setting bResetTextureFilter\n",
( int )config.ForceTrilinear(), ( int )g_config.ForceTrilinear() );
}
bResetTextureFilter = true;
}
if ( config.m_nForceAnisotropicLevel != g_config.m_nForceAnisotropicLevel )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new m_nForceAnisotropicLevel: %d, old m_nForceAnisotropicLevel: %d, setting bResetAnisotropy and bResetTextureFilter\n",
( int )config.ForceTrilinear(), ( int )g_config.ForceTrilinear() );
}
bResetAnisotropy = true;
bResetTextureFilter = true;
}
if ( config.m_fMonitorGamma != g_config.m_fMonitorGamma || config.m_fGammaTVRangeMin != g_config.m_fGammaTVRangeMin ||
config.m_fGammaTVRangeMax != g_config.m_fGammaTVRangeMax || config.m_fGammaTVExponent != g_config.m_fGammaTVExponent ||
config.m_bGammaTVEnabled != g_config.m_bGammaTVEnabled )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: new monitorgamma: %f, old monitorgamma: %f, setting bMonitorGammaChanged\n",
config.m_fMonitorGamma, g_config.m_fMonitorGamma );
}
bMonitorGammaChanged = true;
}
if ( config.m_VideoMode.m_Width != g_config.m_VideoMode.m_Width ||
config.m_VideoMode.m_Height != g_config.m_VideoMode.m_Height ||
config.m_VideoMode.m_RefreshRate != g_config.m_VideoMode.m_RefreshRate ||
config.m_nAASamples != g_config.m_nAASamples ||
config.m_nAAQuality != g_config.m_nAAQuality ||
config.Windowed() != g_config.Windowed() ||
config.Stencil() != g_config.Stencil() )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: video mode changed for one of various reasons\n" );
}
bVideoModeChange = true;
}
// toggle wait for vsync
// In GL, we just check this and it's just a function call--no need for device shenanigans.
#if !defined( DX_TO_GL_ABSTRACTION )
if ( (IsX360() || !config.Windowed()) && (config.WaitForVSync() != g_config.WaitForVSync()) )
{
# if ( !defined( _X360 ) )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: video mode changed due to toggle of wait for vsync\n" );
}
bVideoModeChange = true;
}
# else
{
g_pShaderAPI->EnableVSync_360( config.WaitForVSync() );
}
# endif
}
#endif
g_config = config;
#ifndef _X360
g_config_internal = config_internal;
#endif
if ( dxSupportLevelChanged )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: dx support level changed, clearing snapshots\n" );
}
// All snapshots have basically become invalid;
g_pShaderAPI->ClearSnapshots();
}
if ( bRedownloadTextures || bRedownloadLightmaps )
{
// Get rid of this?
ColorSpace::SetGamma( 2.2f, 2.2f, OVERBRIGHT, g_config.bAllowCheats, false );
}
// 360 does not support various configuration changes and cannot reload materials
if ( !IsX360() )
{
if ( bResetAnisotropy || recomputeSnapshots || bRedownloadLightmaps ||
bRedownloadTextures || bResetAnisotropy || bVideoModeChange ||
bSetStandardVertexShaderConstants || bResetTextureFilter )
{
Unlock( hLock );
ForceSingleThreaded();
hLock = Lock();
}
}
if ( bReloadMaterials && !IsX360() )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: ReloadMaterials\n" );
}
ReloadMaterials();
}
// 360 does not support various configuration changes and cannot reload textures
// 360 has no reason to reload textures, it's unnecessary and massively expensive
// 360 does not use this path as an init affect to get its textures into memory
if ( bRedownloadTextures && !IsX360() )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: redownloading textures\n" );
}
if ( g_pShaderAPI->CanDownloadTextures() )
{
TextureManager()->RestoreRenderTargets();
TextureManager()->RestoreNonRenderTargetTextures();
}
}
else if ( bResetTextureFilter )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: ResetTextureFilteringState\n" );
}
TextureManager()->ResetTextureFilteringState();
}
// Recompute all state snapshots
if ( recomputeSnapshots )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: RecomputeAllStateSnapshots\n" );
}
RecomputeAllStateSnapshots();
}
if ( bResetAnisotropy )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: SetAnisotropicLevel\n" );
}
g_pShaderAPI->SetAnisotropicLevel( config.m_nForceAnisotropicLevel );
}
if ( bSetStandardVertexShaderConstants )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: SetStandardVertexShaderConstants\n" );
}
g_pShaderAPI->SetStandardVertexShaderConstants( OVERBRIGHT );
}
if ( bMonitorGammaChanged )
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: SetHardwareGammaRamp\n" );
}
g_pShaderDevice->SetHardwareGammaRamp( config.m_fMonitorGamma, config.m_fGammaTVRangeMin, config.m_fGammaTVRangeMax,
config.m_fGammaTVExponent, config.m_bGammaTVEnabled );
}
if ( bVideoModeChange )
{
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: ChangeVideoMode\n" );
}
ShaderDeviceInfo_t info;
ConvertModeStruct( &info, config );
g_pShaderAPI->ChangeVideoMode( info );
#if defined( USE_SDL )
uint width = info.m_DisplayMode.m_nWidth;
uint height = info.m_DisplayMode.m_nHeight;
g_pLauncherMgr->RenderedSize( width, height, true ); // true = set
#endif
}
if ( bForceAltTab )
{
// Simulate an Alt-Tab
// g_pShaderAPI->ReleaseResources();
// g_pShaderAPI->ReacquireResources();
}
Unlock( hLock );
if ( bVideoModeChange )
{
ForceSingleThreaded();
}
return bRedownloadLightmaps;
}
//-----------------------------------------------------------------------------
// This is called when the config changes
//-----------------------------------------------------------------------------
bool CMaterialSystem::UpdateConfig( bool forceUpdate )
{
int nUpdateFlags = 0;
if ( g_pCVar && g_pCVar->HasQueuedMaterialThreadConVarSets() )
{
ForceSingleThreaded();
nUpdateFlags = g_pCVar->ProcessQueuedMaterialThreadConVarSets();
}
MaterialSystem_Config_t config = g_config;
ReadConfigFromConVars( &config );
return OverrideConfig( config, forceUpdate );
}
void CMaterialSystem::ReleaseResources()
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: CMaterialSystem::ReleaseResources\n" );
}
g_pShaderAPI->FlushBufferedPrimitives();
g_pShaderDevice->ReleaseResources();
}
void CMaterialSystem::ReacquireResources()
{
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: CMaterialSystem::ReacquireResources\n" );
}
g_pShaderDevice->ReacquireResources();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CMaterialSystem::OnDrawMesh( IMesh *pMesh, int firstIndex, int numIndices )
{
if ( IsInStubMode() )
{
return false;
}
return GetRenderContextInternal()->OnDrawMesh( pMesh, firstIndex, numIndices );
}
bool CMaterialSystem::OnDrawMesh( IMesh *pMesh, CPrimList *pLists, int nLists )
{
if ( IsInStubMode() )
{
return false;
}
return GetRenderContextInternal()->OnDrawMesh( pMesh, pLists, nLists );
}
void CMaterialSystem::OnThreadEvent( uint32 threadEvent )
{
m_threadEvents.AddToTail( threadEvent );
}
ShaderAPITextureHandle_t CMaterialSystem::GetShaderAPITextureBindHandle( ITexture *pTexture, int nFrame, int nTextureChannel )
{
return ShaderSystem()->GetShaderAPITextureBindHandle( pTexture, nFrame, nTextureChannel );
}
//-----------------------------------------------------------------------------
// Creates a procedural texture
//-----------------------------------------------------------------------------
ITexture *CMaterialSystem::CreateProceduralTexture(
const char *pTextureName,
const char *pTextureGroupName,
int w,
int h,
ImageFormat fmt,
int nFlags )
{
ITextureInternal* pTex = TextureManager()->CreateProceduralTexture( pTextureName, pTextureGroupName, w, h, 1, fmt, nFlags );
return pTex;
}
//-----------------------------------------------------------------------------
// Create new materials (currently only used by the editor!)
//-----------------------------------------------------------------------------
IMaterial *CMaterialSystem::CreateMaterial( const char *pMaterialName, KeyValues *pVMTKeyValues )
{
// For not, just create a material with no default settings
IMaterialInternal* pMaterial = IMaterialInternal::CreateMaterial( pMaterialName, TEXTURE_GROUP_OTHER, pVMTKeyValues );
pMaterial->IncrementReferenceCount();
AddMaterialToMaterialList( pMaterial );
return pMaterial->GetQueueFriendlyVersion();
}
//-----------------------------------------------------------------------------
// Finds or creates a procedural material
//-----------------------------------------------------------------------------
IMaterial *CMaterialSystem::FindProceduralMaterial( const char *pMaterialName, const char *pTextureGroupName, KeyValues *pVMTKeyValues )
{
// We need lower-case symbols for this to work
int nLen = Q_strlen( pMaterialName ) + 1;
char *pTemp = (char*)stackalloc( nLen );
Q_strncpy( pTemp, pMaterialName, nLen );
Q_strlower( pTemp );
Q_FixSlashes( pTemp, '/' );
// 'true' causes the search to find procedural materials
IMaterialInternal *pMaterial = m_MaterialDict.FindMaterial( pTemp, true );
if ( pMaterial )
{
pVMTKeyValues->deleteThis();
}
else
{
pMaterial = IMaterialInternal::CreateMaterial( pMaterialName, pTextureGroupName, pVMTKeyValues );
AddMaterialToMaterialList( static_cast<IMaterialInternal*>( pMaterial ) );
}
return pMaterial->GetQueueFriendlyVersion();
}
//-----------------------------------------------------------------------------
// Search by name
//-----------------------------------------------------------------------------
bool CMaterialSystem::IsMaterialLoaded( char const *pMaterialName )
{
// We need lower-case symbols for this to work
int nLen = Q_strlen( pMaterialName ) + 1;
char *pFixedNameTemp = (char*)stackalloc( nLen );
char *pTemp = (char*)stackalloc( nLen );
Q_strncpy( pFixedNameTemp, pMaterialName, nLen );
Q_strlower( pFixedNameTemp );
#ifdef POSIX
// strip extensions needs correct slashing for the OS, so fix it up early for Posix
Q_FixSlashes( pFixedNameTemp, '/' );
#endif
Q_StripExtension( pFixedNameTemp, pTemp, nLen );
#ifndef POSIX
Q_FixSlashes( pTemp, '/' );
#endif
Assert( nLen >= Q_strlen( pTemp ) + 1 );
return m_MaterialDict.FindMaterial( pTemp, false ) != NULL; // 'false' causes the search to find only file-created materials
}
//-----------------------------------------------------------------------------
// Search by name
//-----------------------------------------------------------------------------
IMaterial* CMaterialSystem::FindMaterial( char const *pMaterialName, const char *pTextureGroupName, bool bComplain, const char *pComplainPrefix )
{
return FindMaterialEx( pMaterialName, pTextureGroupName, MATERIAL_FINDCONTEXT_NONE, bComplain, pComplainPrefix );
}
//-----------------------------------------------------------------------------
// Search by name
//-----------------------------------------------------------------------------
IMaterial* CMaterialSystem::FindMaterialEx( char const* pMaterialName, const char *pTextureGroupName, int nContext, bool bComplain, const char *pComplainPrefix )
{
// We need lower-case symbols for this to work
int nLen = Q_strlen( pMaterialName ) + 1;
amd64: fix multithread, fix vgui, fix physmodels
2022-06-05 06:44:42 +08:00
char *pFixedNameTemp = (char*)malloc( nLen );
char *pTemp = (char*)malloc( nLen );
1
2020-04-23 00:56:21 +08:00
Q_strncpy( pFixedNameTemp, pMaterialName, nLen );
Q_strlower( pFixedNameTemp );
#ifdef POSIX
// strip extensions needs correct slashing for the OS, so fix it up early for Posix
Q_FixSlashes( pFixedNameTemp, '/' );
#endif
Q_StripExtension( pFixedNameTemp, pTemp, nLen );
#ifndef POSIX
Q_FixSlashes( pTemp, '/' );
#endif
Assert( nLen >= Q_strlen( pTemp ) + 1 );
IMaterialInternal *pExistingMaterial = m_MaterialDict.FindMaterial( pTemp, false ); // 'false' causes the search to find only file-created materials
if ( pExistingMaterial )
return pExistingMaterial->GetQueueFriendlyVersion();
// It hasn't been seen yet, so let's check to see if it's in the filesystem.
nLen = Q_strlen( "materials/" ) + Q_strlen( pTemp ) + Q_strlen( ".vmt" ) + 1;
char *vmtName = (char *)stackalloc( nLen );
// Check to see if this is a UNC-specified material name
bool bIsUNC = pTemp[0] == '/' && pTemp[1] == '/' && pTemp[2] != '/';
if ( !bIsUNC )
{
Q_strncpy( vmtName, "materials/", nLen );
Q_strncat( vmtName, pTemp, nLen, COPY_ALL_CHARACTERS );
V_FixDoubleSlashes( vmtName );
}
else
{
Q_strncpy( vmtName, pTemp, nLen );
}
//Q_strncat( vmtName, ".vmt", nLen, COPY_ALL_CHARACTERS );
Assert( nLen >= (int)Q_strlen( vmtName ) + 1 );
CUtlVector<FileNameHandle_t> includes;
KeyValues *pKeyValues = new KeyValues("vmt");
KeyValues *pPatchKeyValues = new KeyValues( "vmt_patches" );
if ( !LoadVMTFile( *pKeyValues, *pPatchKeyValues, vmtName, true, &includes ) )
{
pKeyValues->deleteThis();
pKeyValues = NULL;
pPatchKeyValues->deleteThis();
pPatchKeyValues = NULL;
}
else
{
char *matNameWithExtension;
nLen = Q_strlen( pTemp ) + Q_strlen( ".vmt" ) + 1;
matNameWithExtension = (char *)stackalloc( nLen );
Q_strncpy( matNameWithExtension, pTemp, nLen );
Q_strncat( matNameWithExtension, ".vmt", nLen, COPY_ALL_CHARACTERS );
IMaterialInternal *pMat = NULL;
if ( !Q_stricmp( pKeyValues->GetName(), "subrect" ) )
{
pMat = m_MaterialDict.AddMaterialSubRect( matNameWithExtension, pTextureGroupName, pKeyValues, pPatchKeyValues );
}
else
{
pMat = m_MaterialDict.AddMaterial( matNameWithExtension, pTextureGroupName );
if ( g_pShaderDevice->IsUsingGraphics() )
{
if ( !bIsUNC )
{
m_pForcedTextureLoadPathID = "GAME";
}
pMat->PrecacheVars( pKeyValues, pPatchKeyValues, &includes, nContext );
m_pForcedTextureLoadPathID = NULL;
}
}
pKeyValues->deleteThis();
pPatchKeyValues->deleteThis();
return pMat->GetQueueFriendlyVersion();
}
if ( bComplain )
{
Assert( pTemp );
// convert to lowercase
nLen = Q_strlen(pTemp) + 1 ;
char *name = (char*)stackalloc( nLen );
Q_strncpy( name, pTemp, nLen );
Q_strlower( name );
if ( m_MaterialDict.NoteMissing( name ) )
{
if ( pComplainPrefix )
{
DevWarning( "%s", pComplainPrefix );
}
DevWarning( "material \"%s\" not found.\n", name );
}
}
amd64: fix multithread, fix vgui, fix physmodels
2022-06-05 06:44:42 +08:00
free(pTemp);
free(pFixedNameTemp);
1
2020-04-23 00:56:21 +08:00
return g_pErrorMaterial->GetRealTimeVersion();
}
void CMaterialSystem::SetAsyncTextureLoadCache( void* h )
{
Assert( !h || !m_hAsyncLoadFileCache );
m_hAsyncLoadFileCache = ( FileCacheHandle_t ) h;
}
static char const *TextureAliases[] =
{
// this table is only here for backwards compatibility where a render target change was made,
// and we wish to redirect an existing old client.dll for hl2 to reference this texture. It's
// not meant as a general texture aliasing system.
"_rt_FullFrameFB1", "_rt_FullScreen"
};
ITexture *CMaterialSystem::FindTexture( char const *pTextureName, const char *pTextureGroupName, bool bComplain /* = false */, int nAdditionalCreationFlags /* = 0 */ )
{
if ( m_hAsyncLoadFileCache && !TextureManager()->IsTextureLoaded( pTextureName ) )
{
bool bIsUNCName = ( pTextureName[0] == '/' && pTextureName[1] == '/' && pTextureName[2] != '/' );
if ( !bIsUNCName )
{
const char* pPathID = "GAME";
char buf[MAX_PATH];
V_snprintf( buf, MAX_PATH, "materials/%s", pTextureName );
V_SetExtension( buf, ".vtf", sizeof( buf ) );
const char *pbuf = buf;
g_pFullFileSystem->AddFilesToFileCache( m_hAsyncLoadFileCache, &pbuf, 1, pPathID );
return TextureManager()->ErrorTexture();
}
}
ITextureInternal *pTexture = TextureManager()->FindOrLoadTexture( pTextureName, pTextureGroupName, nAdditionalCreationFlags );
Assert( pTexture );
if ( pTexture->IsError() )
{
if ( IsPC() )
{
for ( int i=0; i<NELEMS( TextureAliases ); i+=2 )
{
if ( !Q_stricmp( pTextureName, TextureAliases[i] ) )
{
return FindTexture( TextureAliases[i+1], pTextureGroupName, bComplain, nAdditionalCreationFlags );
}
}
}
if ( bComplain )
{
DevWarning( "Texture '%s' not found.\n", pTextureName );
}
}
return pTexture;
}
bool CMaterialSystem::IsTextureLoaded( char const* pTextureName ) const
{
return TextureManager()->IsTextureLoaded( pTextureName );
}
void CMaterialSystem::AddTextureAlias( const char *pAlias, const char *pRealName )
{
TextureManager()->AddTextureAlias( pAlias, pRealName );
}
void CMaterialSystem::RemoveTextureAlias( const char *pAlias )
{
TextureManager()->RemoveTextureAlias( pAlias );
}
void CMaterialSystem::SetExcludedTextures( const char *pScriptName )
{
TextureManager()->SetExcludedTextures( pScriptName );
}
void CMaterialSystem::UpdateExcludedTextures( void )
{
TextureManager()->UpdateExcludedTextures();
// Have to re-setup the representative textures since they may have been removed out from under us by the queued loader.
for (MaterialHandle_t i = FirstMaterial(); i != InvalidMaterial(); i = NextMaterial(i) )
{
GetMaterialInternal(i)->FindRepresentativeTexture();
GetMaterialInternal(i)->PrecacheMappingDimensions();
}
}
//-----------------------------------------------------------------------------
// Recomputes state snapshots for all materials
//-----------------------------------------------------------------------------
void CMaterialSystem::RecomputeAllStateSnapshots()
{
g_pShaderAPI->ClearSnapshots();
for (MaterialHandle_t i = FirstMaterial(); i != InvalidMaterial(); i = NextMaterial(i) )
{
GetMaterialInternal(i)->RecomputeStateSnapshots();
}
g_pShaderAPI->ResetRenderState();
}
//-----------------------------------------------------------------------------
// Suspend texture streaming operations, for abormal periods such as loading
//-----------------------------------------------------------------------------
void CMaterialSystem::SuspendTextureStreaming()
{
TextureManager()->SuspendTextureStreaming();
}
//-----------------------------------------------------------------------------
// Inverse of SuspendTextureStreaming
//-----------------------------------------------------------------------------
void CMaterialSystem::ResumeTextureStreaming()
{
TextureManager()->ResumeTextureStreaming();
}
//-----------------------------------------------------------------------------
// Uncache all materials
//-----------------------------------------------------------------------------
void CMaterialSystem::UncacheAllMaterials()
{
MaterialLock_t hLock = Lock();
Flush( true );
m_bReplacementFilesValid = false;
for ( MaterialHandle_t i = FirstMaterial(); i != InvalidMaterial(); i = NextMaterial( i ) )
{
Assert( GetMaterialInternal(i)->GetReferenceCount() >= 0 );
GetMaterialInternal(i)->Uncache();
}
TextureManager()->RemoveUnusedTextures();
Unlock( hLock );
}
//-----------------------------------------------------------------------------
// Uncache unused materials
//-----------------------------------------------------------------------------
void CMaterialSystem::UncacheUnusedMaterials( bool bRecomputeStateSnapshots )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
MaterialLock_t hLock = Lock();
Flush( true );
// We need two loops to make sure we don't reset the snapshots if nothing got removed,
// otherwise the snapshot recomputation is expensive and avoided at load time
bool bDidUncacheMaterial = false;
for ( MaterialHandle_t i = FirstMaterial(); i != InvalidMaterial(); i = NextMaterial(i) )
{
IMaterialInternal *pMatInternal = GetMaterialInternal( i );
Assert( pMatInternal->GetReferenceCount() >= 0 );
if ( pMatInternal->GetReferenceCount() <= 0 )
{
bDidUncacheMaterial = true;
pMatInternal->Uncache();
}
}
if ( IsX360() && bRecomputeStateSnapshots )
{
// Always recompute snapshots because the queued loading process skips it during pre-purge,
// allowing it to happen just once, here.
bDidUncacheMaterial = true;
}
if ( bDidUncacheMaterial && bRecomputeStateSnapshots )
{
// Clear the state snapshots since we are going to rebuild all of them.
g_pShaderAPI->ClearSnapshots();
g_pShaderAPI->ClearVertexAndPixelShaderRefCounts();
for ( MaterialHandle_t i = FirstMaterial(); i != InvalidMaterial(); i = NextMaterial(i) )
{
IMaterialInternal *pMatInternal = GetMaterialInternal(i);
if ( pMatInternal->GetReferenceCount() > 0 )
{
// Recompute the state snapshots for the materials that we are keeping
// since we blew all of them away above.
pMatInternal->RecomputeStateSnapshots();
}
}
g_pShaderAPI->PurgeUnusedVertexAndPixelShaders();
}
if ( bRecomputeStateSnapshots )
{
// kick out all per material context datas
for( MaterialHandle_t i = m_MaterialDict.FirstMaterial(); i != m_MaterialDict.InvalidMaterial(); i = m_MaterialDict.NextMaterial( i ) )
{
GetMaterialInternal(i)->ClearContextData();
}
}
TextureManager()->RemoveUnusedTextures();
Unlock( hLock );
}
//-----------------------------------------------------------------------------
// Release temporary HW memory...
//-----------------------------------------------------------------------------
void CMaterialSystem::ResetTempHWMemory( bool bExitingLevel )
{
g_pShaderAPI->DestroyVertexBuffers( bExitingLevel );
TextureManager()->ReleaseTempRenderTargetBits();
}
//-----------------------------------------------------------------------------
// Cache used materials
//-----------------------------------------------------------------------------
void CMaterialSystem::CacheUsedMaterials( )
{
g_pShaderAPI->EvictManagedResources();
size_t count = 0;
for (MaterialHandle_t i = FirstMaterial(); i != InvalidMaterial(); i = NextMaterial(i) )
{
// Some (mac) drivers (amd) seem to keep extra resources around on uploads until the next frame swap. This
// injects pointless synthetic swaps (between already-static load frames)
if ( mat_texture_reload_frame_swap_workaround.GetBool() )
{
if ( count++ % 20 == 0 )
{
Flush(true);
SwapBuffers(); // Not the right thing to call
}
}
IMaterialInternal* pMat = GetMaterialInternal(i);
Assert( pMat->GetReferenceCount() >= 0 );
if( pMat->GetReferenceCount() > 0 )
{
pMat->Precache();
}
}
if ( mat_forcemanagedtextureintohardware.GetBool() )
{
TextureManager()->ForceAllTexturesIntoHardware();
}
}
//-----------------------------------------------------------------------------
// Reloads textures + materials
//-----------------------------------------------------------------------------
void CMaterialSystem::ReloadTextures( void )
{
// Add by jay in changelist 621420.
ForceSingleThreaded();
// 360 should not have gotten here
Assert( !IsX360() );
KeyValuesSystem()->InvalidateCache();
TextureManager()->RestoreRenderTargets();
TextureManager()->RestoreNonRenderTargetTextures();
}
void CMaterialSystem::ReloadMaterials( const char *pSubString )
{
bool bDeviceReady = g_pShaderAPI->CanDownloadTextures();
if ( !bDeviceReady )
{
//$ TODO: Merge m_bDeferredMaterialReload from cs:go?
Msg( "%s bDeviceReady false\n", __FUNCTION__ );
}
// Add by jay in changelist 621420.
ForceSingleThreaded();
KeyValuesSystem()->InvalidateCache();
bool bVertexFormatChanged = false;
if( pSubString == NULL )
{
bVertexFormatChanged = true;
UncacheAllMaterials();
CacheUsedMaterials();
}
else
{
Flush( false );
char const chMultiDelim = '*';
CUtlVector< char > arrSearchSubString;
CUtlVector< char const * > arrSearchItems;
if ( strchr( pSubString, chMultiDelim ) )
{
arrSearchSubString.SetCount( strlen( pSubString ) + 1 );
strcpy( arrSearchSubString.Base(), pSubString );
for ( char * pch = arrSearchSubString.Base(); pch; )
{
char *pchEnd = strchr( pch, chMultiDelim );
pchEnd ? *( pchEnd ++ ) = 0 : 0;
arrSearchItems.AddToTail( pch );
pch = pchEnd;
}
}
for (MaterialHandle_t i = FirstMaterial(); i != InvalidMaterial(); i = NextMaterial(i) )
{
if( GetMaterialInternal(i)->GetReferenceCount() <= 0 )
continue;
char const *szMatName = GetMaterialInternal(i)->GetName();
if ( arrSearchItems.Count() > 1 )
{
bool bMatched = false;
for ( int k = 0; !bMatched && ( k < arrSearchItems.Count() ); ++ k )
if( Q_stristr( szMatName, arrSearchItems[k] ) )
bMatched = true;
if ( !bMatched )
continue;
}
else
{
if( !Q_stristr( szMatName, pSubString ) )
continue;
}
if ( !GetMaterialInternal(i)->IsPrecached() )
{
if ( GetMaterialInternal(i)->IsPrecachedVars() )
{
GetMaterialInternal(i)->Uncache( );
}
}
else
{
VertexFormat_t oldVertexFormat = GetMaterialInternal(i)->GetVertexFormat();
GetMaterialInternal(i)->Uncache();
GetMaterialInternal(i)->Precache();
GetMaterialInternal(i)->ReloadTextures();
if( GetMaterialInternal(i)->GetVertexFormat() != oldVertexFormat )
{
bVertexFormatChanged = true;
}
}
}
}
if( bVertexFormatChanged && bDeviceReady )
{
// Reloading materials could cause a vertex format change, so
// we need to release and restore
ReleaseShaderObjects();
RestoreShaderObjects( NULL, MATERIAL_RESTORE_VERTEX_FORMAT_CHANGED );
}
}
//-----------------------------------------------------------------------------
// Allocates the standard textures used by the material system
//-----------------------------------------------------------------------------
void CMaterialSystem::AllocateStandardTextures()
{
if ( m_StandardTexturesAllocated )
return;
m_StandardTexturesAllocated = true;
float nominal_lightmap_value = 1.0;
if ( HardwareConfig()->GetHDRType() == HDR_TYPE_INTEGER )
nominal_lightmap_value = 1.0/16.0;
unsigned char texel[4];
texel[3] = 255;
int tcFlags = TEXTURE_CREATE_MANAGED;
int tcFlagsSRGB = TEXTURE_CREATE_MANAGED | TEXTURE_CREATE_SRGB;
if ( IsX360() )
{
tcFlags |= TEXTURE_CREATE_CANCONVERTFORMAT;
tcFlagsSRGB |= TEXTURE_CREATE_CANCONVERTFORMAT;
}
// allocate a white, single texel texture for the fullbright lightmap
// note: make sure and redo this when changing gamma, etc.
// don't mipmap lightmaps
m_FullbrightLightmapTextureHandle = g_pShaderAPI->CreateTexture( 1, 1, 1, IMAGE_FORMAT_BGRX8888, 1, 1, tcFlags, "[FULLBRIGHT_LIGHTMAP_TEXID]", TEXTURE_GROUP_LIGHTMAP );
g_pShaderAPI->ModifyTexture( m_FullbrightLightmapTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
float tmpVect[3] = { nominal_lightmap_value, nominal_lightmap_value, nominal_lightmap_value };
ColorSpace::LinearToLightmap( texel, tmpVect );
g_pShaderAPI->TexImage2D( 0, 0, IMAGE_FORMAT_BGRX8888, 0, 1, 1, IMAGE_FORMAT_BGRX8888, false, texel );
// allocate a black single texel texture
#if !defined( _X360 )
m_BlackTextureHandle = g_pShaderAPI->CreateTexture( 1, 1, 1, IMAGE_FORMAT_BGRX8888, 1, 1, tcFlagsSRGB, "[BLACK_TEXID]", TEXTURE_GROUP_OTHER );
g_pShaderAPI->ModifyTexture( m_BlackTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
texel[0] = texel[1] = texel[2] = 0;
g_pShaderAPI->TexImage2D( 0, 0, IMAGE_FORMAT_BGRX8888, 0, 1, 1, IMAGE_FORMAT_BGRX8888, false, texel );
#else
m_BlackTextureHandle = ((ITextureInternal*)FindTexture( "black", TEXTURE_GROUP_OTHER, true ))->GetTextureHandle( 0 );
#endif
g_pShaderAPI->SetStandardTextureHandle( TEXTURE_BLACK, m_BlackTextureHandle );
// allocate a fully white single texel texture
#if !defined( _X360 )
m_WhiteTextureHandle = g_pShaderAPI->CreateTexture( 1, 1, 1, IMAGE_FORMAT_BGRX8888, 1, 1, tcFlagsSRGB, "[WHITE_TEXID]", TEXTURE_GROUP_OTHER );
g_pShaderAPI->ModifyTexture( m_WhiteTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
texel[0] = texel[1] = texel[2] = 255;
g_pShaderAPI->TexImage2D( 0, 0, IMAGE_FORMAT_BGRX8888, 0, 1, 1, IMAGE_FORMAT_BGRX8888, false, texel );
#else
m_WhiteTextureHandle = ((ITextureInternal*)FindTexture( "white", TEXTURE_GROUP_OTHER, true ))->GetTextureHandle( 0 );
#endif
g_pShaderAPI->SetStandardTextureHandle( TEXTURE_WHITE, m_WhiteTextureHandle );
// allocate a grey single texel texture with an alpha of zero (for mat_fullbright 2)
#if !defined( _X360 )
m_GreyTextureHandle = g_pShaderAPI->CreateTexture( 1, 1, 1, IMAGE_FORMAT_BGRX8888, 1, 1, tcFlagsSRGB, "[GREY_TEXID]", TEXTURE_GROUP_OTHER );
g_pShaderAPI->ModifyTexture( m_GreyTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
texel[0] = texel[1] = texel[2] = 128;
texel[3] = 255; // needs to be 255 so that mat_fullbright 2 stuff isn't translucent.
g_pShaderAPI->TexImage2D( 0, 0, IMAGE_FORMAT_BGRX8888, 0, 1, 1, IMAGE_FORMAT_BGRX8888, false, texel );
#else
m_GreyTextureHandle = ((ITextureInternal*)FindTexture( "grey", TEXTURE_GROUP_OTHER, true ))->GetTextureHandle( 0 );
#endif
g_pShaderAPI->SetStandardTextureHandle( TEXTURE_GREY, m_GreyTextureHandle );
// allocate a grey single texel texture with an alpha of zero (for mat_fullbright 2)
#if !defined( _X360 )
m_GreyAlphaZeroTextureHandle = g_pShaderAPI->CreateTexture( 1, 1, 1, IMAGE_FORMAT_RGBA8888, 1, 1, tcFlagsSRGB, "[GREYALPHAZERO_TEXID]", TEXTURE_GROUP_OTHER );
g_pShaderAPI->ModifyTexture( m_GreyAlphaZeroTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
texel[0] = texel[1] = texel[2] = 128;
texel[3] = 0; // needs to be 0 so that self-illum doens't affect mat_fullbright 2
g_pShaderAPI->TexImage2D( 0, 0, IMAGE_FORMAT_RGBA8888, 0, 1, 1, IMAGE_FORMAT_RGBA8888, false, texel );
texel[3] = 255; // set back to default value so we don't affect the rest of this code.'
#else
m_GreyAlphaZeroTextureHandle = ((ITextureInternal*)FindTexture( "greyalphazero", TEXTURE_GROUP_OTHER, true ))->GetTextureHandle( 0 );
#endif
g_pShaderAPI->SetStandardTextureHandle( TEXTURE_GREY_ALPHA_ZERO, m_GreyAlphaZeroTextureHandle );
// allocate a single texel flat normal texture lightmap
m_FlatNormalTextureHandle = g_pShaderAPI->CreateTexture( 1, 1, 1, IMAGE_FORMAT_BGRX8888, 1, 1, tcFlags, "[FLAT_NORMAL_TEXTURE]", TEXTURE_GROUP_OTHER );
g_pShaderAPI->ModifyTexture( m_FlatNormalTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
texel[0] = 255; // B
texel[1] = 127; // G
texel[2] = 127; // R
g_pShaderAPI->TexImage2D( 0, 0, IMAGE_FORMAT_BGRX8888, 0, 1, 1, IMAGE_FORMAT_BGRX8888, false, texel );
g_pShaderAPI->SetStandardTextureHandle( TEXTURE_NORMALMAP_FLAT, m_FlatNormalTextureHandle );
// allocate a single texel fullbright 1 lightmap for use with bump textures
m_FullbrightBumpedLightmapTextureHandle = g_pShaderAPI->CreateTexture( 1, 1, 1, IMAGE_FORMAT_BGRX8888, 1, 1, tcFlags, "[FULLBRIGHT_BUMPED_LIGHTMAP_TEXID]", TEXTURE_GROUP_LIGHTMAP );
g_pShaderAPI->ModifyTexture( m_FullbrightBumpedLightmapTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
float linearColor[3] = { nominal_lightmap_value, nominal_lightmap_value, nominal_lightmap_value };
unsigned char dummy[3];
ColorSpace::LinearToBumpedLightmap( linearColor, linearColor, linearColor, linearColor,
dummy, texel, dummy, dummy );
g_pShaderAPI->TexImage2D( 0, 0, IMAGE_FORMAT_BGRX8888, 0, 1, 1, IMAGE_FORMAT_BGRX8888, false, texel );
g_pShaderAPI->SetStandardTextureHandle( TEXTURE_LIGHTMAP_BUMPED_FULLBRIGHT, m_FullbrightBumpedLightmapTextureHandle );
{
int iGammaLookupFlags = tcFlags;
ImageFormat gammalookupfmt;
gammalookupfmt = IMAGE_FORMAT_I8;
// generate the linear->gamma conversion table texture.
{
const int LINEAR_TO_GAMMA_TABLE_WIDTH = 512;
m_LinearToGammaTableTextureHandle = g_pShaderAPI->CreateTexture( LINEAR_TO_GAMMA_TABLE_WIDTH, 1, 1, gammalookupfmt, 1, 1, iGammaLookupFlags, "[LINEAR_TO_GAMMA_LOOKUP_SRGBON_TEXID]", TEXTURE_GROUP_PIXEL_SHADERS );
g_pShaderAPI->ModifyTexture( m_LinearToGammaTableTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_S, SHADER_TEXWRAPMODE_CLAMP );
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_T, SHADER_TEXWRAPMODE_CLAMP );
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_U, SHADER_TEXWRAPMODE_CLAMP );
float pixelData[LINEAR_TO_GAMMA_TABLE_WIDTH]; //sometimes used as float, sometimes as uint8, sizeof(float) > sizeof(uint8)
for( int i = 0; i != LINEAR_TO_GAMMA_TABLE_WIDTH; ++i )
{
float fLookupResult = ((float)i) / ((float)(LINEAR_TO_GAMMA_TABLE_WIDTH - 1));
fLookupResult = g_pShaderAPI->LinearToGamma_HardwareSpecific( fLookupResult );
//do an extra srgb conversion because we'll be converting back on texture read
fLookupResult = g_pShaderAPI->LinearToGamma_HardwareSpecific( fLookupResult ); //that's right, linear->gamma->gamma2x so that that gamma->linear srgb read still ends up in gamma
int iColor = RoundFloatToInt( fLookupResult * 255.0f );
if( iColor > 255 )
iColor = 255;
((uint8 *)pixelData)[i] = (uint8)iColor;
}
g_pShaderAPI->TexImage2D( 0, 0, gammalookupfmt, 0, LINEAR_TO_GAMMA_TABLE_WIDTH, 1, gammalookupfmt, false, (void *)pixelData );
}
// generate the identity conversion table texture.
{
const int LINEAR_TO_GAMMA_IDENTITY_TABLE_WIDTH = 256;
m_LinearToGammaIdentityTableTextureHandle = g_pShaderAPI->CreateTexture( LINEAR_TO_GAMMA_IDENTITY_TABLE_WIDTH, 1, 1, gammalookupfmt, 1, 1, tcFlags, "[LINEAR_TO_GAMMA_LOOKUP_SRGBOFF_TEXID]", TEXTURE_GROUP_PIXEL_SHADERS );
g_pShaderAPI->ModifyTexture( m_LinearToGammaIdentityTableTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_S, SHADER_TEXWRAPMODE_CLAMP );
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_T, SHADER_TEXWRAPMODE_CLAMP );
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_U, SHADER_TEXWRAPMODE_CLAMP );
float pixelData[LINEAR_TO_GAMMA_IDENTITY_TABLE_WIDTH]; //sometimes used as float, sometimes as uint8, sizeof(float) > sizeof(uint8)
for( int i = 0; i != LINEAR_TO_GAMMA_IDENTITY_TABLE_WIDTH; ++i )
{
float fLookupResult = ((float)i) / ((float)(LINEAR_TO_GAMMA_IDENTITY_TABLE_WIDTH - 1));
//do an extra srgb conversion because we'll be converting back on texture read
fLookupResult = g_pShaderAPI->LinearToGamma_HardwareSpecific( fLookupResult );
int iColor = RoundFloatToInt( fLookupResult * 255.0f );
if ( iColor > 255 )
iColor = 255;
((uint8 *)pixelData)[i] = (uint8)iColor;
}
g_pShaderAPI->TexImage2D( 0, 0, gammalookupfmt, 0, LINEAR_TO_GAMMA_IDENTITY_TABLE_WIDTH, 1, gammalookupfmt, false, (void *)pixelData );
}
}
//create the maximum depth texture
{
m_MaxDepthTextureHandle = g_pShaderAPI->CreateTexture( 1, 1, 1, IMAGE_FORMAT_RGBA8888, 1, 1, tcFlags, "[MAXDEPTH_TEXID]", TEXTURE_GROUP_OTHER );
g_pShaderAPI->ModifyTexture( m_MaxDepthTextureHandle );
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
//360 gets depth out of the red channel (which doubles as depth in D24S8) and may be 0/1 depending on REVERSE_DEPTH_ON_X360
//PC gets depth out of the alpha channel
texel[0] = texel[1] = texel[2] = ReverseDepthOnX360() ? 0 : 255;
texel[3] = 255;
g_pShaderAPI->TexImage2D( 0, 0, IMAGE_FORMAT_RGBA8888, 0, 1, 1, IMAGE_FORMAT_RGBA8888, false, texel );
}
//only the shaderapi can handle switching between textures correctly, so pass off the textures to it.
g_pShaderAPI->SetLinearToGammaConversionTextures( m_LinearToGammaTableTextureHandle, m_LinearToGammaIdentityTableTextureHandle );
}
void CMaterialSystem::ReleaseStandardTextures()
{
if ( m_StandardTexturesAllocated )
{
if ( IsPC() )
{
g_pShaderAPI->DeleteTexture( m_BlackTextureHandle );
g_pShaderAPI->DeleteTexture( m_WhiteTextureHandle );
g_pShaderAPI->DeleteTexture( m_GreyTextureHandle );
g_pShaderAPI->DeleteTexture( m_GreyAlphaZeroTextureHandle );
}
g_pShaderAPI->DeleteTexture( m_FullbrightLightmapTextureHandle );
g_pShaderAPI->DeleteTexture( m_FlatNormalTextureHandle );
g_pShaderAPI->DeleteTexture( m_FullbrightBumpedLightmapTextureHandle );
g_pShaderAPI->DeleteTexture( m_LinearToGammaTableTextureHandle );
g_pShaderAPI->DeleteTexture( m_LinearToGammaIdentityTableTextureHandle );
g_pShaderAPI->SetLinearToGammaConversionTextures( INVALID_SHADERAPI_TEXTURE_HANDLE, INVALID_SHADERAPI_TEXTURE_HANDLE );
g_pShaderAPI->DeleteTexture( m_MaxDepthTextureHandle );
m_StandardTexturesAllocated = false;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CMaterialSystem::BeginFrame( float frameTime )
{
// Safety measure (calls should only come from the main thread, also check correct pairing)
if ( !ThreadInMainThread() || IsInFrame() )
return;
// check debug vars. we will use these to setup g_nDebugVarsSignature so that materials will
// rebuild their draw lists when debug modes changed.
g_nDebugVarsSignature = (
(mat_specular.GetInt() != 0 ) + ( mat_normalmaps.GetInt() << 1 ) +
( mat_fullbright.GetInt() << 2 ) + (mat_fastnobump.GetInt() << 4 ) ) << 24;
Assert( m_bGeneratedConfig );
VPROF_BUDGET( "CMaterialSystem::BeginFrame", VPROF_BUDGETGROUP_SWAP_BUFFERS );
tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );
IMatRenderContextInternal *pRenderContext = GetRenderContextInternal();
if ( g_config.ForceHWSync() && (IsPC() || m_ThreadMode != MATERIAL_QUEUED_THREADED) )
{
tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "ForceHardwareSync" );
pRenderContext->ForceHardwareSync();
}
pRenderContext->MarkRenderDataUnused( true );
pRenderContext->BeginFrame();
pRenderContext->SetFrameTime( frameTime );
pRenderContext->SetToneMappingScaleLinear( Vector( 1,1,1) );
Assert( !m_bInFrame );
m_bInFrame = true;
}
bool CMaterialSystem::IsInFrame( ) const
{
return m_bInFrame;
}
#ifdef RAD_TELEMETRY_ENABLED
static const char *GetMatString( enum MaterialThreadMode_t ThreadMode )
{
switch( ThreadMode )
{
case MATERIAL_SINGLE_THREADED: return "single";
case MATERIAL_QUEUED_SINGLE_THREADED: return "queued_single";
case MATERIAL_QUEUED_THREADED: return "queued_threaded";
default: return "???";
}
}
#endif
ConVar mat_queue_mode( "mat_queue_mode", "-1", FCVAR_ARCHIVE, "The queue/thread mode the material system should use: -1=default, 0=synchronous single thread"
#ifdef MAT_QUEUE_MODE_PROFILE
", 1=queued single thread"
#endif
", 2=queued multithreaded" );
ConVar mat_queue_report( "mat_queue_report", "0", FCVAR_ARCHIVE, "Report thread stalls. Positive number will filter by stalls >= time in ms. -1 reports all locks." );
void CMaterialSystem::ThreadExecuteQueuedContext( CMatQueuedRenderContext *pContext )
{
#ifdef RAD_TELEMETRY_ENABLED
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s-%s", __FUNCTION__, GetMatString( m_ThreadMode ) );
CTelemetrySpikeDetector Spike( "ThreadExecuteQueuedContext", 1 );
#endif
Assert( m_bThreadHasOwnership );
m_nRenderThreadID = ThreadGetCurrentId();
IMatRenderContextInternal* pSavedRenderContext = m_pRenderContext.Get();
m_pRenderContext.Set( &m_HardwareRenderContext );
pContext->EndQueue( true );
m_pRenderContext.Set( pSavedRenderContext );
amd64: fix multithread, fix vgui, fix physmodels
2022-06-05 06:44:42 +08:00
m_nRenderThreadID = (uintp)-1;
1
2020-04-23 00:56:21 +08:00
}
IThreadPool *CMaterialSystem::CreateMatQueueThreadPool()
{
if( IsX360() )
{
return g_pThreadPool;
}
else if( !m_pMatQueueThreadPool )
{
ThreadPoolStartParams_t startParams;
startParams.nThreads = 1;
startParams.nStackSize = 256*1024;
startParams.fDistribute = TRS_TRUE;
// The rendering thread has the GL context and the main thread is coming in and
// "helping" finish jobs - that breaks OpenGL, which requires TLS. This flag states
// that only the threadpool threads should execute these jobs.
startParams.bExecOnThreadPoolThreadsOnly = true;
m_pMatQueueThreadPool = CreateThreadPool();
m_pMatQueueThreadPool->Start( startParams, "MatQueue" );
}
return m_pMatQueueThreadPool;
}
void CMaterialSystem::DestroyMatQueueThreadPool()
{
if( m_pMatQueueThreadPool )
{
m_pMatQueueThreadPool->Stop();
delete m_pMatQueueThreadPool;
m_pMatQueueThreadPool = NULL;
}
}
//-----------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------
class CThreadAcquire : public CJob
{
virtual JobStatus_t DoExecute()
{
g_pShaderAPI->AcquireThreadOwnership();
return JOB_OK;
}
};
void CMaterialSystem::EndFrame( void )
{
// Safety measure (calls should only come from the main thread, also check correct pairing)
if ( !ThreadInMainThread() || !IsInFrame() )
return;
Assert( m_bGeneratedConfig );
VPROF_BUDGET( "CMaterialSystem::EndFrame", VPROF_BUDGETGROUP_SWAP_BUFFERS );
GetRenderContextInternal()->EndFrame();
TextureManager()->Update();
while ( !m_scheduledComposites.IsEmpty() )
{
// We hold a ref, so if there's only one count left, it's us. Let it go and move on.
if ( m_scheduledComposites[ 0 ]->GetRefCount() == 1 )
{
m_scheduledComposites[ 0 ]->Release();
m_scheduledComposites.Remove( 0 );
continue;
}
m_scheduledComposites[ 0 ]->Resolve();
m_pendingComposites.AddToTail( m_scheduledComposites[ 0 ] );
m_scheduledComposites.Remove( 0 );
// Only do one per frame, because these can actually be fairly expensive.
break;
}
FOR_EACH_VEC( m_pendingComposites, i )
{
CTextureCompositor* comp = m_pendingComposites[ i ];
// We hold a ref, so if there's only one count left, it's us. Let it go and move on.
if ( comp->GetRefCount() == 1 )
{
comp->Release();
m_pendingComposites.Remove( i );
// Back up one
--i;
continue;
}
comp->Update();
if ( comp->GetResolveStatus() == ECRS_Complete || comp->GetResolveStatus() == ECRS_Error )
{
comp->Release();
m_pendingComposites.Remove( i );
// Stop after the first one reports that it was completed, these can take awhile and
// we don't want to hammer anyone's framerate.
break;
}
}
//-------------------------------------------------------------
int iConVarThreadMode = mat_queue_mode.GetInt();
// For this testing release, -2 is equivalent to 0 (off). When we release, we'll make -2 equivalent to -1 (on)
if ( iConVarThreadMode == -2 )
{
iConVarThreadMode = MATERIAL_QUEUED_THREADED;
}
#ifndef MAT_QUEUE_MODE_PROFILE
if ( iConVarThreadMode == MATERIAL_QUEUED_SINGLE_THREADED )
{
iConVarThreadMode = MATERIAL_SINGLE_THREADED;
}
#endif
MaterialThreadMode_t nextThreadMode = ( iConVarThreadMode >= 0 ) ? (MaterialThreadMode_t)iConVarThreadMode : m_IdealThreadMode;
// note: This is a hack because there is no explicit query for the device being deactivated due to device lost.
// however, that is all the current implementation of CanDownloadTextures actually does.
bool bDeviceReady = g_pShaderAPI->CanDownloadTextures();
if ( !bDeviceReady || !m_bAllowQueuedRendering )
{
nextThreadMode = MATERIAL_SINGLE_THREADED;
}
if ( m_bForcedSingleThreaded || m_bThreadingNotAvailable )
{
nextThreadMode = MATERIAL_SINGLE_THREADED;
m_bForcedSingleThreaded = false;
}
switch ( m_ThreadMode )
{
case MATERIAL_SINGLE_THREADED:
OnRenderingAsyncComplete();
break;
case MATERIAL_QUEUED_THREADED:
{
VPROF_BUDGET( "Mat_ThreadedEndframe", "Mat_ThreadedEndframe" );
if ( !m_bThreadHasOwnership )
{
ThreadAcquire( true );
}
if ( m_pActiveAsyncJob && !m_pActiveAsyncJob->IsFinished() )
{
m_pActiveAsyncJob->WaitForFinish();
if ( !IsPC() && g_config.ForceHWSync() )
{
g_pShaderAPI->ForceHardwareSync();
}
}
SafeRelease( m_pActiveAsyncJob );
OnRenderingAsyncComplete();
CMatQueuedRenderContext *pPrevContext = &m_QueuedRenderContexts[m_iCurQueuedContext];
m_iCurQueuedContext = ( ( m_iCurQueuedContext + 1 ) % ARRAYSIZE( m_QueuedRenderContexts) );
m_QueuedRenderContexts[m_iCurQueuedContext].BeginQueue( pPrevContext );
m_pRenderContext.Set( &m_QueuedRenderContexts[m_iCurQueuedContext] );
m_pActiveAsyncJob = new CFunctorJob( CreateFunctor( this, &CMaterialSystem::ThreadExecuteQueuedContext, pPrevContext ), "ThreadExecuteQueuedContext" );
if ( IsX360() )
{
if ( m_nServiceThread >= 0 )
{
m_pActiveAsyncJob->SetServiceThread( m_nServiceThread );
}
}
IThreadPool *pThreadPool = CreateMatQueueThreadPool();
pThreadPool->AddJob( m_pActiveAsyncJob );
break;
}
case MATERIAL_QUEUED_SINGLE_THREADED:
OnRenderingAsyncComplete();
break;
#ifdef MAT_QUEUE_MODE_PROFILE
{
VPROF_BUDGET( "Mat_ThreadedEndframe", "Mat_QueuedEndframe" );
g_pShaderAPI->SetDisallowAccess( false );
m_pRenderContext.Set( &m_HardwareRenderContext );
m_QueuedRenderContexts[m_iCurQueuedContext].CallQueued();
m_pRenderContext.Set( &m_QueuedRenderContexts[m_iCurQueuedContext] );
g_pShaderAPI->SetDisallowAccess( true );
break;
}
#endif
}
bool bRelease = false;
if ( !bDeviceReady )
{
if ( nextThreadMode != MATERIAL_SINGLE_THREADED )
{
Assert( nextThreadMode == MATERIAL_SINGLE_THREADED );
bRelease = true;
nextThreadMode = MATERIAL_SINGLE_THREADED;
if( mat_debugalttab.GetBool() )
{
Warning("Handling alt-tab in queued mode!\n");
}
}
}
if ( m_threadEvents.Count() )
{
nextThreadMode = MATERIAL_SINGLE_THREADED;
}
if ( m_ThreadMode != nextThreadMode )
{
// Shut down the current mode & set new mode
switch ( m_ThreadMode )
{
case MATERIAL_SINGLE_THREADED:
break;
case MATERIAL_QUEUED_THREADED:
{
if ( m_pActiveAsyncJob )
{
m_pActiveAsyncJob->WaitForFinish();
SafeRelease( m_pActiveAsyncJob );
}
// probably have a queued context set here, need hardware to flush the queue if the job isn't active
m_HardwareRenderContext.InitializeFrom(&m_QueuedRenderContexts[m_iCurQueuedContext]);
m_pRenderContext.Set( &m_HardwareRenderContext );
m_QueuedRenderContexts[m_iCurQueuedContext].EndQueue( true );
ThreadRelease();
}
break;
#ifdef MAT_QUEUE_MODE_PROFILE
case MATERIAL_QUEUED_SINGLE_THREADED:
{
g_pShaderAPI->SetDisallowAccess( false );
// We have a queued context set here, need hardware to flush the queue if the job isn't active
m_pRenderContext.Set( &m_HardwareRenderContext );
m_QueuedRenderContexts[m_iCurQueuedContext].EndQueue( true );
break;
}
#endif
}
m_ThreadMode = nextThreadMode;
Assert( g_MatSysMutex.GetOwnerId() == 0 );
g_pShaderAPI->EnableShaderShaderMutex( m_ThreadMode != MATERIAL_SINGLE_THREADED ); // use mutex even for queued to allow "disalow access" to function properly
g_pShaderAPI->EnableBuffer2FramesAhead( true );
switch ( m_ThreadMode )
{
case MATERIAL_SINGLE_THREADED:
m_pRenderContext.Set( &m_HardwareRenderContext );
for ( int i = 0; i < ARRAYSIZE( m_QueuedRenderContexts ); i++ )
{
Assert( m_QueuedRenderContexts[i].IsInitialized() );
m_QueuedRenderContexts[i].EndQueue( true );
}
break;
#ifdef MAT_QUEUE_MODE_PROFILE
case MATERIAL_QUEUED_SINGLE_THREADED:
#endif
case MATERIAL_QUEUED_THREADED:
{
m_iCurQueuedContext = 0;
m_QueuedRenderContexts[m_iCurQueuedContext].BeginQueue( &m_HardwareRenderContext );
m_pRenderContext.Set( &m_QueuedRenderContexts[m_iCurQueuedContext] );
#ifdef MAT_QUEUE_MODE_PROFILE
if ( m_ThreadMode == MATERIAL_QUEUED_SINGLE_THREADED )
{
g_pShaderAPI->SetDisallowAccess( true );
}
else
#endif
{
g_pShaderAPI->ReleaseThreadOwnership();
CJob *pActiveAsyncJob = new CThreadAcquire();
IThreadPool *pThreadPool = CreateMatQueueThreadPool();
pThreadPool->AddJob( pActiveAsyncJob );
SafeRelease( pActiveAsyncJob );
m_bThreadHasOwnership = true;
m_ThreadOwnershipID = ThreadGetCurrentId();
}
}
break;
}
}
if ( m_ThreadMode == MATERIAL_SINGLE_THREADED )
{
for ( int i = 0; i < m_threadEvents.Count(); i++ )
{
g_pShaderDevice->HandleThreadEvent(m_threadEvents[i]);
}
m_threadEvents.RemoveAll();
}
Assert( m_bInFrame );
m_bInFrame = false;
}
void CMaterialSystem::SetInStubMode( bool bInStubMode )
{
m_bInStubMode = bInStubMode;
}
bool CMaterialSystem::IsInStubMode()
{
return m_bInStubMode;
}
void CMaterialSystem::Flush( bool flushHardware )
{
GetRenderContextInternal()->Flush( flushHardware );
}
//-----------------------------------------------------------------------------
// Flushes managed textures from the texture cacher
//-----------------------------------------------------------------------------
void CMaterialSystem::EvictManagedResources()
{
g_pShaderAPI->EvictManagedResources();
}
int __cdecl MaterialNameCompareFunc( const void *elem1, const void *elem2 )
{
IMaterialInternal *pMaterialA = g_MaterialSystem.GetMaterialInternal( *(MaterialHandle_t *)elem1 );
IMaterialInternal *pMaterialB = g_MaterialSystem.GetMaterialInternal( *(MaterialHandle_t *)elem2 );
// case insensitive to group similar named materials
return stricmp( pMaterialA->GetName(), pMaterialB->GetName() );
}
void CMaterialSystem::DebugPrintUsedMaterials( const char *pSearchSubString, bool bVerbose )
{
MaterialHandle_t h;
int i;
int nNumCached;
int nRefCount;
int nSortedMaterials;
int nNumErrors;
// build a mapping to sort the material names
MaterialHandle_t *pSorted = (MaterialHandle_t*)stackalloc( GetNumMaterials() * sizeof(MaterialHandle_t) );
nSortedMaterials = 0;
for (h = FirstMaterial(); h != InvalidMaterial(); h = NextMaterial(h) )
{
pSorted[nSortedMaterials++] = h;
}
qsort( pSorted, nSortedMaterials, sizeof(MaterialHandle_t), MaterialNameCompareFunc );
nNumCached = 0;
nNumErrors = 0;
for (i = 0; i < nSortedMaterials; i++)
{
// iterate using sort mapping
IMaterialInternal *pMaterial = GetMaterialInternal(pSorted[i]);
nRefCount = pMaterial->GetReferenceCount();
if ( nRefCount < 0 )
{
nNumErrors++;
}
else if (!nRefCount)
{
if (pMaterial->IsPrecached() || pMaterial->IsPrecachedVars())
{
nNumErrors++;
}
}
else
{
// nonzero reference count
// tally the valid ones
nNumCached++;
if( pSearchSubString )
{
if( !Q_stristr( pMaterial->GetName(), pSearchSubString ) &&
(!pMaterial->GetShader() || !Q_stristr( pMaterial->GetShader()->GetName(), pSearchSubString )) )
{
continue;
}
}
DevMsg( "%s (shader: %s) refCount: %d.\n", pMaterial->GetName(),
pMaterial->GetShader() ? pMaterial->GetShader()->GetName() : "unknown\n", nRefCount );
if( !bVerbose )
{
continue;
}
if( pMaterial->IsPrecached() )
{
if( pMaterial->GetShader() )
{
for( int j = 0; j < pMaterial->GetShader()->GetNumParams(); j++ )
{
IMaterialVar *var;
var = pMaterial->GetShaderParams()[j];
if( var )
{
switch( var->GetType() )
{
case MATERIAL_VAR_TYPE_TEXTURE:
{
ITextureInternal *texture = static_cast<ITextureInternal *>( var->GetTextureValue() );
if( !texture )
{
DevWarning( "Programming error: CMaterialSystem::DebugPrintUsedMaterialsCallback: NULL texture\n" );
continue;
}
if( IsTextureInternalEnvCubemap( texture ) )
{
DevMsg( " \"%s\" \"env_cubemap\"\n", var->GetName() );
}
else
{
DevMsg( " \"%s\" \"%s\"\n",
var->GetName(),
texture->GetName() );
DevMsg( " %dx%d refCount: %d numframes: %d\n", texture->GetActualWidth(), texture->GetActualHeight(),
texture->GetReferenceCount(), texture->GetNumAnimationFrames() );
}
}
break;
case MATERIAL_VAR_TYPE_UNDEFINED:
break;
default:
DevMsg( " \"%s\" \"%s\"\n", var->GetName(), var->GetStringValue() );
break;
}
}
}
}
}
}
}
// list the critical errors after, otherwise the console log scrolls them away
if (nNumErrors)
{
for (i = 0; i < nSortedMaterials; i++)
{
// iterate using sort mapping
IMaterialInternal *pMaterial = GetMaterialInternal(pSorted[i]);
nRefCount = pMaterial->GetReferenceCount();
if ( nRefCount < 0 )
{
// reference counts should not be negative
DevWarning( "DebugPrintUsedMaterials: refCount (%d) < 0 for material: \"%s\"\n",
nRefCount, pMaterial->GetName() );
}
else if (!nRefCount)
{
// ensure that it stayed uncached after the post loading uncache
// this is effectively a coding bug thats needs to be fixed
// a material is being precached without incrementing its reference
if (pMaterial->IsPrecached() || pMaterial->IsPrecachedVars())
{
DevWarning( "DebugPrintUsedMaterials: material: \"%s\" didn't unache\n",
pMaterial->GetName() );
}
}
}
DevWarning( "%d Errors\n", nNumErrors );
}
if (!pSearchSubString)
{
DevMsg( "%d Cached, %d Total Materials\n", nNumCached, GetNumMaterials() );
}
}
void CMaterialSystem::DebugPrintUsedTextures( void )
{
TextureManager()->DebugPrintUsedTextures();
}
#if defined( _X360 )
void CMaterialSystem::ListUsedMaterials( void )
{
int numMaterials = GetNumMaterials();
xMaterialList_t* pMaterialList = (xMaterialList_t *)stackalloc( numMaterials * sizeof( xMaterialList_t ) );
numMaterials = 0;
for ( MaterialHandle_t hMaterial = FirstMaterial(); hMaterial != InvalidMaterial(); hMaterial = NextMaterial( hMaterial ) )
{
IMaterialInternal *pMaterial = GetMaterialInternal( hMaterial );
pMaterialList[numMaterials].pName = pMaterial->GetName();
pMaterialList[numMaterials].pShaderName = pMaterial->GetShader() ? pMaterial->GetShader()->GetName() : "???";
pMaterialList[numMaterials].refCount = pMaterial->GetReferenceCount();
numMaterials++;
}
XBX_rMaterialList( numMaterials, pMaterialList );
}
#endif
void CMaterialSystem::ToggleSuppressMaterial( char const* pMaterialName )
{
/*
// This version suppresses all but the material
IMaterial *pMaterial = GetFirstMaterial();
while (pMaterial)
{
if (stricmp(pMaterial->GetName(), pMaterialName))
{
IMaterialInternal* pMatInt = static_cast<IMaterialInternal*>(pMaterial);
pMatInt->ToggleSuppression();
}
pMaterial = GetNextMaterial();
}
*/
// Note: if we use this function a lot, we'll want to do something else, like have them
// pass in a texture group or reuse whatever texture group the material already had.
// As it is, this is rarely used, so if it's not in TEXTURE_GROUP_OTHER, it'll go in
// TEXTURE_GROUP_SHARED.
IMaterial* pMaterial = FindMaterial( pMaterialName, TEXTURE_GROUP_OTHER, true, NULL );
if ( !IsErrorMaterial( pMaterial ) )
{
IMaterialInternal* pMatInt = static_cast<IMaterialInternal*>(pMaterial);
pMatInt = pMatInt->GetRealTimeVersion(); //always work with the realtime material internally
pMatInt->ToggleSuppression();
}
}
void CMaterialSystem::ToggleDebugMaterial( char const* pMaterialName )
{
// Note: if we use this function a lot, we'll want to do something else, like have them
// pass in a texture group or reuse whatever texture group the material already had.
// As it is, this is rarely used, so if it's not in TEXTURE_GROUP_OTHER, it'll go in
// TEXTURE_GROUP_SHARED.
IMaterial* pMaterial = FindMaterial( pMaterialName, TEXTURE_GROUP_OTHER, false, NULL );
if ( !IsErrorMaterial( pMaterial ) )
{
IMaterialInternal* pMatInt = static_cast<IMaterialInternal*>(pMaterial);
pMatInt = pMatInt->GetRealTimeVersion(); //always work with the realtime material internally
pMatInt->ToggleDebugTrace();
}
else
{
Warning("Unknown material %s\n", pMaterialName );
}
}
//-----------------------------------------------------------------------------
// Used to iterate over all shaders for editing purposes
//-----------------------------------------------------------------------------
int CMaterialSystem::ShaderCount() const
{
return ShaderSystem()->ShaderCount();
}
int CMaterialSystem::GetShaders( int nFirstShader, int nMaxCount, IShader **ppShaderList ) const
{
return ShaderSystem()->GetShaders( nFirstShader, nMaxCount, ppShaderList );
}
//-----------------------------------------------------------------------------
// FIXME: Is there a better way of doing this?
// Returns shader flag names for editors to be able to edit them
//-----------------------------------------------------------------------------
int CMaterialSystem::ShaderFlagCount() const
{
return ShaderSystem()->ShaderStateCount( );
}
const char *CMaterialSystem::ShaderFlagName( int nIndex ) const
{
return ShaderSystem()->ShaderStateString( nIndex );
}
//-----------------------------------------------------------------------------
// Returns the currently active shader fallback for a particular shader
//-----------------------------------------------------------------------------
void CMaterialSystem::GetShaderFallback( const char *pShaderName, char *pFallbackShader, int nFallbackLength )
{
// FIXME: This is pretty much a hack. We need a better way for the
// editor to get ahold of shader fallbacks
int nCount = ShaderCount();
IShader** ppShaderList = (IShader**)_alloca( nCount * sizeof(IShader) );
GetShaders( 0, nCount, ppShaderList );
do
{
int i;
for ( i = 0; i < nCount; ++i )
{
if ( !Q_stricmp( pShaderName, ppShaderList[i]->GetName() ) )
break;
}
// Didn't find a match!
if ( i == nCount )
{
Q_strncpy( pFallbackShader, "wireframe", nFallbackLength );
return;
}
// Found a match
// FIXME: Theoretically, getting fallbacks should require a param list
// In practice, it looks rare or maybe even neved done
const char *pFallback = ppShaderList[i]->GetFallbackShader( NULL );
if ( !pFallback )
{
Q_strncpy( pFallbackShader, pShaderName, nFallbackLength );
return;
}
else
{
pShaderName = pFallback;
}
} while (true);
}
//-----------------------------------------------------------------------------
// Triggers OpenGL shader preloading at game startup
//-----------------------------------------------------------------------------
#ifdef DX_TO_GL_ABSTRACTION
void CMaterialSystem::DoStartupShaderPreloading( void )
{
GetRenderContextInternal()->DoStartupShaderPreloading();
}
#endif
void CMaterialSystem::SwapBuffers( void )
{
VPROF_BUDGET( "CMaterialSystem::SwapBuffers", VPROF_BUDGETGROUP_SWAP_BUFFERS );
GetRenderContextInternal()->SwapBuffers();
g_FrameNum++;
}
bool CMaterialSystem::InEditorMode() const
{
Assert( m_bGeneratedConfig );
return g_config.bEditMode && CanUseEditorMaterials();
}
void CMaterialSystem::NoteAnisotropicLevel( int currentLevel )
{
Assert( m_bGeneratedConfig );
g_config.m_nForceAnisotropicLevel = currentLevel;
}
// Get the current config for this video card (as last set by control panel or the default if not)
const MaterialSystem_Config_t &CMaterialSystem::GetCurrentConfigForVideoCard() const
{
Assert( m_bGeneratedConfig );
return g_config;
}
// Does the device support the given MSAA level?
bool CMaterialSystem::SupportsMSAAMode( int nNumSamples )
{
return g_pShaderAPI->SupportsMSAAMode( nNumSamples );
}
void CMaterialSystem::ReloadFilesInList( IFileList *pFilesToReload )
{
if ( !IsPC() )
return;
// We have to flush the materials in 2 steps because they have recursive dependencies. The problem case
// is if you have two materials, A and B, that depend on C. You tell A to reload and it also reloads C. Then
// the filesystem thinks C doesn't need to be reloaded anymore. So when you get to B, it decides not to reload
// either since C doesn't need to be reloaded. To fix this, we ask all materials if they want to reload in
// one stage, then in the next stage we actually reload the appropriate ones.
MaterialHandle_t hNext;
for ( MaterialHandle_t h=m_MaterialDict.FirstMaterial(); h != m_MaterialDict.InvalidMaterial(); h=hNext )
{
hNext = m_MaterialDict.NextMaterial( h );
IMaterialInternal *pMat = m_MaterialDict.GetMaterialInternal( h );
pMat->DecideShouldReloadFromWhitelist( pFilesToReload );
}
// Now reload the materials that wanted to be reloaded.
for ( MaterialHandle_t h=m_MaterialDict.FirstMaterial(); h != m_MaterialDict.InvalidMaterial(); h=hNext )
{
hNext = m_MaterialDict.NextMaterial( h );
IMaterialInternal *pMat = m_MaterialDict.GetMaterialInternal( h );
pMat->ReloadFromWhitelistIfMarked();
}
// Flush out necessary textures.
TextureManager()->ReloadFilesInList( pFilesToReload );
}
// Does the device support the given CSAA level?
bool CMaterialSystem::SupportsCSAAMode( int nNumSamples, int nQualityLevel )
{
return g_pShaderAPI->SupportsCSAAMode( nNumSamples, nQualityLevel );
}
// Does the device support shadow depth texturing?
bool CMaterialSystem::SupportsShadowDepthTextures( void )
{
return g_pShaderAPI->SupportsShadowDepthTextures();
}
// Does the device support Fetch4
bool CMaterialSystem::SupportsFetch4( void )
{
return g_pShaderAPI->SupportsFetch4();
}
// Vendor-dependent shadow depth texture format
ImageFormat CMaterialSystem::GetShadowDepthTextureFormat( void )
{
return g_pShaderAPI->GetShadowDepthTextureFormat();
}
// Vendor-dependent slim texture format
ImageFormat CMaterialSystem::GetNullTextureFormat( void )
{
return g_pShaderAPI->GetNullTextureFormat();
}
void CMaterialSystem::SetShadowDepthBiasFactors( float fShadowSlopeScaleDepthBias, float fShadowDepthBias )
{
g_pShaderAPI->SetShadowDepthBiasFactors( fShadowSlopeScaleDepthBias, fShadowDepthBias );
}
bool CMaterialSystem::SupportsHDRMode( HDRType_t nHDRMode )
{
return HardwareConfig()->SupportsHDRMode( nHDRMode );
}
bool CMaterialSystem::UsesSRGBCorrectBlending( void ) const
{
return HardwareConfig()->UsesSRGBCorrectBlending();
}
// Get video card identitier
const MaterialSystemHardwareIdentifier_t &CMaterialSystem::GetVideoCardIdentifier( void ) const
{
static MaterialSystemHardwareIdentifier_t foo;
Assert( 0 );
return foo;
}
void CMaterialSystem::AddModeChangeCallBack( ModeChangeCallbackFunc_t func )
{
g_pShaderDeviceMgr->AddModeChangeCallback( func );
}
void CMaterialSystem::RemoveModeChangeCallBack( ModeChangeCallbackFunc_t func )
{
g_pShaderDeviceMgr->RemoveModeChangeCallback( func );
}
//-----------------------------------------------------------------------------
// Gets configuration information associated with the display card, and optionally for a particular DX level.
// It will return a list of ConVars and values to set.
//-----------------------------------------------------------------------------
bool CMaterialSystem::GetRecommendedConfigurationInfo( int nDXLevel, KeyValues *pKeyValues )
{
MaterialLock_t hLock = Lock();
bool bResult = g_pShaderDeviceMgr->GetRecommendedConfigurationInfo( m_nAdapter, nDXLevel, pKeyValues );
Unlock( hLock );
return bResult;
}
//-----------------------------------------------------------------------------
// For dealing with device lost in cases where SwapBuffers isn't called all the time (Hammer)
//-----------------------------------------------------------------------------
void CMaterialSystem::HandleDeviceLost()
{
if ( IsX360() )
return;
g_pShaderAPI->HandleDeviceLost();
}
bool CMaterialSystem::UsingFastClipping( void )
{
return (HardwareConfig()->UseFastClipping() || (HardwareConfig()->MaxUserClipPlanes() < 1));
};
int CMaterialSystem::StencilBufferBits( void )
{
return HardwareConfig()->StencilBufferBits();
}
ITexture* CMaterialSystem::CreateRenderTargetTexture(
int w,
int h,
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change).
ImageFormat format,
MaterialRenderTargetDepth_t depth )
{
return CreateNamedRenderTargetTextureEx( NULL, w, h, sizeMode, format, depth, TEXTUREFLAGS_CLAMPS|TEXTUREFLAGS_CLAMPT, 0 );
}
ITexture* CMaterialSystem::CreateNamedRenderTargetTexture(
const char *pRTName,
int w,
int h,
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change).
ImageFormat format,
MaterialRenderTargetDepth_t depth,
bool bClampTexCoords,
bool bAutoMipMap )
{
unsigned int textureFlags = 0;
if ( bClampTexCoords )
{
textureFlags |= TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT;
}
unsigned int renderTargetFlags = 0;
if ( bAutoMipMap )
{
renderTargetFlags |= CREATERENDERTARGETFLAGS_AUTOMIPMAP;
}
return CreateNamedRenderTargetTextureEx( pRTName, w, h, sizeMode, format, depth, textureFlags, renderTargetFlags );
}
ITexture* CMaterialSystem::CreateNamedRenderTargetTextureEx(
const char *pRTName,
int w,
int h,
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change).
ImageFormat format,
MaterialRenderTargetDepth_t depth,
unsigned int textureFlags,
unsigned int renderTargetFlags )
{
RenderTargetType_t rtType;
bool gl_canMixTargetSizes = (HardwareConfig() && HardwareConfig()->SupportsGLMixedSizeTargets());
// On GL, the depth buffer for a render target must be the same size (until we pick up mixed-sized attachments in 10.6.3)
if ( (!gl_canMixTargetSizes && IsPosix()) || IsEmulatingGL() )
{
if ( depth != MATERIAL_RT_DEPTH_SEPARATE && depth != MATERIAL_RT_DEPTH_NONE )
{
int fbWidth, fbHeight;
g_pShaderAPI->GetBackBufferDimensions( fbWidth, fbHeight );
if ( sizeMode != RT_SIZE_FULL_FRAME_BUFFER )
{
if ( w != fbWidth || h != fbHeight )
{
depth = MATERIAL_RT_DEPTH_SEPARATE;
}
}
}
}
// Determine RT type based on depth buffer requirements
switch ( depth )
{
case MATERIAL_RT_DEPTH_SEPARATE:
// using own depth buffer
rtType = RENDER_TARGET_WITH_DEPTH;
break;
case MATERIAL_RT_DEPTH_NONE:
// no depth buffer
rtType = RENDER_TARGET_NO_DEPTH;
break;
case MATERIAL_RT_DEPTH_ONLY:
// only depth buffer
rtType = RENDER_TARGET_ONLY_DEPTH;
break;
case MATERIAL_RT_DEPTH_SHARED:
default:
// using shared depth buffer
rtType = RENDER_TARGET;
break;
}
ITextureInternal* pTex = TextureManager()->CreateRenderTargetTexture( pRTName, w, h, sizeMode, format, rtType, textureFlags, renderTargetFlags );
pTex->IncrementReferenceCount();
#if defined( _X360 )
if ( !( renderTargetFlags & CREATERENDERTARGETFLAGS_NOEDRAM ) )
{
// create the EDRAM surface that is bound to the RT Texture
pTex->CreateRenderTargetSurface( 0, 0, IMAGE_FORMAT_UNKNOWN, true );
}
#endif
// If we're not in a BeginRenderTargetAllocation-EndRenderTargetAllocation block
// because we're being called by a legacy path (i.e. a mod), force an Alt-Tab after every
// RT allocation to ensure that all RTs get priority during allocation
if ( !m_bAllocatingRenderTargets )
{
EndRenderTargetAllocation();
}
return pTex;
}
//-----------------------------------------------------------------------------------------------------
// New version which must be called inside BeginRenderTargetAllocation-EndRenderTargetAllocation block
//-----------------------------------------------------------------------------------------------------
ITexture *CMaterialSystem::CreateNamedRenderTargetTextureEx2(
const char *pRTName,
int w,
int h,
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change).
ImageFormat format,
MaterialRenderTargetDepth_t depth,
unsigned int textureFlags,
unsigned int renderTargetFlags )
{
// Only proceed if we are between BeginRenderTargetAllocation and EndRenderTargetAllocation
if ( !m_bAllocatingRenderTargets )
{
Warning( "Tried to create render target outside of CMaterialSystem::BeginRenderTargetAllocation/EndRenderTargetAllocation block\n" );
return NULL;
}
ITexture* pTexture = CreateNamedRenderTargetTextureEx( pRTName, w, h, sizeMode, format, depth, textureFlags, renderTargetFlags );
pTexture->DecrementReferenceCount(); // Follow the same convention as CTextureManager::LoadTexture (return refcount of 0).
return pTexture;
}
class CTextureBitsRegenerator : public ITextureRegenerator
{
public:
CTextureBitsRegenerator( int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits )
: m_nWidth( w )
, m_nHeight( h )
, m_nMipmaps( mips )
, m_ImageFormat( fmt )
{
Assert( srcBits );
Assert( srcBufferSize > 0 );
Assert( m_nMipmaps != 0 );
// If these fail, we'll crash later, so look to before here for the problem.
Assert( ImageLoader::GetMemRequired( w, h, 1, fmt, m_nMipmaps > 1 ? true : false ) <= srcBufferSize );
Assert( m_nMipmaps == 1 || m_nMipmaps == ImageLoader::GetNumMipMapLevels( m_nWidth, m_nHeight, 1 ) );
m_ImageData.EnsureCapacity( srcBufferSize );
Q_memcpy( m_ImageData.Base(), srcBits, srcBufferSize );
}
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect )
{
Assert( pVTFTexture->FrameCount() == 1 );
Assert( pVTFTexture->FaceCount() == 1 );
int destWidth, destHeight, destDepth;
pVTFTexture->ComputeMipLevelDimensions( 0, &destWidth, &destHeight, &destDepth );
Assert( destDepth == 1 );
Assert( destWidth <= m_nWidth && destHeight <= m_nHeight );
unsigned char* pDest = pVTFTexture->ImageData();
ImageFormat destFmt = pVTFTexture->Format();
if ( destFmt == m_ImageFormat && destWidth == m_nWidth && destHeight == m_nHeight )
{
Q_memcpy( pDest, m_ImageData.Base(), m_ImageData.NumAllocated() );
}
else
{
int srcResX = m_nWidth;
int srcResY = m_nHeight;
int srcOffset = 0;
int dstOffset = 0;
int mip = 0;
// Skip the mips we're not including.
while ( mip < m_nMipmaps && ( srcResX > destWidth || srcResY > destHeight ) )
{
srcOffset += ImageLoader::GetMemRequired( srcResX, srcResY, 1, m_ImageFormat, false );
srcResX = Max( 1, ( srcResX >> 1 ) );
srcResY = Max( 1, ( srcResY >> 1 ) );
mip++;
}
// Assert we're where we expect to be now.
Assert( srcResX == destWidth && srcResY == destHeight );
for ( ; mip < m_nMipmaps; ++mip )
{
// Convert this mipmap level.
ImageLoader::ConvertImageFormat( m_ImageData.Base() + srcOffset, m_ImageFormat, pDest + dstOffset, destFmt, srcResX, srcResY );
// Then update offsets for the next mipmap level.
srcOffset += ImageLoader::GetMemRequired( srcResX, srcResY, 1, m_ImageFormat, false );
dstOffset += ImageLoader::GetMemRequired( srcResX, srcResY, 1, destFmt, false );
srcResX = Max( 1, ( srcResX >> 1 ) );
srcResY = Max( 1, ( srcResY >> 1 ) );
}
}
}
virtual void Release()
{
delete this;
}
private:
int m_nWidth;
int m_nHeight;
int m_nMipmaps;
ImageFormat m_ImageFormat;
CUtlMemory<byte> m_ImageData;
};
ITexture* CMaterialSystem::CreateTextureFromBits(int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits)
{
int flags = TEXTUREFLAGS_SINGLECOPY
| ( mips > 1
? TEXTUREFLAGS_ALL_MIPS
: TEXTUREFLAGS_NOMIP )
;
return CreateNamedTextureFromBitsEx( "frombits", TEXTURE_GROUP_OTHER, w, h, mips, fmt, srcBufferSize, srcBits, flags );
}
void CMaterialSystem::OverrideRenderTargetAllocation( bool rtAlloc )
{
m_bAllocatingRenderTargets = rtAlloc;
}
ITextureCompositor* CMaterialSystem::NewTextureCompositor( int w, int h, const char* pCompositeName, int nTeamNum, uint64 randomSeed, KeyValues* stageDesc, uint32 texCompositeCreateFlags )
{
return CreateTextureCompositor( w, h, pCompositeName, nTeamNum, randomSeed, stageDesc, texCompositeCreateFlags );
}
void CMaterialSystem::ScheduleTextureComposite( CTextureCompositor* _texCompositor )
{
Assert( _texCompositor != NULL );
_texCompositor->AddRef();
m_scheduledComposites.AddToTail( _texCompositor );
}
void CMaterialSystem::AsyncFindTexture( const char* pFilename, const char *pTextureGroupName, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs, bool bComplain, int nAdditionalCreationFlags )
{
Assert( pFilename != NULL );
Assert( pTextureGroupName != NULL );
Assert( pRecipient != NULL );
// Bump the ref count on the recipient before handing it off. This ensures the receiver won't go away before we have completed our work.
pRecipient->AddRef();
TextureManager()->AsyncFindOrLoadTexture( pFilename, pTextureGroupName, pRecipient, pExtraArgs, bComplain, nAdditionalCreationFlags );
}
// creates a texture suitable for use with materials from a raw stream of bits.
// The bits will be retained by the material system and can be freed upon return.
ITexture *CMaterialSystem::CreateNamedTextureFromBitsEx( const char* pName, const char *pTextureGroupName, int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits, int nFlags )
{
Assert( srcBits );
CTextureBitsRegenerator* regen = new CTextureBitsRegenerator( w, h, mips, fmt, srcBufferSize, srcBits );
ITextureInternal* tex = TextureManager()->CreateProceduralTexture( pName, pTextureGroupName, w, h, 1, fmt, nFlags, regen );
return tex;
}
bool CMaterialSystem::AddTextureCompositorTemplate( const char* pName, KeyValues* pTmplDesc, int /* nTexCompositeTemplateFlags */ )
{
// Flags are currently unused, but added for futureproofing.
return TextureManager()->AddTextureCompositorTemplate( pName, pTmplDesc );
}
bool CMaterialSystem::VerifyTextureCompositorTemplates()
{
return TextureManager()->VerifyTextureCompositorTemplates();
}
void CMaterialSystem::BeginRenderTargetAllocation( void )
{
g_pShaderAPI->FlushBufferedPrimitives();
m_bAllocatingRenderTargets = true;
}
void CMaterialSystem::EndRenderTargetAllocation( void )
{
// Any GPU newer than 2005 doesn't need to do this, and it eats up ~40% of our level load time!
const bool cbRequiresRenderTargetAllocationFirst = mat_requires_rt_alloc_first.GetBool();
g_pShaderAPI->FlushBufferedPrimitives();
m_bAllocatingRenderTargets = false;
if ( IsPC() && cbRequiresRenderTargetAllocationFirst && g_pShaderAPI->CanDownloadTextures() )
{
// Simulate an Alt-Tab...will cause RTs to be allocated first
g_pShaderDevice->ReleaseResources();
g_pShaderDevice->ReacquireResources();
}
TextureManager()->CacheExternalStandardRenderTargets();
}
void CMaterialSystem::SetRenderTargetFrameBufferSizeOverrides( int nWidth, int nHeight )
{
m_nRenderTargetFrameBufferWidthOverride = nWidth;
m_nRenderTargetFrameBufferHeightOverride = nHeight;
}
void CMaterialSystem::GetRenderTargetFrameBufferDimensions( int & nWidth, int & nHeight )
{
if( m_nRenderTargetFrameBufferHeightOverride && m_nRenderTargetFrameBufferWidthOverride )
{
nWidth = m_nRenderTargetFrameBufferWidthOverride;
nHeight = m_nRenderTargetFrameBufferHeightOverride;
}
else
{
GetBackBufferDimensions( nWidth, nHeight );
}
}
//-----------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------
void CMaterialSystem::UpdateLightmap( int lightmapPageID, int lightmapSize[2],
int offsetIntoLightmapPage[2],
float *pFloatImage, float *pFloatImageBump1,
float *pFloatImageBump2, float *pFloatImageBump3 )
{
CMatCallQueue *pCallQueue = GetRenderCallQueue();
if ( !pCallQueue )
{
m_Lightmaps.UpdateLightmap( lightmapPageID, lightmapSize, offsetIntoLightmapPage, pFloatImage, pFloatImageBump1, pFloatImageBump2, pFloatImageBump3 );
}
else
{
ExecuteOnce( DebuggerBreakIfDebugging() );
}
}
//-----------------------------------------------------------------------------------------------------
// 360 TTF Font Support
//-----------------------------------------------------------------------------------------------------
#if defined( _X360 )
HXUIFONT CMaterialSystem::OpenTrueTypeFont( const char *pFontname, int tall, int style )
{
MaterialLock_t hLock = Lock();
HXUIFONT result = g_pShaderAPI->OpenTrueTypeFont( pFontname, tall, style );
Unlock( hLock );
return result;
}
void CMaterialSystem::CloseTrueTypeFont( HXUIFONT hFont )
{
MaterialLock_t hLock = Lock();
g_pShaderAPI->CloseTrueTypeFont( hFont );
Unlock( hLock );
}
bool CMaterialSystem::GetTrueTypeFontMetrics( HXUIFONT hFont, XUIFontMetrics *pFontMetrics, XUICharMetrics charMetrics[256] )
{
MaterialLock_t hLock = Lock();
bool result = g_pShaderAPI->GetTrueTypeFontMetrics( hFont, pFontMetrics, charMetrics );
Unlock( hLock );
return result;
}
bool CMaterialSystem::GetTrueTypeGlyphs( HXUIFONT hFont, int numChars, wchar_t *pWch, int *pOffsetX, int *pOffsetY, int *pWidth, int *pHeight, unsigned char *pRGBA, int *pRGBAOffset )
{
MaterialLock_t hLock = Lock();
bool result = g_pShaderAPI->GetTrueTypeGlyphs( hFont, numChars, pWch, pOffsetX, pOffsetY, pWidth, pHeight, pRGBA, pRGBAOffset );
Unlock( hLock );
return result;
}
#endif
//-----------------------------------------------------------------------------------------------------
// 360 Back Buffer access. Due to hardware, RT data must be blitted from EDRAM
// and converted.
//-----------------------------------------------------------------------------------------------------
#if defined( _X360 )
void CMaterialSystem::ReadBackBuffer( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *pDstData, ImageFormat dstFormat, int dstStride )
{
Assert( pSrcRect && pDstRect && pDstData );
int fbWidth, fbHeight;
g_pShaderAPI->GetBackBufferDimensions( fbWidth, fbHeight );
if ( pDstRect->width > fbWidth || pDstRect->height > fbHeight )
{
Assert( 0 );
return;
}
// intermediate results will be placed at (0,0)
Rect_t rect;
rect.x = 0;
rect.y = 0;
rect.width = pDstRect->width;
rect.height = pDstRect->height;
ITexture *pTempRT;
bool bStretch = ( pSrcRect->width != pDstRect->width || pSrcRect->height != pDstRect->height );
if ( !bStretch )
{
// hijack an unused RT (no surface required) for 1:1 resolve work, fastest path
pTempRT = FindTexture( "_rt_FullFrameFB", TEXTURE_GROUP_RENDER_TARGET );
}
else
{
// hijack an unused RT (with surface abilities) for stretch work, slower path
pTempRT = FindTexture( "_rt_WaterReflection", TEXTURE_GROUP_RENDER_TARGET );
}
Assert( !pTempRT->IsError() && pDstRect->width <= pTempRT->GetActualWidth() && pDstRect->height <= pTempRT->GetActualHeight() );
GetRenderContextInternal()->CopyRenderTargetToTextureEx( pTempRT, 0, pSrcRect, &rect );
// access the RT bits
CPixelWriter writer;
g_pShaderAPI->ModifyTexture( ((ITextureInternal*)pTempRT)->GetTextureHandle( 0 ) );
if ( !g_pShaderAPI->TexLock( 0, 0, 0, 0, pTempRT->GetActualWidth(), pTempRT->GetActualHeight(), writer ) )
return;
// this will be adequate for non-block formats
int srcStride = pTempRT->GetActualWidth() * ImageLoader::SizeInBytes( pTempRT->GetImageFormat() );
// untile intermediate RT in place to achieve linear access
XGUntileTextureLevel(
pTempRT->GetActualWidth(),
pTempRT->GetActualHeight(),
0,
XGGetGpuFormat( ImageLoader::ImageFormatToD3DFormat( pTempRT->GetImageFormat() ) ),
0,
(char*)writer.GetPixelMemory(),
srcStride,
NULL,
writer.GetPixelMemory(),
NULL );
// swap back to x86 order as expected by image conversion
ImageLoader::ByteSwapImageData( (unsigned char*)writer.GetPixelMemory(), srcStride*pTempRT->GetActualHeight(), pTempRT->GetImageFormat() );
// convert to callers format
Assert( dstFormat == IMAGE_FORMAT_RGB888 );
ImageLoader::ConvertImageFormat( (unsigned char*)writer.GetPixelMemory(), pTempRT->GetImageFormat(), pDstData, dstFormat, pDstRect->width, pDstRect->height, srcStride, dstStride );
g_pShaderAPI->TexUnlock();
}
#endif
#if defined( _X360 )
void CMaterialSystem::PersistDisplay()
{
g_pShaderAPI->PersistDisplay();
}
#endif
#if defined( _X360 )
void *CMaterialSystem::GetD3DDevice()
{
return g_pShaderAPI->GetD3DDevice();
}
#endif
#if defined( _X360 )
bool CMaterialSystem::OwnGPUResources( bool bEnable )
{
return g_pShaderAPI->OwnGPUResources( bEnable );
}
#endif
//-----------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------
class CThreadRelease : public CJob
{
virtual JobStatus_t DoExecute()
{
g_pShaderAPI->ReleaseThreadOwnership();
return JOB_OK;
}
};
void CMaterialSystem::ThreadRelease( )
{
if ( !m_bThreadHasOwnership )
{
return;
}
double flStartTime, flEndThreadRelease, flEndTime;
int do_report = mat_queue_report.GetInt();
if ( do_report )
{
flStartTime = Plat_FloatTime();
}
CJob *pActiveAsyncJob = new CThreadRelease();
IThreadPool *pThreadPool = CreateMatQueueThreadPool();
pThreadPool->AddJob( pActiveAsyncJob );
pActiveAsyncJob->WaitForFinish();
SafeRelease( pActiveAsyncJob );
if ( do_report )
{
flEndThreadRelease = Plat_FloatTime();
}
g_pShaderAPI->AcquireThreadOwnership();
m_bThreadHasOwnership = false;
m_ThreadOwnershipID = 0;
if ( do_report )
{
flEndTime = Plat_FloatTime();
double flResult = ( flEndTime - flStartTime ) * 1000.0;
if ( do_report == -1 || flResult > mat_queue_report.GetFloat() )
{
Color red( 200, 20, 20, 255 );
ConColorMsg( red, "CMaterialSystem::ThreadRelease: %0.2fms = Release:%0.2fms + Acquire:%0.2fms\n", flResult, ( flEndThreadRelease - flStartTime ) * 1000.0, ( flEndTime - flEndThreadRelease ) * 1000.0 );
}
}
}
void CMaterialSystem::ThreadAcquire( bool bForce )
{
if ( !bForce )
{
return;
}
double flStartTime, flEndTime;
int do_report = mat_queue_report.GetInt();
if ( do_report )
{
flStartTime = Plat_FloatTime();
}
g_pShaderAPI->ReleaseThreadOwnership();
CJob *pActiveAsyncJob = new CThreadAcquire();
IThreadPool *pThreadPool = CreateMatQueueThreadPool();
pThreadPool->AddJob( pActiveAsyncJob );
// while we could wait for this job to finish, there's no reason too
// pActiveAsyncJob->WaitForFinish();
SafeRelease( pActiveAsyncJob );
m_bThreadHasOwnership = true;
m_ThreadOwnershipID = ThreadGetCurrentId();
if ( do_report )
{
flEndTime = Plat_FloatTime();
double flResult = ( flEndTime - flStartTime ) * 1000.0;
if ( do_report == -1 || flResult > mat_queue_report.GetFloat() )
{
Color red( 200, 20, 20, 255 );
ConColorMsg( red, "CMaterialSystem::ThreadAcquire: %0.2fms\n", flResult );
}
}
}
//-----------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------
MaterialLock_t CMaterialSystem::Lock()
{
double flStartTime;
int do_report = mat_queue_report.GetInt();
if ( do_report )
{
flStartTime = Plat_FloatTime();
}
IMatRenderContextInternal *pCurContext = GetRenderContextInternal();
#if 1 // Rick's optimization: not sure this is needed anymore
if ( pCurContext != &m_HardwareRenderContext && m_pActiveAsyncJob )
{
m_pActiveAsyncJob->WaitForFinish();
// threadsafety note: not releasing or nulling pointer.
}
if ( m_ThreadMode != MATERIAL_SINGLE_THREADED )
{
TelemetrySetLockName( TELEMETRY_LEVEL0, (char const *)&g_MatSysMutex, "MatSysMutex" );
tmTryLock( TELEMETRY_LEVEL0, (char const *)&g_MatSysMutex, "CMaterialSystem" );
g_MatSysMutex.Lock();
tmEndTryLock( TELEMETRY_LEVEL0, (char const *)&g_MatSysMutex, TMLR_SUCCESS );
tmSetLockState( TELEMETRY_LEVEL0, (char const *)&g_MatSysMutex, TMLS_LOCKED, "CMaterialSystem" );
}
#endif
MaterialLock_t hMaterialLock = (MaterialLock_t)pCurContext;
m_pRenderContext.Set( &m_HardwareRenderContext );
if ( m_ThreadMode != MATERIAL_SINGLE_THREADED )
{
g_pShaderAPI->SetDisallowAccess( false );
if ( pCurContext->GetCallQueueInternal() )
{
ThreadRelease();
}
}
g_pShaderAPI->ShaderLock();
if ( do_report )
{
double flEndTime = Plat_FloatTime();
double flResult = ( flEndTime - flStartTime ) * 1000.0;
if ( do_report == -1 || flResult > mat_queue_report.GetFloat() )
{
Color red( 200, 20, 20, 255 );
ConColorMsg( red, "*CMaterialSystem::Lock: %0.2fms\n", flResult );
}
}
return hMaterialLock;
}
//-----------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------
void CMaterialSystem::Unlock( MaterialLock_t hMaterialLock )
{
double flStartTime;
int do_report = mat_queue_report.GetInt();
if ( do_report )
{
flStartTime = Plat_FloatTime();
}
IMatRenderContextInternal *pRenderContext = (IMatRenderContextInternal *)hMaterialLock;
m_pRenderContext.Set( pRenderContext );
g_pShaderAPI->ShaderUnlock();
#ifdef MAT_QUEUE_MODE_PROFILE
if ( m_ThreadMode == MATERIAL_QUEUED_SINGLE_THREADED )
{
g_pShaderAPI->SetDisallowAccess( true );
}
else
#endif
if ( m_ThreadMode == MATERIAL_QUEUED_THREADED )
{
if ( pRenderContext->GetCallQueueInternal() )
{
ThreadAcquire();
}
}
#if 1 // Rick's optimization: not sure this is needed anymore
if ( m_ThreadMode != MATERIAL_SINGLE_THREADED )
{
g_MatSysMutex.Unlock();
tmSetLockState( TELEMETRY_LEVEL0, (char const *)&g_MatSysMutex, TMLS_RELEASED, "CMaterialSystem" );
}
#endif
if ( do_report )
{
double flEndTime = Plat_FloatTime();
double flResult = ( flEndTime - flStartTime ) * 1000.0;
if ( do_report || flResult > mat_queue_report.GetFloat() )
{
Color red( 200, 20, 20, 255 );
ConColorMsg( red, "*CMaterialSystem::Unlock: %0.2fms\n", flResult );
}
}
}
//-----------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------
CMatCallQueue *CMaterialSystem::GetRenderCallQueue()
{
IMatRenderContextInternal *pRenderContext = m_pRenderContext.Get();
return pRenderContext ? pRenderContext->GetCallQueueInternal() : NULL;
}
void CMaterialSystem::UnbindMaterial( IMaterial *pMaterial )
{
Assert( (pMaterial == NULL) || ((IMaterialInternal *)pMaterial)->IsRealTimeVersion() );
if ( m_HardwareRenderContext.GetCurrentMaterial() == pMaterial )
{
m_HardwareRenderContext.Bind( g_pErrorMaterial, NULL );
}
}
class CReplacementProxy : public IMaterialProxy
{
public:
CReplacementProxy( void );
virtual ~CReplacementProxy( void );
virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
virtual void OnBind( void * );
virtual void Release( );
virtual IMaterial * GetMaterial( );
private:
IMaterial *m_pReplaceMaterial;
};
#define REPLACEMENT_NAME "_replacement"
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CReplacementProxy::CReplacementProxy( void ) : m_pReplaceMaterial ( NULL )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CReplacementProxy::~CReplacementProxy( void )
{
}
//-----------------------------------------------------------------------------
// Purpose: Get pointer to the color value
// Input : *pMaterial -
//-----------------------------------------------------------------------------
bool CReplacementProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
const char *pszFileName = pMaterial->GetName();
char szNewName[ MAX_PATH ];
V_sprintf_safe( szNewName, "%s" REPLACEMENT_NAME, pszFileName );
m_pReplaceMaterial = materials->CreateMaterial( szNewName, pKeyValues );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
//-----------------------------------------------------------------------------
void CReplacementProxy::OnBind( void * )
{
}
void CReplacementProxy::Release( )
{
m_pReplaceMaterial->DecrementReferenceCount();
// Since we have a material-holding-a-material situation here, we need to nuke these if unreferenced to prevent the
// engine needing to double-call UncacheUnusedMaterials to actually get rid of all materials.
m_pReplaceMaterial->DeleteIfUnreferenced();
m_pReplaceMaterial = NULL;
}
IMaterial *CReplacementProxy::GetMaterial()
{
static ConVarRef localplayer_visionflags( "localplayer_visionflags" );
bool bVisionOverride = ( localplayer_visionflags.IsValid() && ( localplayer_visionflags.GetInt() & ( 0x01 ) ) ); // Pyro-vision Goggles
if ( bVisionOverride )
{
return m_pReplaceMaterial;
}
return NULL;
}
EXPOSE_INTERFACE( CReplacementProxy, IMaterialProxy, "replace_proxy" IMATERIAL_PROXY_INTERFACE_VERSION );
static const char *pszReplacementForceCopy[] =
{
"$nocull",
NULL
};
void CMaterialSystem::LoadReplacementMaterials()
{
const char* cLocation = "materials";
if ( CommandLine()->FindParm( "-matscan") ) {
ScanDirForReplacements( cLocation );
} else {
InitReplacementsFromFile( cLocation );
}
}
void CMaterialSystem::ScanDirForReplacements( const char *pszPathName )
{
char szBaseName[ MAX_PATH ];
V_sprintf_safe( szBaseName, "%s/replacements.vmt", pszPathName );
if ( g_pFullFileSystem->FileExists( szBaseName ) )
{
KeyValues *pKV = g_pFullFileSystem->LoadKeyValues( IFileSystem::TYPE_VMT, szBaseName );
if ( pKV )
{
V_sprintf_safe( szBaseName, "%s/", pszPathName );
m_Replacements.Insert( szBaseName, pKV );
}
}
V_sprintf_safe( szBaseName, "%s/*", pszPathName );
FileFindHandle_t FindHandle;
const char *pFindFileName = g_pFullFileSystem->FindFirst( szBaseName, &FindHandle );
while ( pFindFileName && pFindFileName[ 0 ] != '\0' )
{
if ( g_pFullFileSystem->FindIsDirectory( FindHandle ) )
{
if ( strcmp( pFindFileName, "." ) != 0 && strcmp( pFindFileName, ".." ) != 0 )
{
char szNextBaseName[ MAX_PATH ];
V_sprintf_safe( szNextBaseName, "%s/%s", pszPathName, pFindFileName );
ScanDirForReplacements( szNextBaseName );
}
}
pFindFileName = g_pFullFileSystem->FindNext( FindHandle );
}
g_pFullFileSystem->FindClose( FindHandle );
}
void CMaterialSystem::InitReplacementsFromFile( const char *pszPathName )
{
CUtlVector<char*> replacementFiles;
char szBaseName[MAX_PATH];
V_sprintf_safe( szBaseName, "%s/replacements.txt", pszPathName );
int replacementCount = ReadListFromFile( &replacementFiles, szBaseName );
for ( int i = 0; i < replacementCount; ++i )
{
V_snprintf( szBaseName, sizeof(szBaseName), "%s/%s/replacements.vmt", pszPathName, replacementFiles[i] );
if ( g_pFullFileSystem->FileExists(szBaseName) )
{
KeyValues *pKV = g_pFullFileSystem->LoadKeyValues( IFileSystem::TYPE_VMT, szBaseName );
if (pKV)
{
V_sprintf_safe( szBaseName, "%s/%s/", pszPathName, replacementFiles[i] );
m_Replacements.Insert( szBaseName, pKV );
}
}
}
replacementFiles.PurgeAndDeleteElements();
}
void CMaterialSystem::PreloadReplacements( )
{
int nIndex = m_Replacements.First();
while( m_Replacements.IsValidIndex( nIndex ) )
{
m_Replacements.Element( nIndex )->deleteThis();
nIndex = m_Replacements.Next( nIndex );
}
m_Replacements.Purge();
COM_TimestampedLog( "LoadReplacementMaterials(): Begin" );
LoadReplacementMaterials();
COM_TimestampedLog( "LoadReplacementMaterials(): End" );
m_bReplacementFilesValid = true;
}
IMaterialProxy *CMaterialSystem::DetermineProxyReplacements( IMaterial *pMaterial, KeyValues *pFallbackKeyValues )
{
CReplacementProxy *pReplacementProxy = NULL;
if ( !g_pMaterialSystemHardwareConfig->SupportsPixelShaders_2_0() )
{
return NULL;
}
if ( !m_bReplacementFilesValid )
{
PreloadReplacements();
}
const char *pszMaterialName = pMaterial->GetName();
char szCheckPath[ MAX_PATH ], szCheckName[ MAX_PATH ], szLastPath[ MAX_PATH ];
const char *pszShadername = pFallbackKeyValues->GetName();
V_strcpy_safe( szLastPath, pszMaterialName );
int nLength = strlen( szLastPath ) - strlen( REPLACEMENT_NAME );
if ( nLength > 0 && strcmpi( &szLastPath[ nLength ], REPLACEMENT_NAME ) == 0 )
{
return NULL;
}
while( 1 )
{
const char *pszRemoveSlashes;
V_ExtractFilePath( szLastPath, szCheckPath, sizeof( szCheckPath ) );
pszRemoveSlashes = szCheckPath;
while ( ( *pszRemoveSlashes ) != 0 && ( ( *pszRemoveSlashes ) == '/' || ( *pszRemoveSlashes ) == '\\' ) )
{
pszRemoveSlashes++;
}
V_sprintf_safe( szCheckName, "materials/%s", pszRemoveSlashes );
int nIndex = m_Replacements.Find( szCheckName );
if ( m_Replacements.IsValidIndex( nIndex ) )
{
KeyValues *pKV = m_Replacements.Element( nIndex );
KeyValues *pTemplatesKV = pKV->FindKey( "templates" );
KeyValues *pPatternsKV = pKV->FindKey( "patterns" );
const char *pszFileName = V_GetFileName( pszMaterialName );
if ( !pTemplatesKV || !pPatternsKV )
{
Warning( "Replacements: Invalid KV file %s\n", szCheckName );
}
else
{
for ( KeyValues *pSubKey = pPatternsKV->GetFirstSubKey(); pSubKey; pSubKey = pSubKey->GetNextKey() )
{
const char *pszReplacementName = pSubKey->GetName();
// Msg( " Sub: %s\n", pSubKey->GetName() );
if ( strnicmp( pszFileName, pszReplacementName, strlen( pszReplacementName ) ) == 0 )
{ // We found a replacement!
const char *pszTemplateName = pSubKey->GetString( "template", NULL );
KeyValues *pReplacementMaterial = NULL;
if ( pszTemplateName && pTemplatesKV )
{
KeyValues *pTemplateKV = pTemplatesKV->FindKey( pszTemplateName );
if ( pTemplateKV )
{
pTemplateKV = pTemplateKV->FindKey( pszShadername );
if ( pTemplateKV && pTemplateKV->GetFirstSubKey() )
{
pReplacementMaterial = pTemplateKV->GetFirstSubKey()->MakeCopy();
}
}
}
else
{
if ( pSubKey->GetFirstSubKey() )
{
pReplacementMaterial = pSubKey->GetFirstSubKey()->MakeCopy();
}
}
if ( !pReplacementMaterial )
{
break;
}
if ( pReplacementMaterial->GetInt( "$copyall" ) == 1 )
{
for( KeyValues *pCopyKV = pFallbackKeyValues->GetFirstSubKey(); pCopyKV; pCopyKV = pCopyKV->GetNextKey() )
{
const char *pszCopyValue = pReplacementMaterial->GetString( pCopyKV->GetName(), NULL );
if ( !pszCopyValue )
{
pReplacementMaterial->SetString( pCopyKV->GetName(), pCopyKV->GetString() );
}
}
}
else
{
int nReplaceIndex = 0;
while( pszReplacementForceCopy[nReplaceIndex] )
{
const char *pszCopyValue = pFallbackKeyValues->GetString( pszReplacementForceCopy[nReplaceIndex], NULL );
if ( pszCopyValue )
{
pReplacementMaterial->SetString( pszReplacementForceCopy[nReplaceIndex], pszCopyValue );
}
nReplaceIndex++;
}
}
for( KeyValues *pSearchKV = pReplacementMaterial->GetFirstSubKey(); pSearchKV; pSearchKV = pSearchKV->GetNextKey() )
{
const char *pszValue = pSearchKV->GetString();
if ( pszValue[ 0 ] == '$' )
{
const char *pszCopyValue = pFallbackKeyValues->GetString( pszValue, NULL );
if ( pszCopyValue )
{
pSearchKV->SetStringValue( pszCopyValue );
}
else
{
pSearchKV->SetStringValue( "" );
}
}
}
pReplacementProxy = new CReplacementProxy();
pReplacementProxy->Init( pMaterial, pReplacementMaterial );
break;
}
}
}
if ( pReplacementProxy == NULL )
{
// Msg( "Failed to find: %s\n", GetName() );
}
break;
}
if ( szCheckPath[ 0 ] == 0 )
{
break;
}
strcpy( szLastPath, szCheckPath );
}
return pReplacementProxy;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CMaterialSystem::CompactMemory()
{
for ( int i = 0; i < ARRAYSIZE(m_QueuedRenderContexts); i++)
{
m_QueuedRenderContexts[i].CompactMemory();
}
}
void CMaterialSystem::OnRenderingAsyncComplete()
{
Assert( m_pActiveAsyncJob == NULL );
// Update the texture manager, which may cause some textures to become available for compositing.
// Because updating textures may cause textures to swap out their active texture handles, this can only be done
// while the async job is not running.
bool bThreadHadOwnership = m_bThreadHasOwnership;
TextureManager()->UpdatePostAsync();
if ( bThreadHadOwnership && !m_bThreadHasOwnership )
ThreadAcquire( true );
}
//-----------------------------------------------------------------------------
// Material + texture related commands
//-----------------------------------------------------------------------------
void CMaterialSystem::DebugPrintUsedMaterials( const CCommand &args )
{
if( args.ArgC() == 1 )
{
DebugPrintUsedMaterials( NULL, false );
}
else
{
DebugPrintUsedMaterials( args[ 1 ], false );
}
}
void CMaterialSystem::DebugPrintUsedMaterialsVerbose( const CCommand &args )
{
if( args.ArgC() == 1 )
{
DebugPrintUsedMaterials( NULL, true );
}
else
{
DebugPrintUsedMaterials( args[ 1 ], true );
}
}
void CMaterialSystem::DebugPrintUsedTextures( const CCommand &args )
{
DebugPrintUsedTextures();
}
#if defined( _X360 )
void CMaterialSystem::ListUsedMaterials( const CCommand &args )
{
ListUsedMaterials();
}
#endif // !_X360
void CMaterialSystem::ReloadAllMaterials( const CCommand &args )
{
ReloadMaterials( NULL );
}
void CMaterialSystem::ReloadMaterials( const CCommand &args )
{
if( args.ArgC() != 2 )
{
ConWarning( "Usage: mat_reloadmaterial material_name_substring\n"
" or mat_reloadmaterial substring1*substring2*...*substringN\n" );
return;
}
ReloadMaterials( args[ 1 ] );
}
void CMaterialSystem::ReloadTextures( const CCommand &args )
{
ReloadTextures();
}
CON_COMMAND( mat_hdr_enabled, "Report if HDR is enabled for debugging" )
{
if( HardwareConfig() && HardwareConfig()->GetHDREnabled() )
{
Warning( "HDR Enabled\n" );
}
else
{
Warning( "HDR Disabled\n" );
}
}
static int ReadListFromFile(CUtlVector<char*>* outReplacementMaterials, const char *pszPathName)
{
Assert(outReplacementMaterials != NULL);
Assert(pszPathName != NULL);
CUtlBuffer fileContents;
if ( !g_pFullFileSystem->ReadFile( pszPathName, NULL, fileContents ) )
return 0;
const char* seps[] = { "\r", "\r\n", "\n" };
V_SplitString2( (char*)fileContents.Base(), seps, ARRAYSIZE(seps), *outReplacementMaterials );
return outReplacementMaterials->Size();
}
Reference in New Issue Copy Permalink