H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
9a1ab79372
source-engine/materialsystem/shaderapidx9/shaderdevicebase.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

1257 lines
38 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#define DISABLE_PROTECTED_THINGS
#include "togl/rendermechanism.h"
#include "shaderdevicebase.h"
#include "tier1/KeyValues.h"
#include "tier1/convar.h"
#include "tier1/utlbuffer.h"
#include "tier0/icommandline.h"
#include "tier2/tier2.h"
#include "filesystem.h"
#include "datacache/idatacache.h"
#include "shaderapi/ishaderutil.h"
#include "shaderapibase.h"
#include "shaderapi/ishadershadow.h"
#include "shaderapi_global.h"
#include "winutils.h"
#ifdef _X360
#include "xbox/xbox_win32stubs.h"
#endif
//-----------------------------------------------------------------------------
// Globals
//-----------------------------------------------------------------------------
IShaderUtil* g_pShaderUtil; // The main shader utility interface
CShaderDeviceBase *g_pShaderDevice;
CShaderDeviceMgrBase *g_pShaderDeviceMgr;
CShaderAPIBase *g_pShaderAPI;
IShaderShadow *g_pShaderShadow;
bool g_bUseShaderMutex = false; // Shader mutex globals
bool g_bShaderAccessDisallowed;
CShaderMutex g_ShaderMutex;
//-----------------------------------------------------------------------------
// FIXME: Hack related to setting command-line values for convars. Remove!!!
//-----------------------------------------------------------------------------
class CShaderAPIConVarAccessor : public IConCommandBaseAccessor
{
public:
virtual bool RegisterConCommandBase( ConCommandBase *pCommand )
{
// Link to engine's list instead
g_pCVar->RegisterConCommand( pCommand );
char const *pValue = g_pCVar->GetCommandLineValue( pCommand->GetName() );
if( pValue && !pCommand->IsCommand() )
{
( ( ConVar * )pCommand )->SetValue( pValue );
}
return true;
}
};
static void InitShaderAPICVars( )
{
static CShaderAPIConVarAccessor g_ConVarAccessor;
if ( g_pCVar )
{
ConVar_Register( FCVAR_MATERIAL_SYSTEM_THREAD, &g_ConVarAccessor );
}
}
//-----------------------------------------------------------------------------
// Read dx support levels
//-----------------------------------------------------------------------------
#if defined( DX_TO_GL_ABSTRACTION )
#if defined( OSX )
// OSX
#define SUPPORT_CFG_FILE "dxsupport_mac.cfg"
// TODO: make this different for Mac?
#define SUPPORT_CFG_OVERRIDE_FILE "dxsupport_override.cfg"
#else
// Linux/Win GL
#define SUPPORT_CFG_FILE "dxsupport_linux.cfg"
// TODO: make this different for Linux?
#define SUPPORT_CFG_OVERRIDE_FILE "dxsupport_override.cfg"
#endif
#else
// D3D
#define SUPPORT_CFG_FILE "dxsupport.cfg"
#define SUPPORT_CFG_OVERRIDE_FILE "dxsupport_override.cfg"
#endif
//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------
CShaderDeviceMgrBase::CShaderDeviceMgrBase()
{
m_pDXSupport = NULL;
}
CShaderDeviceMgrBase::~CShaderDeviceMgrBase()
{
}
//-----------------------------------------------------------------------------
// Factory used to get at internal interfaces (used by shaderapi + shader dlls)
//-----------------------------------------------------------------------------
static CreateInterfaceFn s_TempFactory;
void *ShaderDeviceFactory( const char *pName, int *pReturnCode )
{
if (pReturnCode)
{
*pReturnCode = IFACE_OK;
}
void *pInterface = s_TempFactory( pName, pReturnCode );
if ( pInterface )
return pInterface;
pInterface = Sys_GetFactoryThis()( pName, pReturnCode );
if ( pInterface )
return pInterface;
if ( pReturnCode )
{
*pReturnCode = IFACE_FAILED;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Connect, disconnect
//-----------------------------------------------------------------------------
bool CShaderDeviceMgrBase::Connect( CreateInterfaceFn factory )
{
LOCK_SHADERAPI();
Assert( !g_pShaderDeviceMgr );
s_TempFactory = factory;
// Connection/convar registration
CreateInterfaceFn actualFactory = ShaderDeviceFactory;
ConnectTier1Libraries( &actualFactory, 1 );
InitShaderAPICVars();
ConnectTier2Libraries( &actualFactory, 1 );
g_pShaderUtil = (IShaderUtil*)ShaderDeviceFactory( SHADER_UTIL_INTERFACE_VERSION, NULL );
g_pShaderDeviceMgr = this;
s_TempFactory = NULL;
if ( !g_pShaderUtil || !g_pFullFileSystem || !g_pShaderDeviceMgr )
{
Warning( "ShaderAPIDx10 was unable to access the required interfaces!\n" );
return false;
}
// 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 );
return true;
}
void CShaderDeviceMgrBase::Disconnect()
{
LOCK_SHADERAPI();
g_pShaderDeviceMgr = NULL;
g_pShaderUtil = NULL;
DisconnectTier2Libraries();
ConVar_Unregister();
DisconnectTier1Libraries();
if ( m_pDXSupport )
{
m_pDXSupport->deleteThis();
m_pDXSupport = NULL;
}
}
//-----------------------------------------------------------------------------
// Query interface
//-----------------------------------------------------------------------------
void *CShaderDeviceMgrBase::QueryInterface( const char *pInterfaceName )
{
if ( !Q_stricmp( pInterfaceName, SHADER_DEVICE_MGR_INTERFACE_VERSION ) )
return ( IShaderDeviceMgr* )this;
if ( !Q_stricmp( pInterfaceName, MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION ) )
return ( IMaterialSystemHardwareConfig* )g_pHardwareConfig;
return NULL;
}
//-----------------------------------------------------------------------------
// Returns the hardware caps for a particular adapter
//-----------------------------------------------------------------------------
const HardwareCaps_t& CShaderDeviceMgrBase::GetHardwareCaps( int nAdapter ) const
{
Assert( ( nAdapter >= 0 ) && ( nAdapter < GetAdapterCount() ) );
return m_Adapters[nAdapter].m_ActualCaps;
}
//-----------------------------------------------------------------------------
// Utility methods for reading config scripts
//-----------------------------------------------------------------------------
static inline int ReadHexValue( KeyValues *pVal, const char *pName )
{
const char *pString = pVal->GetString( pName, NULL );
if (!pString)
{
return -1;
}
char *pTemp;
int nVal = strtol( pString, &pTemp, 16 );
return (pTemp != pString) ? nVal : -1;
}
static bool ReadBool( KeyValues *pGroup, const char *pKeyName, bool bDefault )
{
int nVal = pGroup->GetInt( pKeyName, -1 );
if ( nVal != -1 )
{
// Warning( "\t%s = %s\n", pKeyName, (nVal != false) ? "true" : "false" );
return (nVal != false);
}
return bDefault;
}
static void ReadInt( KeyValues *pGroup, const char *pKeyName, int nInvalidValue, int *pResult )
{
int nVal = pGroup->GetInt( pKeyName, nInvalidValue );
if ( nVal != nInvalidValue )
{
*pResult = nVal;
// Warning( "\t%s = %d\n", pKeyName, *pResult );
}
}
//-----------------------------------------------------------------------------
// Utility method to copy over a keyvalue
//-----------------------------------------------------------------------------
static void AddKey( KeyValues *pDest, KeyValues *pSrc )
{
// Note this will replace already-existing values
switch( pSrc->GetDataType() )
{
case KeyValues::TYPE_NONE:
break;
case KeyValues::TYPE_STRING:
pDest->SetString( pSrc->GetName(), pSrc->GetString() );
break;
case KeyValues::TYPE_INT:
pDest->SetInt( pSrc->GetName(), pSrc->GetInt() );
break;
case KeyValues::TYPE_FLOAT:
pDest->SetFloat( pSrc->GetName(), pSrc->GetFloat() );
break;
case KeyValues::TYPE_PTR:
pDest->SetPtr( pSrc->GetName(), pSrc->GetPtr() );
break;
case KeyValues::TYPE_WSTRING:
pDest->SetWString( pSrc->GetName(), pSrc->GetWString() );
break;
case KeyValues::TYPE_COLOR:
pDest->SetColor( pSrc->GetName(), pSrc->GetColor() );
break;
default:
Assert( 0 );
break;
}
}
//-----------------------------------------------------------------------------
// Finds if we have a dxlevel-specific config in the support keyvalues
//-----------------------------------------------------------------------------
KeyValues *CShaderDeviceMgrBase::FindDXLevelSpecificConfig( KeyValues *pKeyValues, int nDxLevel )
{
KeyValues *pGroup = pKeyValues->GetFirstSubKey();
for( pGroup = pKeyValues->GetFirstSubKey(); pGroup; pGroup = pGroup->GetNextKey() )
{
int nFoundDxLevel = pGroup->GetInt( "name", 0 );
if( nFoundDxLevel == nDxLevel )
return pGroup;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Finds if we have a dxlevel and vendor-specific config in the support keyvalues
//-----------------------------------------------------------------------------
KeyValues *CShaderDeviceMgrBase::FindDXLevelAndVendorSpecificConfig( KeyValues *pKeyValues, int nDxLevel, int nVendorID )
{
if ( IsX360() )
{
// 360 unique dxlevel implies hw config, vendor variance not applicable
return NULL;
}
KeyValues *pGroup = pKeyValues->GetFirstSubKey();
for( pGroup = pKeyValues->GetFirstSubKey(); pGroup; pGroup = pGroup->GetNextKey() )
{
int nFoundDxLevel = pGroup->GetInt( "name", 0 );
int nFoundVendorID = ReadHexValue( pGroup, "VendorID" );
if( nFoundDxLevel == nDxLevel && nFoundVendorID == nVendorID )
return pGroup;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Finds if we have a vendor-specific config in the support keyvalues
//-----------------------------------------------------------------------------
KeyValues *CShaderDeviceMgrBase::FindCPUSpecificConfig( KeyValues *pKeyValues, int nCPUMhz, bool bAMD )
{
if ( IsX360() )
{
// 360 unique dxlevel implies hw config, cpu variance not applicable
return NULL;
}
for( KeyValues *pGroup = pKeyValues->GetFirstSubKey(); pGroup; pGroup = pGroup->GetNextKey() )
{
const char *pName = pGroup->GetString( "name", NULL );
if ( !pName )
continue;
if ( ( bAMD && Q_stristr( pName, "AMD" ) ) ||
( !bAMD && Q_stristr( pName, "Intel" ) ) )
{
int nMinMegahertz = pGroup->GetInt( "min megahertz", -1 );
int nMaxMegahertz = pGroup->GetInt( "max megahertz", -1 );
if( nMinMegahertz == -1 || nMaxMegahertz == -1 )
continue;
if( nMinMegahertz <= nCPUMhz && nCPUMhz < nMaxMegahertz )
return pGroup;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Finds if we have a vendor-specific config in the support keyvalues
//-----------------------------------------------------------------------------
KeyValues *CShaderDeviceMgrBase::FindCardSpecificConfig( KeyValues *pKeyValues, int nVendorId, int nDeviceId )
{
if ( IsX360() )
{
// 360 unique dxlevel implies hw config, vendor variance not applicable
return NULL;
}
KeyValues *pGroup = pKeyValues->GetFirstSubKey();
for( pGroup = pKeyValues->GetFirstSubKey(); pGroup; pGroup = pGroup->GetNextKey() )
{
int nFoundVendorId = ReadHexValue( pGroup, "VendorID" );
int nFoundDeviceIdMin = ReadHexValue( pGroup, "MinDeviceID" );
int nFoundDeviceIdMax = ReadHexValue( pGroup, "MaxDeviceID" );
if ( nFoundVendorId == nVendorId && nDeviceId >= nFoundDeviceIdMin && nDeviceId <= nFoundDeviceIdMax )
return pGroup;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Finds if we have a vendor-specific config in the support keyvalues
//-----------------------------------------------------------------------------
KeyValues *CShaderDeviceMgrBase::FindMemorySpecificConfig( KeyValues *pKeyValues, int nSystemRamMB )
{
if ( IsX360() )
{
// 360 unique dxlevel implies hw config, memory variance not applicable
return NULL;
}
for( KeyValues *pGroup = pKeyValues->GetFirstSubKey(); pGroup; pGroup = pGroup->GetNextKey() )
{
// Used to help us debug this code
// const char *pDebugName = pGroup->GetString( "name", "blah" );
int nMinMB = pGroup->GetInt( "min megabytes", -1 );
int nMaxMB = pGroup->GetInt( "max megabytes", -1 );
if ( nMinMB == -1 || nMaxMB == -1 )
continue;
if ( nMinMB <= nSystemRamMB && nSystemRamMB < nMaxMB )
return pGroup;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Finds if we have a texture mem size specific config
//-----------------------------------------------------------------------------
KeyValues *CShaderDeviceMgrBase::FindVidMemSpecificConfig( KeyValues *pKeyValues, int nVideoRamMB )
{
if ( IsX360() )
{
// 360 unique dxlevel implies hw config, vidmem variance not applicable
return NULL;
}
for( KeyValues *pGroup = pKeyValues->GetFirstSubKey(); pGroup; pGroup = pGroup->GetNextKey() )
{
int nMinMB = pGroup->GetInt( "min megatexels", -1 );
int nMaxMB = pGroup->GetInt( "max megatexels", -1 );
if ( nMinMB == -1 || nMaxMB == -1 )
continue;
if ( nMinMB <= nVideoRamMB && nVideoRamMB < nMaxMB )
return pGroup;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Methods related to reading DX support levels given particular devices
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Reads in the dxsupport.cfg keyvalues
//-----------------------------------------------------------------------------
static void OverrideValues_R( KeyValues *pDest, KeyValues *pSrc )
{
// Any same-named values get overridden in pDest.
for ( KeyValues *pSrcValue=pSrc->GetFirstValue(); pSrcValue; pSrcValue=pSrcValue->GetNextValue() )
{
// Shouldn't be a container for more keys.
Assert( pSrcValue->GetDataType() != KeyValues::TYPE_NONE );
AddKey( pDest, pSrcValue );
}
// Recurse.
for ( KeyValues *pSrcDir=pSrc->GetFirstTrueSubKey(); pSrcDir; pSrcDir=pSrcDir->GetNextTrueSubKey() )
{
Assert( pSrcDir->GetDataType() == KeyValues::TYPE_NONE );
KeyValues *pDestDir = pDest->FindKey( pSrcDir->GetName() );
if ( pDestDir && pDestDir->GetDataType() == KeyValues::TYPE_NONE )
{
OverrideValues_R( pDestDir, pSrcDir );
}
}
}
static KeyValues * FindMatchingGroup( KeyValues *pSrc, KeyValues *pMatch )
{
KeyValues *pMatchSubKey = pMatch->FindKey( "name" );
bool bHasSubKey = ( pMatchSubKey && ( pMatchSubKey->GetDataType() != KeyValues::TYPE_NONE ) );
const char *name = bHasSubKey ? pMatchSubKey->GetString() : NULL;
int nMatchVendorID = ReadHexValue( pMatch, "VendorID" );
int nMatchMinDeviceID = ReadHexValue( pMatch, "MinDeviceID" );
int nMatchMaxDeviceID = ReadHexValue( pMatch, "MaxDeviceID" );
KeyValues *pSrcGroup = NULL;
for ( pSrcGroup = pSrc->GetFirstTrueSubKey(); pSrcGroup; pSrcGroup = pSrcGroup->GetNextTrueSubKey() )
{
if ( name )
{
KeyValues *pSrcGroupName = pSrcGroup->FindKey( "name" );
Assert( pSrcGroupName );
Assert( pSrcGroupName->GetDataType() != KeyValues::TYPE_NONE );
if ( Q_stricmp( pSrcGroupName->GetString(), name ) )
continue;
}
if ( nMatchVendorID >= 0 )
{
int nVendorID = ReadHexValue( pSrcGroup, "VendorID" );
if ( nMatchVendorID != nVendorID )
continue;
}
if ( nMatchMinDeviceID >= 0 && nMatchMaxDeviceID >= 0 )
{
int nMinDeviceID = ReadHexValue( pSrcGroup, "MinDeviceID" );
int nMaxDeviceID = ReadHexValue( pSrcGroup, "MaxDeviceID" );
if ( nMinDeviceID < 0 || nMaxDeviceID < 0 )
continue;
if ( nMatchMinDeviceID > nMinDeviceID || nMatchMaxDeviceID < nMaxDeviceID )
continue;
}
return pSrcGroup;
}
return NULL;
}
static void OverrideKeyValues( KeyValues *pDst, KeyValues *pSrc )
{
KeyValues *pSrcGroup = NULL;
for ( pSrcGroup = pSrc->GetFirstTrueSubKey(); pSrcGroup; pSrcGroup = pSrcGroup->GetNextTrueSubKey() )
{
// Match each group in pSrc to one in pDst containing the same "name" value:
KeyValues * pDstGroup = FindMatchingGroup( pDst, pSrcGroup );
//Assert( pDstGroup );
if ( pDstGroup )
{
OverrideValues_R( pDstGroup, pSrcGroup );
}
}
// if( CommandLine()->FindParm( "-debugdxsupport" ) )
// {
// CUtlBuffer tmpBuf;
// pDst->RecursiveSaveToFile( tmpBuf, 0 );
// g_pFullFileSystem->WriteFile( "gary.txt", NULL, tmpBuf );
// }
}
KeyValues *CShaderDeviceMgrBase::ReadDXSupportKeyValues()
{
if ( CommandLine()->CheckParm( "-ignoredxsupportcfg" ) )
return NULL;
if ( m_pDXSupport )
return m_pDXSupport;
KeyValues *pCfg = new KeyValues( "dxsupport" );
const char *pPathID = "EXECUTABLE_PATH";
if ( IsX360() && g_pFullFileSystem->GetDVDMode() == DVDMODE_STRICT )
{
// 360 dvd optimzation, expect it inside the platform zip
pPathID = "PLATFORM";
}
// First try to read a game-specific config, if it exists
if ( !pCfg->LoadFromFile( g_pFullFileSystem, SUPPORT_CFG_FILE, pPathID ) )
{
pCfg->deleteThis();
return NULL;
}
char pTempPath[1024];
if ( g_pFullFileSystem->GetSearchPath( "GAME", false, pTempPath, sizeof(pTempPath) ) > 1 )
{
// Is there a mod-specific override file?
KeyValues *pOverride = new KeyValues( "dxsupport_override" );
if ( pOverride->LoadFromFile( g_pFullFileSystem, SUPPORT_CFG_OVERRIDE_FILE, "GAME" ) )
{
OverrideKeyValues( pCfg, pOverride );
}
pOverride->deleteThis();
}
m_pDXSupport = pCfg;
return pCfg;
}
//-----------------------------------------------------------------------------
// Returns the max dx support level achievable with this board
//-----------------------------------------------------------------------------
void CShaderDeviceMgrBase::ReadDXSupportLevels( HardwareCaps_t &caps )
{
// See if the file tells us otherwise
KeyValues *pCfg = ReadDXSupportKeyValues();
if ( !pCfg )
return;
KeyValues *pDeviceKeyValues = FindCardSpecificConfig( pCfg, caps.m_VendorID, caps.m_DeviceID );
if ( pDeviceKeyValues )
{
// First, set the max dx level
int nMaxDXSupportLevel = 0;
ReadInt( pDeviceKeyValues, "MaxDXLevel", 0, &nMaxDXSupportLevel );
if ( nMaxDXSupportLevel != 0 )
{
caps.m_nMaxDXSupportLevel = nMaxDXSupportLevel;
}
// Next, set the preferred dx level
int nDXSupportLevel = 0;
ReadInt( pDeviceKeyValues, "DXLevel", 0, &nDXSupportLevel );
if ( nDXSupportLevel != 0 )
{
caps.m_nDXSupportLevel = nDXSupportLevel;
// Don't slam up the dxlevel level to 92 on DX10 cards in OpenGL Linux/Win mode (otherwise Intel will get dxlevel 92 when we want 90)
if ( !( IsOpenGL() && ( IsLinux() || IsWindows() ) ) )
{
if ( caps.m_bDX10Card )
{
caps.m_nDXSupportLevel = 92;
}
}
}
else
{
caps.m_nDXSupportLevel = caps.m_nMaxDXSupportLevel;
}
}
}
//-----------------------------------------------------------------------------
// Loads the hardware caps, for cases in which the D3D caps lie or where we need to augment the caps
//-----------------------------------------------------------------------------
void CShaderDeviceMgrBase::LoadHardwareCaps( KeyValues *pGroup, HardwareCaps_t &caps )
{
if( !pGroup )
return;
// don't just blanket kill clip planes on POSIX, only shoot them down if we're running ARB, or asked for nouserclipplanes.
//FIXME need to take into account the caps bit that GLM can now provide, so NV can use normal clipping and ATI can fall back to fastclip.
if ( CommandLine()->FindParm("-arbmode") || CommandLine()->CheckParm( "-nouserclip" ) )
{
caps.m_UseFastClipping = true;
}
else
{
caps.m_UseFastClipping = ReadBool( pGroup, "NoUserClipPlanes", caps.m_UseFastClipping );
}
caps.m_bNeedsATICentroidHack = ReadBool( pGroup, "CentroidHack", caps.m_bNeedsATICentroidHack );
caps.m_bDisableShaderOptimizations = ReadBool( pGroup, "DisableShaderOptimizations", caps.m_bDisableShaderOptimizations );
}
//-----------------------------------------------------------------------------
// Reads in the hardware caps from the dxsupport.cfg file
//-----------------------------------------------------------------------------
void CShaderDeviceMgrBase::ReadHardwareCaps( HardwareCaps_t &caps, int nDxLevel )
{
KeyValues *pCfg = ReadDXSupportKeyValues();
if ( !pCfg )
return;
// Next, read the hardware caps for that dx support level.
KeyValues *pDxLevelKeyValues = FindDXLevelSpecificConfig( pCfg, nDxLevel );
// Look for a vendor specific line for a given dxlevel.
KeyValues *pDXLevelAndVendorKeyValue = FindDXLevelAndVendorSpecificConfig( pCfg, nDxLevel, caps.m_VendorID );
// Finally, override the hardware caps based on the specific card
KeyValues *pCardKeyValues = FindCardSpecificConfig( pCfg, caps.m_VendorID, caps.m_DeviceID );
// Apply
if( pCardKeyValues && ReadHexValue( pCardKeyValues, "MinDeviceID" ) == 0 && ReadHexValue( pCardKeyValues, "MaxDeviceID" ) == 0xffff )
{
// The card specific case is a catch all for device ids, so run it before running the dxlevel and card specific stuff.
LoadHardwareCaps( pDxLevelKeyValues, caps );
LoadHardwareCaps( pCardKeyValues, caps );
LoadHardwareCaps( pDXLevelAndVendorKeyValue, caps );
}
else
{
// The card specific case is a small range of cards, so run it last to override all other configs.
LoadHardwareCaps( pDxLevelKeyValues, caps );
// don't run this one since we have a specific config for this card.
// LoadHardwareCaps( pDXLevelAndVendorKeyValue, caps );
LoadHardwareCaps( pCardKeyValues, caps );
}
}
//-----------------------------------------------------------------------------
// Reads in ConVars + config variables
//-----------------------------------------------------------------------------
void CShaderDeviceMgrBase::LoadConfig( KeyValues *pKeyValues, KeyValues *pConfiguration )
{
if( !pKeyValues )
return;
if( CommandLine()->FindParm( "-debugdxsupport" ) )
{
CUtlBuffer tmpBuf;
pKeyValues->RecursiveSaveToFile( tmpBuf, 0 );
Warning( "%s\n", ( const char * )tmpBuf.Base() );
}
for( KeyValues *pGroup = pKeyValues->GetFirstSubKey(); pGroup; pGroup = pGroup->GetNextKey() )
{
AddKey( pConfiguration, pGroup );
}
}
//-----------------------------------------------------------------------------
// Computes amount of ram
//-----------------------------------------------------------------------------
static unsigned long GetRam()
{
MEMORYSTATUS stat;
GlobalMemoryStatus( &stat );
char buf[256];
V_snprintf( buf, sizeof( buf ), "GlobalMemoryStatus: %llu\n", (uint64)(stat.dwTotalPhys) );
Plat_DebugString( buf );
return (stat.dwTotalPhys / (1024 * 1024));
}
//-----------------------------------------------------------------------------
// Gets the recommended configuration associated with a particular dx level
//-----------------------------------------------------------------------------
bool CShaderDeviceMgrBase::GetRecommendedConfigurationInfo( int nAdapter, int nDXLevel, int nVendorID, int nDeviceID, KeyValues *pConfiguration )
{
LOCK_SHADERAPI();
const HardwareCaps_t& caps = GetHardwareCaps( nAdapter );
if ( nDXLevel == 0 )
{
nDXLevel = caps.m_nDXSupportLevel;
}
nDXLevel = GetClosestActualDXLevel( nDXLevel );
if ( nDXLevel > caps.m_nMaxDXSupportLevel )
return false;
KeyValues *pCfg = ReadDXSupportKeyValues();
if ( !pCfg )
return true;
// Look for a dxlevel specific line
KeyValues *pDxLevelKeyValues = FindDXLevelSpecificConfig( pCfg, nDXLevel );
// Look for a vendor specific line for a given dxlevel.
KeyValues *pDXLevelAndVendorKeyValue = FindDXLevelAndVendorSpecificConfig( pCfg, nDXLevel, nVendorID );
// Next, override with device-specific overrides
KeyValues *pCardKeyValues = FindCardSpecificConfig( pCfg, nVendorID, nDeviceID );
// Apply
if ( pCardKeyValues && ReadHexValue( pCardKeyValues, "MinDeviceID" ) == 0 && ReadHexValue( pCardKeyValues, "MaxDeviceID" ) == 0xffff )
{
// The card specific case is a catch all for device ids, so run it before running the dxlevel and card specific stuff.
LoadConfig( pDxLevelKeyValues, pConfiguration );
LoadConfig( pCardKeyValues, pConfiguration );
LoadConfig( pDXLevelAndVendorKeyValue, pConfiguration );
}
else
{
// The card specific case is a small range of cards, so run it last to override all other configs.
LoadConfig( pDxLevelKeyValues, pConfiguration );
// don't run this one since we have a specific config for this card.
// LoadConfig( pDXLevelAndVendorKeyValue, pConfiguration );
LoadConfig( pCardKeyValues, pConfiguration );
}
// Next, override with cpu-speed based overrides
const CPUInformation& pi = *GetCPUInformation();
int nCPUSpeedMhz = (int)(pi.m_Speed / 1000000.0f);
bool bAMD = Q_stristr( pi.m_szProcessorID, "amd" ) != NULL;
char buf[256];
V_snprintf( buf, sizeof( buf ), "CShaderDeviceMgrBase::GetRecommendedConfigurationInfo: CPU speed: %d MHz, Processor: %s\n", nCPUSpeedMhz, pi.m_szProcessorID );
Plat_DebugString( buf );
KeyValues *pCPUKeyValues = FindCPUSpecificConfig( pCfg, nCPUSpeedMhz, bAMD );
LoadConfig( pCPUKeyValues, pConfiguration );
// override with system memory-size based overrides
int nSystemMB = GetRam();
DevMsg( "%d MB of system RAM\n", nSystemMB );
KeyValues *pMemoryKeyValues = FindMemorySpecificConfig( pCfg, nSystemMB );
LoadConfig( pMemoryKeyValues, pConfiguration );
// override with texture memory-size based overrides
int nTextureMemorySize = GetVidMemBytes( nAdapter );
int vidMemMB = nTextureMemorySize / ( 1024 * 1024 );
KeyValues *pVidMemKeyValues = FindVidMemSpecificConfig( pCfg, vidMemMB );
if ( pVidMemKeyValues && nTextureMemorySize > 0 )
{
if ( CommandLine()->FindParm( "-debugdxsupport" ) )
{
CUtlBuffer tmpBuf;
pVidMemKeyValues->RecursiveSaveToFile( tmpBuf, 0 );
Warning( "pVidMemKeyValues\n%s\n", ( const char * )tmpBuf.Base() );
}
KeyValues *pMatPicmipKeyValue = pVidMemKeyValues->FindKey( "ConVar.mat_picmip", false );
// FIXME: Man, is this brutal. If it wasn't 1 day till orange box ship, I'd do something in dxsupport maybe
if ( pMatPicmipKeyValue && ( ( nDXLevel == caps.m_nMaxDXSupportLevel ) || ( vidMemMB < 100 ) ) )
{
KeyValues *pConfigMatPicMip = pConfiguration->FindKey( "ConVar.mat_picmip", false );
int newPicMip = pMatPicmipKeyValue->GetInt();
int oldPicMip = pConfigMatPicMip ? pConfigMatPicMip->GetInt() : 0;
pConfiguration->SetInt( "ConVar.mat_picmip", max( newPicMip, oldPicMip ) );
}
}
// Hack to slam the mat_dxlevel ConVar to match the requested dxlevel
pConfiguration->SetInt( "ConVar.mat_dxlevel", nDXLevel );
if ( CommandLine()->FindParm( "-debugdxsupport" ) )
{
CUtlBuffer tmpBuf;
pConfiguration->RecursiveSaveToFile( tmpBuf, 0 );
Warning( "final config:\n%s\n", ( const char * )tmpBuf.Base() );
}
return true;
}
//-----------------------------------------------------------------------------
// Gets recommended congifuration for a particular adapter at a particular dx level
//-----------------------------------------------------------------------------
bool CShaderDeviceMgrBase::GetRecommendedConfigurationInfo( int nAdapter, int nDXLevel, KeyValues *pCongifuration )
{
Assert( nAdapter >= 0 && nAdapter <= GetAdapterCount() );
MaterialAdapterInfo_t info;
GetAdapterInfo( nAdapter, info );
return GetRecommendedConfigurationInfo( nAdapter, nDXLevel, info.m_VendorID, info.m_DeviceID, pCongifuration );
}
//-----------------------------------------------------------------------------
// Returns only valid dx levels
//-----------------------------------------------------------------------------
int CShaderDeviceMgrBase::GetClosestActualDXLevel( int nDxLevel ) const
{
if ( nDxLevel < ABSOLUTE_MINIMUM_DXLEVEL )
return ABSOLUTE_MINIMUM_DXLEVEL;
if ( nDxLevel == 80 )
return 80;
if ( nDxLevel <= 89 )
return 81;
if ( IsOpenGL() )
{
return ( nDxLevel <= 90 ) ? 90 : 92;
}
if ( nDxLevel <= 94 )
return 90;
if ( IsX360() && nDxLevel <= 98 )
return 98;
if ( nDxLevel <= 99 )
return 95;
return 100;
}
//-----------------------------------------------------------------------------
// Mode change callback
//-----------------------------------------------------------------------------
void CShaderDeviceMgrBase::AddModeChangeCallback( ShaderModeChangeCallbackFunc_t func )
{
LOCK_SHADERAPI();
Assert( func && m_ModeChangeCallbacks.Find( func ) < 0 );
m_ModeChangeCallbacks.AddToTail( func );
}
void CShaderDeviceMgrBase::RemoveModeChangeCallback( ShaderModeChangeCallbackFunc_t func )
{
LOCK_SHADERAPI();
m_ModeChangeCallbacks.FindAndRemove( func );
}
void CShaderDeviceMgrBase::InvokeModeChangeCallbacks()
{
int nCount = m_ModeChangeCallbacks.Count();
for ( int i = 0; i < nCount; ++i )
{
m_ModeChangeCallbacks[i]();
}
}
//-----------------------------------------------------------------------------
// Factory to return from SetMode
//-----------------------------------------------------------------------------
void* CShaderDeviceMgrBase::ShaderInterfaceFactory( const char *pInterfaceName, int *pReturnCode )
{
if ( pReturnCode )
{
*pReturnCode = IFACE_OK;
}
if ( !Q_stricmp( pInterfaceName, SHADER_DEVICE_INTERFACE_VERSION ) )
return static_cast< IShaderDevice* >( g_pShaderDevice );
if ( !Q_stricmp( pInterfaceName, SHADERAPI_INTERFACE_VERSION ) )
return static_cast< IShaderAPI* >( g_pShaderAPI );
if ( !Q_stricmp( pInterfaceName, SHADERSHADOW_INTERFACE_VERSION ) )
return static_cast< IShaderShadow* >( g_pShaderShadow );
if ( pReturnCode )
{
*pReturnCode = IFACE_FAILED;
}
return NULL;
}
//-----------------------------------------------------------------------------
//
// The Base implementation of the shader device
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------
CShaderDeviceBase::CShaderDeviceBase()
{
m_bInitialized = false;
m_nAdapter = -1;
m_hWnd = NULL;
m_hWndCookie = NULL;
m_dwThreadId = ThreadGetCurrentId();
}
CShaderDeviceBase::~CShaderDeviceBase()
{
}
void CShaderDeviceBase::SetCurrentThreadAsOwner()
{
m_dwThreadId = ThreadGetCurrentId();
}
void CShaderDeviceBase::RemoveThreadOwner()
{
m_dwThreadId = 0xFFFFFFFF;
}
bool CShaderDeviceBase::ThreadOwnsDevice()
{
if ( ThreadGetCurrentId() == m_dwThreadId )
return true;
return false;
}
// Methods of IShaderDevice
ImageFormat CShaderDeviceBase::GetBackBufferFormat() const
{
return IMAGE_FORMAT_UNKNOWN;
}
int CShaderDeviceBase::StencilBufferBits() const
{
return 0;
}
bool CShaderDeviceBase::IsAAEnabled() const
{
return false;
}
//-----------------------------------------------------------------------------
// Methods for interprocess communication to release resources
//-----------------------------------------------------------------------------
#define MATERIAL_SYSTEM_WINDOW_ID 0xFEEDDEAD
#ifdef USE_ACTUAL_DX
static VD3DHWND GetTopmostParentWindow( VD3DHWND hWnd )
{
// Find the parent window...
VD3DHWND hParent = GetParent( hWnd );
while ( hParent )
{
hWnd = hParent;
hParent = GetParent( hWnd );
}
return hWnd;
}
static BOOL CALLBACK EnumChildWindowsProc( VD3DHWND hWnd, LPARAM lParam )
{
int windowId = GetWindowLongPtr( hWnd, GWLP_USERDATA );
if (windowId == MATERIAL_SYSTEM_WINDOW_ID)
{
COPYDATASTRUCT copyData;
copyData.dwData = lParam;
copyData.cbData = 0;
copyData.lpData = 0;
SendMessage(hWnd, WM_COPYDATA, 0, (LPARAM)&copyData);
}
return TRUE;
}
static BOOL CALLBACK EnumWindowsProc( VD3DHWND hWnd, LPARAM lParam )
{
EnumChildWindows( hWnd, EnumChildWindowsProc, lParam );
return TRUE;
}
static BOOL CALLBACK EnumWindowsProcNotThis( VD3DHWND hWnd, LPARAM lParam )
{
if ( g_pShaderDevice && ( GetTopmostParentWindow( (VD3DHWND)g_pShaderDevice->GetIPCHWnd() ) == hWnd ) )
return TRUE;
EnumChildWindows( hWnd, EnumChildWindowsProc, lParam );
return TRUE;
}
#endif
//-----------------------------------------------------------------------------
// Adds a hook to let us know when other instances are setting the mode
//-----------------------------------------------------------------------------
#ifdef STRICT
#define WINDOW_PROC WNDPROC
#else
#define WINDOW_PROC FARPROC
#endif
#ifdef USE_ACTUAL_DX
static LRESULT CALLBACK ShaderDX8WndProc(VD3DHWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
#if !defined( _X360 )
// FIXME: Should these IPC messages tell when an app has focus or not?
// If so, we'd want to totally disable the shader api layer when an app
// doesn't have focus.
// Look for the special IPC message that tells us we're trying to set
// the mode....
switch(msg)
{
case WM_COPYDATA:
{
if ( !g_pShaderDevice )
break;
COPYDATASTRUCT* pData = (COPYDATASTRUCT*)lParam;
// that number is our magic cookie number
if ( pData->dwData == CShaderDeviceBase::RELEASE_MESSAGE )
{
g_pShaderDevice->OtherAppInitializing(true);
}
else if ( pData->dwData == CShaderDeviceBase::REACQUIRE_MESSAGE )
{
g_pShaderDevice->OtherAppInitializing(false);
}
else if ( pData->dwData == CShaderDeviceBase::EVICT_MESSAGE )
{
g_pShaderDevice->EvictManagedResourcesInternal( );
}
}
break;
}
return DefWindowProc( hWnd, msg, wParam, lParam );
#endif
}
#endif
//-----------------------------------------------------------------------------
// Install, remove ability to talk to other shaderapi apps
//-----------------------------------------------------------------------------
void CShaderDeviceBase::InstallWindowHook( void* hWnd )
{
Assert( m_hWndCookie == NULL );
#ifdef USE_ACTUAL_DX
#if !defined( _X360 )
VD3DHWND hParent = GetTopmostParentWindow( (VD3DHWND)hWnd );
// Attach a child window to the parent; we're gonna store special info there
// We can't use the USERDATA, cause other apps may want to use this.
HINSTANCE hInst = (HINSTANCE)GetWindowLongPtr( hParent, GWLP_HINSTANCE );
WNDCLASS wc;
memset( &wc, 0, sizeof( wc ) );
wc.style = CS_NOCLOSE | CS_PARENTDC;
wc.lpfnWndProc = ShaderDX8WndProc;
wc.hInstance = hInst;
wc.lpszClassName = "shaderdx8";
// In case an old one is sitting around still...
UnregisterClass( "shaderdx8", hInst );
RegisterClass( &wc );
// Create the window
m_hWndCookie = CreateWindow( "shaderdx8", "shaderdx8", WS_CHILD,
0, 0, 0, 0, hParent, NULL, hInst, NULL );
// Marks it as a material system window
SetWindowLongPtr( (VD3DHWND)m_hWndCookie, GWLP_USERDATA, MATERIAL_SYSTEM_WINDOW_ID );
#endif
#endif
}
void CShaderDeviceBase::RemoveWindowHook( void* hWnd )
{
#ifdef USE_ACTUAL_DX
#if !defined( _X360 )
if ( m_hWndCookie )
{
DestroyWindow( (VD3DHWND)m_hWndCookie );
m_hWndCookie = 0;
}
VD3DHWND hParent = GetTopmostParentWindow( (VD3DHWND)hWnd );
HINSTANCE hInst = (HINSTANCE)GetWindowLongPtr( hParent, GWLP_HINSTANCE );
UnregisterClass( "shaderdx8", hInst );
#endif
#endif
}
//-----------------------------------------------------------------------------
// Sends a message to other shaderapi applications
//-----------------------------------------------------------------------------
void CShaderDeviceBase::SendIPCMessage( IPCMessage_t msg )
{
#ifdef USE_ACTUAL_DX
#if !defined( _X360 )
// Gotta send this to all windows, since we don't know which ones
// are material system apps...
if ( msg != EVICT_MESSAGE )
{
EnumWindows( EnumWindowsProc, (DWORD)msg );
}
else
{
EnumWindows( EnumWindowsProcNotThis, (DWORD)msg );
}
#endif
#endif
}
//-----------------------------------------------------------------------------
// Find view
//-----------------------------------------------------------------------------
int CShaderDeviceBase::FindView( void* hWnd ) const
{
/* FIXME: Is this necessary?
// Look for the view in the list of views
for (int i = m_Views.Count(); --i >= 0; )
{
if (m_Views[i].m_HWnd == (VD3DHWND)hwnd)
return i;
}
*/
return -1;
}
//-----------------------------------------------------------------------------
// Creates a child window
//-----------------------------------------------------------------------------
bool CShaderDeviceBase::AddView( void* hWnd )
{
LOCK_SHADERAPI();
/*
// If we haven't created a device yet
if (!Dx9Device())
return false;
// Make sure no duplicate hwnds...
if (FindView(hwnd) >= 0)
return false;
// In this case, we need to create the device; this is our
// default swap chain. This here says we're gonna use a part of the
// existing buffer and just grab that.
int view = m_Views.AddToTail();
m_Views[view].m_HWnd = (VD3DHWND)hwnd;
// memcpy( &m_Views[view].m_PresentParamters, m_PresentParameters, sizeof(m_PresentParamters) );
HRESULT hr;
hr = Dx9Device()->CreateAdditionalSwapChain( &m_PresentParameters,
&m_Views[view].m_pSwapChain );
return !FAILED(hr);
*/
return true;
}
void CShaderDeviceBase::RemoveView( void* hWnd )
{
LOCK_SHADERAPI();
/*
// Look for the view in the list of views
int i = FindView(hwnd);
if (i >= 0)
{
// FIXME m_Views[i].m_pSwapChain->Release();
m_Views.FastRemove(i);
}
*/
}
//-----------------------------------------------------------------------------
// Activates a child window
//-----------------------------------------------------------------------------
void CShaderDeviceBase::SetView( void* hWnd )
{
LOCK_SHADERAPI();
ShaderViewport_t viewport;
g_pShaderAPI->GetViewports( &viewport, 1 );
// Get the window (*not* client) rect of the view window
m_ViewHWnd = (VD3DHWND)hWnd;
GetWindowSize( m_nWindowWidth, m_nWindowHeight );
// Reset the viewport (takes into account the view rect)
// Don't need to set the viewport if it's not ready
g_pShaderAPI->SetViewports( 1, &viewport );
}
//-----------------------------------------------------------------------------
// Gets the window size
//-----------------------------------------------------------------------------
void CShaderDeviceBase::GetWindowSize( int& nWidth, int& nHeight ) const
{
#if defined( USE_SDL )
// this matches up to what the threaded material system does
g_pShaderAPI->GetBackBufferDimensions( nWidth, nHeight );
#else
// If the window was minimized last time swap buffers happened, or if it's iconic now,
// return 0 size
#ifdef _WIN32
if ( !m_bIsMinimized && !IsIconic( ( HWND )m_hWnd ) )
#else
if ( !m_bIsMinimized && !IsIconic( (VD3DHWND)m_hWnd ) )
#endif
{
// NOTE: Use the 'current view' (which may be the same as the main window)
RECT rect;
#ifdef _WIN32
GetClientRect( ( HWND )m_ViewHWnd, &rect );
#else
toglGetClientRect( (VD3DHWND)m_ViewHWnd, &rect );
#endif
nWidth = rect.right - rect.left;
nHeight = rect.bottom - rect.top;
}
else
{
nWidth = nHeight = 0;
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink