1312 lines
39 KiB
C++
1312 lines
39 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "togl/rendermechanism.h"
|
|
#include "hardwareconfig.h"
|
|
#include "shaderapi/ishaderutil.h"
|
|
#include "shaderapi_global.h"
|
|
#include "materialsystem/materialsystem_config.h"
|
|
#include "tier1/convar.h"
|
|
#include "shaderdevicebase.h"
|
|
#include "tier0/icommandline.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Hardware Config!
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
static CHardwareConfig s_HardwareConfig;
|
|
CHardwareConfig *g_pHardwareConfig = &s_HardwareConfig;
|
|
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CHardwareConfig, IMaterialSystemHardwareConfig,
|
|
MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION, s_HardwareConfig )
|
|
|
|
template<typename T>
|
|
static void ccs_create_convar_from_hwconfig( const T& val, const char *pName )
|
|
{
|
|
int nValue = static_cast<int>( val );
|
|
|
|
ConVar *pConVar = g_pCVar->FindVar( pName );
|
|
if ( pConVar )
|
|
{
|
|
pConVar->SetValue( nValue );
|
|
}
|
|
else
|
|
{
|
|
// Don't care if this leaks - this is only used for development
|
|
pConVar = new ConVar( pName, "" );
|
|
}
|
|
if ( !nValue )
|
|
pConVar->SetValue( "0" );
|
|
else
|
|
pConVar->SetValue( nValue );
|
|
}
|
|
|
|
static void ccs_create_convar_from_hwconfig( const char *pVal, const char *pName )
|
|
{
|
|
ConVar *pConVar = g_pCVar->FindVar( pName );
|
|
if ( pConVar )
|
|
{
|
|
pConVar->SetValue( pVal );
|
|
}
|
|
else
|
|
{
|
|
// Don't care if this leaks - this is only used for development
|
|
pConVar = new ConVar( pName, "" );
|
|
}
|
|
pConVar->SetValue( pVal );
|
|
}
|
|
|
|
CON_COMMAND_F( ccs_create_convars_from_hwconfig, "Create convars from the current hardware config, useful for diffing purposes", FCVAR_CHEAT )
|
|
{
|
|
if ( !g_pHardwareConfig )
|
|
return;
|
|
|
|
const HardwareCaps_t &caps = g_pHardwareConfig->CapsForEdit();
|
|
|
|
#define HWCFG( Name ) ccs_create_convar_from_hwconfig( caps.Name, #Name )
|
|
HWCFG( m_NumTextureStages );
|
|
HWCFG( m_nMaxAnisotropy );
|
|
HWCFG( m_MaxTextureWidth );
|
|
HWCFG( m_MaxTextureHeight );
|
|
HWCFG( m_MaxTextureDepth );
|
|
HWCFG( m_MaxTextureAspectRatio );
|
|
HWCFG( m_MaxPrimitiveCount );
|
|
HWCFG( m_NumPixelShaderConstants );
|
|
HWCFG( m_NumBooleanPixelShaderConstants );
|
|
HWCFG( m_NumIntegerPixelShaderConstants );
|
|
HWCFG( m_NumVertexShaderConstants );
|
|
HWCFG( m_NumBooleanVertexShaderConstants );
|
|
HWCFG( m_NumIntegerVertexShaderConstants );
|
|
HWCFG( m_TextureMemorySize );
|
|
HWCFG( m_MaxNumLights );
|
|
HWCFG( m_MaxBlendMatrices );
|
|
HWCFG( m_MaxBlendMatrixIndices );
|
|
HWCFG( m_MaxVertexShaderBlendMatrices );
|
|
HWCFG( m_MaxUserClipPlanes );
|
|
HWCFG( m_HDRType );
|
|
HWCFG( m_pShaderDLL );
|
|
HWCFG( m_ShadowDepthTextureFormat );
|
|
HWCFG( m_NullTextureFormat );
|
|
HWCFG( m_nVertexTextureCount );
|
|
HWCFG( m_nMaxVertexTextureDimension );
|
|
HWCFG( m_AlphaToCoverageState );
|
|
HWCFG( m_AlphaToCoverageEnableValue );
|
|
HWCFG( m_AlphaToCoverageDisableValue );
|
|
HWCFG( m_nMaxViewports );
|
|
HWCFG( m_flMinGammaControlPoint );
|
|
HWCFG( m_flMaxGammaControlPoint );
|
|
HWCFG( m_nGammaControlPointCount );
|
|
HWCFG( m_MaxVertexShader30InstructionSlots );
|
|
HWCFG( m_MaxPixelShader30InstructionSlots );
|
|
HWCFG( m_MaxSimultaneousRenderTargets );
|
|
HWCFG( m_bDeviceOk );
|
|
HWCFG( m_HasSetDeviceGammaRamp );
|
|
HWCFG( m_SupportsVertexShaders );
|
|
HWCFG( m_SupportsVertexShaders_2_0 );
|
|
HWCFG( m_SupportsPixelShaders );
|
|
HWCFG( m_SupportsPixelShaders_1_4 );
|
|
HWCFG( m_SupportsPixelShaders_2_0 );
|
|
HWCFG( m_SupportsPixelShaders_2_b );
|
|
HWCFG( m_SupportsShaderModel_3_0 );
|
|
HWCFG( m_bSupportsAnisotropicFiltering );
|
|
HWCFG( m_bSupportsMagAnisotropicFiltering );
|
|
HWCFG( m_bSupportsVertexTextures );
|
|
HWCFG( m_ZBiasAndSlopeScaledDepthBiasSupported );
|
|
HWCFG( m_SupportsMipmapping );
|
|
HWCFG( m_SupportsOverbright );
|
|
HWCFG( m_SupportsCubeMaps );
|
|
HWCFG( m_SupportsHardwareLighting );
|
|
HWCFG( m_SupportsMipmappedCubemaps );
|
|
HWCFG( m_SupportsNonPow2Textures );
|
|
HWCFG( m_PreferDynamicTextures );
|
|
HWCFG( m_HasProjectedBumpEnv );
|
|
HWCFG( m_SupportsSRGB );
|
|
HWCFG( m_bSupportsSpheremapping );
|
|
HWCFG( m_UseFastClipping );
|
|
HWCFG( m_bNeedsATICentroidHack );
|
|
HWCFG( m_bDisableShaderOptimizations );
|
|
HWCFG( m_bColorOnSecondStream );
|
|
HWCFG( m_bSupportsStreamOffset );
|
|
HWCFG( m_bFogColorSpecifiedInLinearSpace );
|
|
HWCFG( m_bFogColorAlwaysLinearSpace );
|
|
HWCFG( m_bSupportsAlphaToCoverage );
|
|
HWCFG( m_bSupportsShadowDepthTextures );
|
|
HWCFG( m_bSupportsFetch4 );
|
|
HWCFG( m_bSoftwareVertexProcessing );
|
|
HWCFG( m_bScissorSupported );
|
|
HWCFG( m_bSupportsFloat32RenderTargets );
|
|
HWCFG( m_bSupportsBorderColor );
|
|
HWCFG( m_bDX10Card );
|
|
HWCFG( m_bDX10Blending );
|
|
HWCFG( m_bSupportsStaticControlFlow );
|
|
HWCFG( m_FakeSRGBWrite );
|
|
HWCFG( m_CanDoSRGBReadFromRTs );
|
|
HWCFG( m_bSupportsGLMixedSizeTargets );
|
|
HWCFG( m_bCanStretchRectFromTextures );
|
|
|
|
HWCFG( m_MaxHDRType );
|
|
#undef HWCFG
|
|
}
|
|
|
|
CHardwareConfig::CHardwareConfig()
|
|
{
|
|
memset( &m_Caps, 0, sizeof( HardwareCaps_t ) );
|
|
memset( &m_ActualCaps, 0, sizeof( HardwareCaps_t ) );
|
|
memset( &m_UnOverriddenCaps, 0, sizeof( HardwareCaps_t ) );
|
|
|
|
#ifdef POSIX
|
|
GLMPRINTF((" CHardwareConfig::CHardwareConfig setting m_bHDREnabled to false on %8x", this ));
|
|
#endif
|
|
|
|
m_bHDREnabled = false;
|
|
|
|
// FIXME: This is kind of a hack to deal with DX8 worldcraft startup.
|
|
// We can at least have this much texture
|
|
m_Caps.m_MaxTextureWidth = m_Caps.m_MaxTextureHeight = m_Caps.m_MaxTextureDepth = 256;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CHardwareConfig::GetHDREnabled( void ) const
|
|
{
|
|
// printf("\n CHardwareConfig::GetHDREnabled returning m_bHDREnabled value of %s on %8x", m_bHDREnabled?"true":"false", this );
|
|
return m_bHDREnabled;
|
|
}
|
|
|
|
void CHardwareConfig::SetHDREnabled( bool bEnable )
|
|
{
|
|
// printf("\n CHardwareConfig::SetHDREnabled setting m_bHDREnabled to value of %s on %8x", bEnable?"true":"false", this );
|
|
m_bHDREnabled = bEnable;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets the recommended configuration associated with a particular dx level
|
|
//-----------------------------------------------------------------------------
|
|
void CHardwareConfig::ForceCapsToDXLevel( HardwareCaps_t *pCaps, int nDxLevel, const HardwareCaps_t &actualCaps )
|
|
{
|
|
if ( !IsPC() || nDxLevel >= 100 )
|
|
return;
|
|
|
|
pCaps->m_nDXSupportLevel = nDxLevel;
|
|
switch( nDxLevel )
|
|
{
|
|
case 60:
|
|
// NOTE: Prior to dx9, numsamplers = num texture stages
|
|
pCaps->m_NumTextureStages = min( 2, actualCaps.m_NumTextureStages );
|
|
pCaps->m_NumSamplers = pCaps->m_NumTextureStages;
|
|
pCaps->m_SupportsVertexShaders = false;
|
|
pCaps->m_SupportsVertexShaders_2_0 = false;
|
|
pCaps->m_SupportsPixelShaders = false;
|
|
pCaps->m_SupportsPixelShaders_1_4 = false;
|
|
pCaps->m_SupportsPixelShaders_2_0 = false;
|
|
pCaps->m_SupportsPixelShaders_2_b = false;
|
|
pCaps->m_SupportsShaderModel_3_0 = false;
|
|
pCaps->m_bSupportsStaticControlFlow = false;
|
|
pCaps->m_SupportsCompressedTextures = COMPRESSED_TEXTURES_OFF;
|
|
pCaps->m_SupportsCompressedVertices = VERTEX_COMPRESSION_NONE;
|
|
pCaps->m_bSupportsAnisotropicFiltering = false;
|
|
pCaps->m_bSupportsMagAnisotropicFiltering = false;
|
|
pCaps->m_nMaxAnisotropy = 1;
|
|
pCaps->m_MaxTextureWidth = max( 256, pCaps->m_MaxTextureWidth );
|
|
pCaps->m_MaxTextureHeight = max( 256, pCaps->m_MaxTextureHeight );
|
|
pCaps->m_MaxTextureDepth = max( 256, pCaps->m_MaxTextureDepth );
|
|
// m_MaxTextureAspectRatio;
|
|
// int m_MaxPrimitiveCount;
|
|
pCaps->m_ZBiasAndSlopeScaledDepthBiasSupported = false;
|
|
// pCaps->m_SupportsMipmapping =
|
|
// bool m_SupportsOverbright;
|
|
pCaps->m_SupportsCubeMaps = false;
|
|
pCaps->m_NumPixelShaderConstants = 0;
|
|
pCaps->m_NumBooleanPixelShaderConstants = 0;
|
|
pCaps->m_NumIntegerPixelShaderConstants = 0;
|
|
pCaps->m_NumVertexShaderConstants = 0;
|
|
pCaps->m_NumBooleanVertexShaderConstants = 0;
|
|
pCaps->m_NumIntegerVertexShaderConstants = 0;
|
|
pCaps->m_NumBooleanPixelShaderConstants = 0;
|
|
pCaps->m_NumIntegerPixelShaderConstants = 0;
|
|
pCaps->m_TextureMemorySize = 32 * 1024 * 1024;
|
|
pCaps->m_MaxNumLights = 0;
|
|
pCaps->m_SupportsHardwareLighting = 0;
|
|
pCaps->m_MaxBlendMatrices = 0;
|
|
pCaps->m_MaxBlendMatrixIndices = 0;
|
|
pCaps->m_MaxVertexShaderBlendMatrices = 0;
|
|
pCaps->m_SupportsMipmappedCubemaps = false;
|
|
pCaps->m_SupportsNonPow2Textures = false;
|
|
// pCaps->m_DXSupportLevel = 60;
|
|
pCaps->m_PreferDynamicTextures = false;
|
|
pCaps->m_HasProjectedBumpEnv = false;
|
|
pCaps->m_MaxUserClipPlanes = 0;
|
|
pCaps->m_SupportsSRGB = false;
|
|
pCaps->m_FakeSRGBWrite = false;
|
|
pCaps->m_CanDoSRGBReadFromRTs = true;
|
|
pCaps->m_bSupportsGLMixedSizeTargets = false;
|
|
pCaps->m_HDRType = HDR_TYPE_NONE;
|
|
// pCaps->m_bSupportsSpheremapping = true;
|
|
pCaps->m_UseFastClipping = true;
|
|
pCaps->m_bNeedsATICentroidHack = false;
|
|
pCaps->m_bColorOnSecondStream = false;
|
|
pCaps->m_bSupportsStreamOffset = false;
|
|
pCaps->m_bFogColorSpecifiedInLinearSpace = false;
|
|
pCaps->m_bFogColorAlwaysLinearSpace = false;
|
|
pCaps->m_bSupportsAlphaToCoverage = false;
|
|
pCaps->m_bSupportsShadowDepthTextures = false;
|
|
pCaps->m_bSupportsFetch4 = false;
|
|
pCaps->m_bSupportsBorderColor = false;
|
|
// m_bSoftwareVertexProcessing
|
|
pCaps->m_nVertexTextureCount = 0;
|
|
pCaps->m_nMaxVertexTextureDimension = 0;
|
|
pCaps->m_bSupportsVertexTextures = false;
|
|
pCaps->m_nMaxViewports = 1;
|
|
// m_bScissorSupported
|
|
pCaps->m_bSupportsFloat32RenderTargets = false;
|
|
// ImageFormat m_ShadowDepthTextureFormat;
|
|
// ImageFormat m_NullTextureFormat;
|
|
// m_AlphaToCoverageState;
|
|
// m_AlphaToCoverageEnableValue;
|
|
// m_AlphaToCoverageDisableValue;
|
|
// m_flMinGammaControlPoint
|
|
// m_flMaxGammaControlPoint
|
|
// m_nGammaControlPointCount
|
|
pCaps->m_MaxVertexShader30InstructionSlots = 0;
|
|
pCaps->m_MaxPixelShader30InstructionSlots = 0;
|
|
pCaps->m_bCanStretchRectFromTextures = false;
|
|
break;
|
|
|
|
case 70:
|
|
// NOTE: Prior to dx9, numsamplers = num texture stages
|
|
pCaps->m_NumTextureStages = min( 2, actualCaps.m_NumTextureStages );
|
|
pCaps->m_NumSamplers = pCaps->m_NumTextureStages;
|
|
pCaps->m_SupportsVertexShaders = false;
|
|
pCaps->m_SupportsVertexShaders_2_0 = false;
|
|
pCaps->m_SupportsPixelShaders = false;
|
|
pCaps->m_SupportsPixelShaders_1_4 = false;
|
|
pCaps->m_SupportsPixelShaders_2_0 = false;
|
|
pCaps->m_SupportsPixelShaders_2_b = false;
|
|
pCaps->m_SupportsShaderModel_3_0 = false;
|
|
pCaps->m_bSupportsStaticControlFlow = false;
|
|
// pCaps->m_SupportsCompressedTextures = true;
|
|
pCaps->m_SupportsCompressedVertices = VERTEX_COMPRESSION_NONE;
|
|
pCaps->m_bSupportsAnisotropicFiltering = false;
|
|
pCaps->m_bSupportsMagAnisotropicFiltering = false;
|
|
pCaps->m_nMaxAnisotropy = 1;
|
|
// pCaps->m_MaxTextureWidth = max( 256, pCaps->m_MaxTextureWidth );
|
|
// pCaps->m_MaxTextureHeight = max( 256, pCaps->m_MaxTextureHeight );
|
|
// pCaps->m_MaxTextureDepth = max( 256, pCaps->m_MaxTextureDepth );
|
|
// m_MaxTextureAspectRatio;
|
|
// int m_MaxPrimitiveCount;
|
|
pCaps->m_ZBiasAndSlopeScaledDepthBiasSupported = false;
|
|
// pCaps->m_SupportsMipmapping =
|
|
// bool m_SupportsOverbright;
|
|
// pCaps->m_SupportsCubeMaps = false;
|
|
pCaps->m_NumPixelShaderConstants = 0;
|
|
pCaps->m_NumBooleanPixelShaderConstants = 0;
|
|
pCaps->m_NumIntegerPixelShaderConstants = 0;
|
|
pCaps->m_NumBooleanPixelShaderConstants = 0;
|
|
pCaps->m_NumIntegerPixelShaderConstants = 0;
|
|
pCaps->m_NumVertexShaderConstants = 0;
|
|
pCaps->m_NumBooleanVertexShaderConstants = 0;
|
|
pCaps->m_NumIntegerVertexShaderConstants = 0;
|
|
pCaps->m_TextureMemorySize = 32 * 1024 * 1024;
|
|
pCaps->m_MaxNumLights = 2;
|
|
pCaps->m_SupportsHardwareLighting = 1;
|
|
pCaps->m_MaxBlendMatrices = 0;
|
|
pCaps->m_MaxBlendMatrixIndices = 0;
|
|
pCaps->m_MaxVertexShaderBlendMatrices = 0;
|
|
pCaps->m_SupportsMipmappedCubemaps = false;
|
|
pCaps->m_SupportsNonPow2Textures = false;
|
|
pCaps->m_nDXSupportLevel = 70;
|
|
pCaps->m_PreferDynamicTextures = false;
|
|
pCaps->m_HasProjectedBumpEnv = false;
|
|
pCaps->m_MaxUserClipPlanes = 0;
|
|
pCaps->m_SupportsSRGB = false;
|
|
pCaps->m_FakeSRGBWrite = false;
|
|
pCaps->m_CanDoSRGBReadFromRTs = true;
|
|
pCaps->m_bSupportsGLMixedSizeTargets = false;
|
|
pCaps->m_HDRType = HDR_TYPE_NONE;
|
|
// pCaps->m_bSupportsSpheremapping = true;
|
|
pCaps->m_UseFastClipping = true;
|
|
pCaps->m_bNeedsATICentroidHack = false;
|
|
// pCaps->m_bColorOnSecondStream = false; // dont' force this!
|
|
pCaps->m_bSupportsStreamOffset = false;
|
|
pCaps->m_bFogColorSpecifiedInLinearSpace = false;
|
|
pCaps->m_bFogColorAlwaysLinearSpace = false;
|
|
pCaps->m_bSupportsAlphaToCoverage = false;
|
|
pCaps->m_bSupportsShadowDepthTextures = false;
|
|
pCaps->m_bSupportsFetch4 = false;
|
|
pCaps->m_bSupportsBorderColor = false;
|
|
// m_bSoftwareVertexProcessing
|
|
pCaps->m_nVertexTextureCount = 0;
|
|
pCaps->m_nMaxVertexTextureDimension = 0;
|
|
pCaps->m_bSupportsVertexTextures = false;
|
|
pCaps->m_nMaxViewports = 1;
|
|
// m_bScissorSupported
|
|
pCaps->m_bSupportsFloat32RenderTargets = false;
|
|
pCaps->m_bDX10Card = false;
|
|
pCaps->m_bDX10Blending = false;
|
|
pCaps->m_bCanStretchRectFromTextures = false;
|
|
break;
|
|
|
|
case 80:
|
|
// NOTE: Prior to dx9, numsamplers = num texture stages
|
|
// We clamp num texture stages to 2, though, since we never use
|
|
// fixed-function shaders with more than 2 texture stages
|
|
pCaps->m_NumTextureStages = min( 2, actualCaps.m_NumTextureStages );
|
|
pCaps->m_NumSamplers = min( 4, actualCaps.m_NumTextureStages );
|
|
// pCaps->m_SupportsVertexShaders = true;
|
|
pCaps->m_SupportsVertexShaders_2_0 = false;
|
|
// pCaps->m_SupportsPixelShaders = false;
|
|
pCaps->m_SupportsPixelShaders_1_4 = false;
|
|
pCaps->m_SupportsPixelShaders_2_0 = false;
|
|
pCaps->m_SupportsPixelShaders_2_b = false;
|
|
pCaps->m_SupportsShaderModel_3_0 = false;
|
|
pCaps->m_bSupportsStaticControlFlow = false;
|
|
// pCaps->m_SupportsCompressedTextures = true;
|
|
pCaps->m_SupportsCompressedVertices = VERTEX_COMPRESSION_NONE;
|
|
// pCaps->m_bSupportsAnisotropicFiltering = false;
|
|
// pCaps->m_bSupportsMagAnisotropicFiltering = false;
|
|
// pCaps->m_nMaxAnisotropy = 1;
|
|
// pCaps->m_MaxTextureWidth = max( 256, pCaps->m_MaxTextureWidth );
|
|
// pCaps->m_MaxTextureHeight = max( 256, pCaps->m_MaxTextureHeight );
|
|
// pCaps->m_MaxTextureDepth = max( 256, pCaps->m_MaxTextureDepth );
|
|
// m_MaxTextureAspectRatio;
|
|
// int m_MaxPrimitiveCount;
|
|
// pCaps->m_ZBiasAndSlopeScaledDepthBiasSupported = false;
|
|
// pCaps->m_SupportsMipmapping =
|
|
// bool m_SupportsOverbright;
|
|
// pCaps->m_SupportsCubeMaps = false;
|
|
pCaps->m_NumPixelShaderConstants = 8;
|
|
pCaps->m_NumVertexShaderConstants = min( 96, pCaps->m_NumVertexShaderConstants );
|
|
pCaps->m_NumBooleanVertexShaderConstants = 0;
|
|
pCaps->m_NumIntegerVertexShaderConstants = 0;
|
|
pCaps->m_NumBooleanPixelShaderConstants = 0;
|
|
pCaps->m_NumIntegerPixelShaderConstants = 0;
|
|
// pCaps->m_TextureMemorySize = 32 * 1024 * 1024;
|
|
// pCaps->m_MaxNumLights = 0;
|
|
// pCaps->m_SupportsHardwareLighting = 0;
|
|
// pCaps->m_MaxBlendMatrices = 0;
|
|
// pCaps->m_MaxBlendMatrixIndices = 0;
|
|
pCaps->m_MaxVertexShaderBlendMatrices = min( 16, pCaps->m_MaxVertexShaderBlendMatrices );
|
|
// pCaps->m_SupportsMipmappedCubemaps = false;
|
|
// pCaps->m_SupportsNonPow2Textures = false;
|
|
pCaps->m_nDXSupportLevel = 80;
|
|
// pCaps->m_PreferDynamicTextures = false;
|
|
// pCaps->m_HasProjectedBumpEnv = false;
|
|
// pCaps->m_MaxUserClipPlanes = 0;
|
|
pCaps->m_bSupportsGLMixedSizeTargets = false;
|
|
pCaps->m_HDRType = HDR_TYPE_NONE;
|
|
// pCaps->m_bSupportsSpheremapping = true;
|
|
// pCaps->m_UseFastClipping = true;
|
|
// pCaps->m_bNeedsATICentroidHack = false;
|
|
// pCaps->m_bColorOnSecondStream = false;
|
|
pCaps->m_bSupportsStreamOffset = false;
|
|
pCaps->m_bFogColorSpecifiedInLinearSpace = false;
|
|
pCaps->m_bFogColorAlwaysLinearSpace = false;
|
|
pCaps->m_bSupportsAlphaToCoverage = false;
|
|
pCaps->m_bSupportsShadowDepthTextures = false;
|
|
pCaps->m_bSupportsFetch4 = false;
|
|
// m_bSoftwareVertexProcessing
|
|
pCaps->m_nVertexTextureCount = 0;
|
|
pCaps->m_nMaxVertexTextureDimension = 0;
|
|
pCaps->m_bSupportsVertexTextures = false;
|
|
pCaps->m_MaxNumLights = 2;
|
|
pCaps->m_nMaxViewports = 1;
|
|
// m_bScissorSupported
|
|
pCaps->m_SupportsSRGB = false;
|
|
pCaps->m_FakeSRGBWrite = false;
|
|
pCaps->m_CanDoSRGBReadFromRTs = true;
|
|
pCaps->m_bSupportsGLMixedSizeTargets = false;
|
|
pCaps->m_bSupportsFetch4 = false;
|
|
pCaps->m_bSupportsBorderColor = false;
|
|
pCaps->m_bSupportsFloat32RenderTargets = false;
|
|
// ImageFormat m_ShadowDepthTextureFormat;
|
|
// ImageFormat m_NullTextureFormat;
|
|
// m_AlphaToCoverageState;
|
|
// m_AlphaToCoverageEnableValue;
|
|
// m_AlphaToCoverageDisableValue;
|
|
// m_flMinGammaControlPoint
|
|
// m_flMaxGammaControlPoint
|
|
// m_nGammaControlPointCount
|
|
pCaps->m_MaxVertexShader30InstructionSlots = 0;
|
|
pCaps->m_MaxPixelShader30InstructionSlots = 0;
|
|
pCaps->m_bDX10Card = false;
|
|
pCaps->m_bDX10Blending = false;
|
|
pCaps->m_bCanStretchRectFromTextures = false;
|
|
break;
|
|
|
|
case 81:
|
|
// NOTE: Prior to dx9, numsamplers = num texture stages
|
|
// We clamp num texture stages to 2, though, since we never use
|
|
// fixed-function shaders with more than 2 texture stages
|
|
pCaps->m_NumTextureStages = min( 2, actualCaps.m_NumTextureStages );
|
|
pCaps->m_NumSamplers = min( 6, actualCaps.m_NumTextureStages );
|
|
// pCaps->m_SupportsVertexShaders = true;
|
|
pCaps->m_SupportsVertexShaders_2_0 = false;
|
|
// pCaps->m_SupportsPixelShaders = false;
|
|
pCaps->m_SupportsPixelShaders_1_4 = true;
|
|
pCaps->m_SupportsPixelShaders_2_0 = false;
|
|
pCaps->m_SupportsPixelShaders_2_b = false;
|
|
pCaps->m_SupportsShaderModel_3_0 = false;
|
|
pCaps->m_bSupportsStaticControlFlow = false;
|
|
// pCaps->m_SupportsCompressedTextures = true;
|
|
pCaps->m_SupportsCompressedVertices = VERTEX_COMPRESSION_NONE;
|
|
// pCaps->m_bSupportsAnisotropicFiltering = false;
|
|
// pCaps->m_bSupportsMagAnisotropicFiltering = false;
|
|
// pCaps->m_nMaxAnisotropy = 1;
|
|
// pCaps->m_MaxTextureWidth = max( 256, pCaps->m_MaxTextureWidth );
|
|
// pCaps->m_MaxTextureHeight = max( 256, pCaps->m_MaxTextureHeight );
|
|
// pCaps->m_MaxTextureDepth = max( 256, pCaps->m_MaxTextureDepth );
|
|
// m_MaxTextureAspectRatio;
|
|
// int m_MaxPrimitiveCount;
|
|
// pCaps->m_ZBiasAndSlopeScaledDepthBiasSupported = false;
|
|
// pCaps->m_SupportsMipmapping =
|
|
// bool m_SupportsOverbright;
|
|
// pCaps->m_SupportsCubeMaps = false;
|
|
pCaps->m_NumPixelShaderConstants = 8;
|
|
pCaps->m_NumVertexShaderConstants = min( 96, pCaps->m_NumVertexShaderConstants );
|
|
pCaps->m_NumBooleanVertexShaderConstants = 0;
|
|
pCaps->m_NumIntegerVertexShaderConstants = 0;
|
|
pCaps->m_NumBooleanPixelShaderConstants = 0;
|
|
pCaps->m_NumIntegerPixelShaderConstants = 0;
|
|
// pCaps->m_TextureMemorySize = 32 * 1024 * 1024;
|
|
pCaps->m_MaxNumLights = 2;
|
|
// pCaps->m_SupportsHardwareLighting = 0;
|
|
// pCaps->m_MaxBlendMatrices = 0;
|
|
// pCaps->m_MaxBlendMatrixIndices = 0;
|
|
pCaps->m_MaxVertexShaderBlendMatrices = min( 16, pCaps->m_MaxVertexShaderBlendMatrices );
|
|
// pCaps->m_SupportsMipmappedCubemaps = false;
|
|
// pCaps->m_SupportsNonPow2Textures = false;
|
|
pCaps->m_nDXSupportLevel = 81;
|
|
// pCaps->m_PreferDynamicTextures = false;
|
|
// pCaps->m_HasProjectedBumpEnv = false;
|
|
// pCaps->m_MaxUserClipPlanes = 0;
|
|
pCaps->m_SupportsSRGB = false;
|
|
pCaps->m_FakeSRGBWrite = false;
|
|
pCaps->m_CanDoSRGBReadFromRTs = true;
|
|
pCaps->m_bSupportsGLMixedSizeTargets = false;
|
|
pCaps->m_HDRType = HDR_TYPE_NONE;
|
|
// pCaps->m_bSupportsSpheremapping = true;
|
|
// pCaps->m_UseFastClipping = true;
|
|
// pCaps->m_bNeedsATICentroidHack = false;
|
|
// pCaps->m_bColorOnSecondStream = false;
|
|
pCaps->m_bSupportsStreamOffset = false;
|
|
pCaps->m_bFogColorSpecifiedInLinearSpace = false;
|
|
pCaps->m_bFogColorAlwaysLinearSpace = false;
|
|
pCaps->m_bSupportsAlphaToCoverage = false;
|
|
pCaps->m_bSupportsShadowDepthTextures = false;
|
|
pCaps->m_bSupportsFetch4 = false;
|
|
pCaps->m_bSupportsBorderColor = false;
|
|
// m_bSoftwareVertexProcessing
|
|
pCaps->m_nVertexTextureCount = 0;
|
|
pCaps->m_nMaxVertexTextureDimension = 0;
|
|
pCaps->m_bSupportsVertexTextures = false;
|
|
pCaps->m_nMaxViewports = 1;
|
|
// m_bScissorSupported
|
|
pCaps->m_bSupportsFloat32RenderTargets = false;
|
|
// ImageFormat m_ShadowDepthTextureFormat;
|
|
// ImageFormat m_NullTextureFormat;
|
|
// m_AlphaToCoverageState;
|
|
// m_AlphaToCoverageEnableValue;
|
|
// m_AlphaToCoverageDisableValue;
|
|
// m_flMinGammaControlPoint
|
|
// m_flMaxGammaControlPoint
|
|
// m_nGammaControlPointCount
|
|
pCaps->m_MaxVertexShader30InstructionSlots = 0;
|
|
pCaps->m_MaxPixelShader30InstructionSlots = 0;
|
|
pCaps->m_bDX10Card = false;
|
|
pCaps->m_bDX10Blending = false;
|
|
pCaps->m_bCanStretchRectFromTextures = false;
|
|
break;
|
|
|
|
case 90:
|
|
pCaps->m_nVertexTextureCount = 0;
|
|
pCaps->m_nMaxVertexTextureDimension = 0;
|
|
pCaps->m_bSupportsVertexTextures = false;
|
|
pCaps->m_bSupportsStreamOffset = true;
|
|
pCaps->m_bSupportsGLMixedSizeTargets = true;
|
|
|
|
if ( IsOpenGL() )
|
|
{
|
|
//FIXME this is way too complicated, we should just check the caps bit from GLM
|
|
|
|
pCaps->m_bSupportsStaticControlFlow = false;
|
|
|
|
if (1) //(CommandLine()->FindParm("-glslmode"))
|
|
{
|
|
// rbarris 03Feb10: this is now hardwired because we are defaulting GLSL mode "on".
|
|
// so this will mean that the engine will always ask for user clip planes.
|
|
// this will misbehave under ARB mode, since ARB shaders won't respect that state.
|
|
// it's difficult to make this fluid without teaching the engine about a cap that could change during run.
|
|
|
|
pCaps->m_MaxUserClipPlanes = 2;
|
|
pCaps->m_UseFastClipping = false;
|
|
}
|
|
else
|
|
{
|
|
pCaps->m_MaxUserClipPlanes = 0;
|
|
pCaps->m_UseFastClipping = true;
|
|
}
|
|
|
|
pCaps->m_MaxNumLights = 2;
|
|
}
|
|
else
|
|
{
|
|
pCaps->m_bSupportsStaticControlFlow = true;
|
|
pCaps->m_MaxNumLights = pCaps->m_SupportsPixelShaders_2_b ? 4 : 2; // 2b gets four lights, 2.0 gets two...
|
|
}
|
|
|
|
pCaps->m_bSupportsBorderColor = false;
|
|
pCaps->m_nMaxViewports = 1;
|
|
pCaps->m_NumPixelShaderConstants = 32;
|
|
pCaps->m_nMaxVertexTextureDimension = 0;
|
|
pCaps->m_MaxVertexShader30InstructionSlots = 0;
|
|
pCaps->m_MaxPixelShader30InstructionSlots = 0;
|
|
pCaps->m_bCanStretchRectFromTextures = false;
|
|
break;
|
|
|
|
case 92:
|
|
pCaps->m_nVertexTextureCount = 0;
|
|
pCaps->m_nMaxVertexTextureDimension = 0;
|
|
pCaps->m_bSupportsVertexTextures = false;
|
|
pCaps->m_bSupportsBorderColor = false;
|
|
|
|
// 2b gets four lights, 2.0 gets two...
|
|
pCaps->m_SupportsShaderModel_3_0 = false;
|
|
if ( IsOpenGL() )
|
|
{
|
|
if ( IsOSX() )
|
|
{
|
|
pCaps->m_bSupportsStaticControlFlow = CommandLine()->CheckParm( "-glslcontrolflow" ) != NULL;
|
|
}
|
|
else
|
|
{
|
|
pCaps->m_bSupportsStaticControlFlow = !CommandLine()->CheckParm( "-noglslcontrolflow" );
|
|
}
|
|
|
|
pCaps->m_MaxUserClipPlanes = 2;
|
|
pCaps->m_UseFastClipping = false;
|
|
pCaps->m_MaxNumLights = pCaps->m_bSupportsStaticControlFlow ? MAX_NUM_LIGHTS : ( MAX_NUM_LIGHTS - 2 );
|
|
}
|
|
else
|
|
{
|
|
pCaps->m_MaxNumLights = MAX_NUM_LIGHTS;
|
|
}
|
|
|
|
pCaps->m_nMaxViewports = 1;
|
|
pCaps->m_NumPixelShaderConstants = 32;
|
|
pCaps->m_nMaxVertexTextureDimension = 0;
|
|
pCaps->m_bDX10Card = false;
|
|
pCaps->m_bDX10Blending = false;
|
|
pCaps->m_MaxVertexShader30InstructionSlots = 0;
|
|
pCaps->m_MaxPixelShader30InstructionSlots = 0;
|
|
pCaps->m_bCanStretchRectFromTextures = false;
|
|
break;
|
|
|
|
case 95:
|
|
pCaps->m_bSupportsStreamOffset = true;
|
|
pCaps->m_bSupportsStaticControlFlow = true;
|
|
pCaps->m_bDX10Card = false;
|
|
pCaps->m_bDX10Blending = false;
|
|
pCaps->m_MaxNumLights = MAX_NUM_LIGHTS;
|
|
pCaps->m_nMaxViewports = 1;
|
|
pCaps->m_bSupportsBorderColor = false;
|
|
pCaps->m_bCanStretchRectFromTextures = false;
|
|
break;
|
|
|
|
case 100:
|
|
break;
|
|
|
|
default:
|
|
Assert( 0 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets up the hardware caps given the specified DX level
|
|
//-----------------------------------------------------------------------------
|
|
void CHardwareConfig::SetupHardwareCaps( int nDXLevel, const HardwareCaps_t &actualCaps )
|
|
{
|
|
Assert( nDXLevel != 0 );
|
|
|
|
memcpy( &m_Caps, &actualCaps, sizeof(HardwareCaps_t) );
|
|
memcpy( &m_UnOverriddenCaps, &actualCaps, sizeof(HardwareCaps_t) );
|
|
|
|
// Don't bother with fallbacks for DX10 or consoles
|
|
#ifdef DX_TO_GL_ABSTRACTION
|
|
if ( nDXLevel >= 100 )
|
|
#else
|
|
if ( !( IsPC() || IsPosix() ) || ( nDXLevel >= 100 ) )
|
|
#endif
|
|
return;
|
|
|
|
// Slam the support level to what we were requested
|
|
m_Caps.m_nDXSupportLevel = nDXLevel;
|
|
if ( m_Caps.m_nDXSupportLevel != m_Caps.m_nMaxDXSupportLevel || CommandLine()->ParmValue( "-maxdxlevel", 0 ) > 0 )
|
|
{
|
|
// We're falling back to some other dx level
|
|
ForceCapsToDXLevel( &m_Caps, m_Caps.m_nDXSupportLevel, m_ActualCaps );
|
|
}
|
|
|
|
// Clamp num texture stages to 2, since it's only used for fixed function
|
|
m_Caps.m_NumTextureStages = min( 2, m_Caps.m_NumTextureStages );
|
|
|
|
// Read dxsupport.cfg which has config overrides for particular cards.
|
|
g_pShaderDeviceMgr->ReadHardwareCaps( m_Caps, m_Caps.m_nDXSupportLevel );
|
|
|
|
// This is the spot to validate read in caps versus actual caps.
|
|
if ( m_Caps.m_MaxUserClipPlanes > m_ActualCaps.m_MaxUserClipPlanes )
|
|
{
|
|
m_Caps.m_MaxUserClipPlanes = m_ActualCaps.m_MaxUserClipPlanes;
|
|
}
|
|
if ( m_Caps.m_MaxUserClipPlanes == 0 )
|
|
{
|
|
m_Caps.m_UseFastClipping = true;
|
|
}
|
|
|
|
if ( IsOpenGL() )
|
|
{
|
|
m_Caps.m_MaxNumLights = MIN( m_Caps.m_MaxNumLights, ( m_Caps.m_bSupportsStaticControlFlow && m_Caps.m_SupportsPixelShaders_2_b ) ? MAX_NUM_LIGHTS : ( MAX_NUM_LIGHTS - 2 ) );
|
|
m_Caps.m_bSupportsShadowDepthTextures = true;
|
|
}
|
|
else // not POSIX or emulated
|
|
{
|
|
// 2b supports more lights than just 2.0
|
|
if ( m_Caps.m_SupportsPixelShaders_2_b )
|
|
{
|
|
m_Caps.m_MaxNumLights = MIN( m_Caps.m_MaxNumLights, MAX_NUM_LIGHTS );
|
|
}
|
|
else
|
|
{
|
|
m_Caps.m_MaxNumLights = MIN( m_Caps.m_MaxNumLights, MAX_NUM_LIGHTS - 2 );
|
|
}
|
|
}
|
|
|
|
m_Caps.m_MaxNumLights = min( m_Caps.m_MaxNumLights, (int)MAX_NUM_LIGHTS );
|
|
|
|
memcpy( &m_UnOverriddenCaps, &m_Caps, sizeof(HardwareCaps_t) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets up the hardware caps given the specified DX level
|
|
//-----------------------------------------------------------------------------
|
|
void CHardwareConfig::SetupHardwareCaps( const ShaderDeviceInfo_t& mode, const HardwareCaps_t &actualCaps )
|
|
{
|
|
memcpy( &m_ActualCaps, &actualCaps, sizeof(HardwareCaps_t) );
|
|
SetupHardwareCaps( mode.m_nDXLevel, actualCaps );
|
|
}
|
|
|
|
|
|
void CHardwareConfig::OverrideStreamOffsetSupport( bool bOverrideEnabled, bool bEnableSupport )
|
|
{
|
|
if ( bOverrideEnabled )
|
|
{
|
|
m_Caps.m_bSupportsStreamOffset = bEnableSupport;
|
|
if ( !m_ActualCaps.m_bSupportsStreamOffset )
|
|
{
|
|
m_Caps.m_bSupportsStreamOffset = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Go back to default
|
|
m_Caps.m_bSupportsStreamOffset = m_UnOverriddenCaps.m_bSupportsStreamOffset;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Implementation of IMaterialSystemHardwareConfig
|
|
//-----------------------------------------------------------------------------
|
|
bool CHardwareConfig::HasDestAlphaBuffer() const
|
|
{
|
|
if ( !g_pShaderDevice )
|
|
return false;
|
|
return (g_pShaderDevice->GetBackBufferFormat() == IMAGE_FORMAT_BGRA8888);
|
|
}
|
|
|
|
bool CHardwareConfig::HasStencilBuffer() const
|
|
{
|
|
return StencilBufferBits() > 0;
|
|
}
|
|
|
|
int CHardwareConfig::GetFrameBufferColorDepth() const
|
|
{
|
|
if ( !g_pShaderDevice )
|
|
return 0;
|
|
return ShaderUtil()->ImageFormatInfo( g_pShaderDevice->GetBackBufferFormat() ).m_NumBytes;
|
|
}
|
|
|
|
int CHardwareConfig::GetSamplerCount() const
|
|
{
|
|
return m_Caps.m_NumSamplers;
|
|
}
|
|
|
|
bool CHardwareConfig::HasSetDeviceGammaRamp() const
|
|
{
|
|
return m_Caps.m_HasSetDeviceGammaRamp;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsCompressedTextures() const
|
|
{
|
|
Assert( m_Caps.m_SupportsCompressedTextures != COMPRESSED_TEXTURES_NOT_INITIALIZED );
|
|
return m_Caps.m_SupportsCompressedTextures == COMPRESSED_TEXTURES_ON;
|
|
}
|
|
|
|
VertexCompressionType_t CHardwareConfig::SupportsCompressedVertices() const
|
|
{
|
|
return m_Caps.m_SupportsCompressedVertices;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsBorderColor() const
|
|
{
|
|
return m_Caps.m_bSupportsBorderColor;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsFetch4() const
|
|
{
|
|
return m_Caps.m_bSupportsFetch4;
|
|
}
|
|
|
|
bool CHardwareConfig::CanStretchRectFromTextures() const
|
|
{
|
|
return m_Caps.m_bCanStretchRectFromTextures;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsVertexAndPixelShaders() const
|
|
{
|
|
if ( (ShaderUtil()->GetConfig().dxSupportLevel != 0) && (GetDXSupportLevel() < 80) )
|
|
return false;
|
|
|
|
return m_Caps.m_SupportsPixelShaders;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsPixelShaders_1_4() const
|
|
{
|
|
if ( (ShaderUtil()->GetConfig().dxSupportLevel != 0) && (GetDXSupportLevel() < 81) )
|
|
return false;
|
|
|
|
return m_Caps.m_SupportsPixelShaders_1_4;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsPixelShaders_2_0() const
|
|
{
|
|
if ( (ShaderUtil()->GetConfig().dxSupportLevel != 0) && (GetDXSupportLevel() < 90) )
|
|
return false;
|
|
|
|
return m_Caps.m_SupportsPixelShaders_2_0;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsPixelShaders_2_b() const
|
|
{
|
|
if ((ShaderUtil()->GetConfig().dxSupportLevel != 0) &&
|
|
(GetDXSupportLevel() < 90))
|
|
return false;
|
|
|
|
return m_Caps.m_SupportsPixelShaders_2_b;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsVertexShaders_2_0() const
|
|
{
|
|
if ((ShaderUtil()->GetConfig().dxSupportLevel != 0) &&
|
|
(GetDXSupportLevel() < 90))
|
|
return false;
|
|
|
|
return m_Caps.m_SupportsVertexShaders_2_0;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsStaticControlFlow() const
|
|
{
|
|
return m_Caps.m_bSupportsStaticControlFlow;
|
|
}
|
|
|
|
|
|
bool CHardwareConfig::SupportsShaderModel_3_0() const
|
|
{
|
|
if ((ShaderUtil()->GetConfig().dxSupportLevel != 0) &&
|
|
(GetDXSupportLevel() < 95))
|
|
return false;
|
|
|
|
return m_Caps.m_SupportsShaderModel_3_0;
|
|
}
|
|
|
|
// If you change these, make the corresponding change in common_ps_fxc.h
|
|
#define NVIDIA_PCF_POISSON 0
|
|
#define ATI_NOPCF 1
|
|
#define ATI_NO_PCF_FETCH4 2
|
|
|
|
int CHardwareConfig::GetShadowFilterMode() const
|
|
{
|
|
|
|
#ifdef DX_TO_GL_ABSTRACTION
|
|
if ( !m_Caps.m_bSupportsShadowDepthTextures )
|
|
return 0;
|
|
#else
|
|
if ( !m_Caps.m_bSupportsShadowDepthTextures || !ShaderUtil()->GetConfig().ShadowDepthTexture() )
|
|
return 0;
|
|
#endif
|
|
|
|
switch ( m_Caps.m_ShadowDepthTextureFormat )
|
|
{
|
|
case IMAGE_FORMAT_NV_DST16:
|
|
case IMAGE_FORMAT_NV_DST24:
|
|
|
|
return NVIDIA_PCF_POISSON; // NVIDIA hardware bilinear PCF
|
|
|
|
case IMAGE_FORMAT_ATI_DST16:
|
|
case IMAGE_FORMAT_ATI_DST24:
|
|
|
|
if ( m_Caps.m_bSupportsFetch4 )
|
|
return ATI_NO_PCF_FETCH4; // ATI fetch4 depth texture sampling
|
|
|
|
return ATI_NOPCF; // ATI vanilla depth texture sampling
|
|
|
|
#if defined( _X360 )
|
|
case IMAGE_FORMAT_X360_DST16:
|
|
case IMAGE_FORMAT_X360_DST24:
|
|
case IMAGE_FORMAT_X360_DST24F:
|
|
return 0;
|
|
#endif
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ConVar r_shader_srgb( "r_shader_srgb", "0", FCVAR_ALLOWED_IN_COMPETITIVE, "-1 = use hardware caps. 0 = use hardware srgb. 1 = use shader srgb(software lookup)" ); // -1=use caps 0=off 1=on
|
|
|
|
int CHardwareConfig::NeedsShaderSRGBConversion() const
|
|
{
|
|
if ( IsX360() )
|
|
{
|
|
// 360 always now uses a permanent hw solution
|
|
return false;
|
|
}
|
|
|
|
int cValue = r_shader_srgb.GetInt();
|
|
switch( cValue )
|
|
{
|
|
case 0:
|
|
return false;
|
|
|
|
case 1:
|
|
return true;
|
|
|
|
default:
|
|
return m_Caps.m_bDX10Blending; // !!! change to return false after portal deport built!!!!!
|
|
}
|
|
}
|
|
|
|
bool CHardwareConfig::UsesSRGBCorrectBlending() const
|
|
{
|
|
int cValue = r_shader_srgb.GetInt();
|
|
return ( cValue == 0 ) && ( ( m_Caps.m_bDX10Blending ) || IsX360() );
|
|
}
|
|
|
|
static ConVar mat_disablehwmorph( "mat_disablehwmorph", "0", FCVAR_ALLOWED_IN_COMPETITIVE, "Disables HW morphing for particular mods" );
|
|
bool CHardwareConfig::HasFastVertexTextures() const
|
|
{
|
|
static int bEnableFastVertexTextures = -1;
|
|
static bool bDisableHWMorph = false;
|
|
if ( bEnableFastVertexTextures < 0 )
|
|
{
|
|
bEnableFastVertexTextures = 1;
|
|
if ( CommandLine()->FindParm( "-disallowhwmorph" ) )
|
|
{
|
|
bEnableFastVertexTextures = 0;
|
|
}
|
|
bDisableHWMorph = ( mat_disablehwmorph.GetInt() != 0 );
|
|
}
|
|
|
|
// JasonM - turned this off for Orange Box release...
|
|
return false;
|
|
|
|
// return m_Caps.m_bDX10Card && ( GetDXSupportLevel() >= 95 ) && ( bEnableFastVertexTextures != 0 ) && ( !bDisableHWMorph );
|
|
}
|
|
|
|
int CHardwareConfig::MaxHWMorphBatchCount() const
|
|
{
|
|
return ShaderUtil()->MaxHWMorphBatchCount();
|
|
}
|
|
|
|
int CHardwareConfig::MaximumAnisotropicLevel() const
|
|
{
|
|
return m_Caps.m_nMaxAnisotropy;
|
|
}
|
|
|
|
int CHardwareConfig::MaxTextureWidth() const
|
|
{
|
|
return m_Caps.m_MaxTextureWidth;
|
|
}
|
|
|
|
int CHardwareConfig::MaxTextureHeight() const
|
|
{
|
|
return m_Caps.m_MaxTextureHeight;
|
|
}
|
|
|
|
int CHardwareConfig::TextureMemorySize() const
|
|
{
|
|
return m_Caps.m_TextureMemorySize;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsOverbright() const
|
|
{
|
|
return m_Caps.m_SupportsOverbright;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsCubeMaps() const
|
|
{
|
|
if ( (ShaderUtil()->GetConfig().dxSupportLevel > 0) && (GetDXSupportLevel() < 70) )
|
|
return false;
|
|
|
|
return m_Caps.m_SupportsCubeMaps;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsMipmappedCubemaps() const
|
|
{
|
|
if ( (ShaderUtil()->GetConfig().dxSupportLevel > 0) && (GetDXSupportLevel() < 70) )
|
|
return false;
|
|
|
|
return m_Caps.m_SupportsMipmappedCubemaps;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsNonPow2Textures() const
|
|
{
|
|
return m_Caps.m_SupportsNonPow2Textures;
|
|
}
|
|
|
|
int CHardwareConfig::GetTextureStageCount() const
|
|
{
|
|
return m_Caps.m_NumTextureStages;
|
|
}
|
|
|
|
int CHardwareConfig::NumVertexShaderConstants() const
|
|
{
|
|
return m_Caps.m_NumVertexShaderConstants;
|
|
}
|
|
|
|
int CHardwareConfig::NumBooleanVertexShaderConstants() const
|
|
{
|
|
return m_Caps.m_NumBooleanVertexShaderConstants;
|
|
}
|
|
|
|
int CHardwareConfig::NumIntegerVertexShaderConstants() const
|
|
{
|
|
return m_Caps.m_NumIntegerVertexShaderConstants;
|
|
}
|
|
|
|
int CHardwareConfig::NumPixelShaderConstants() const
|
|
{
|
|
return m_Caps.m_NumPixelShaderConstants;
|
|
}
|
|
|
|
int CHardwareConfig::NumBooleanPixelShaderConstants() const
|
|
{
|
|
return m_Caps.m_NumBooleanPixelShaderConstants;
|
|
}
|
|
|
|
int CHardwareConfig::NumIntegerPixelShaderConstants() const
|
|
{
|
|
return m_Caps.m_NumIntegerPixelShaderConstants;
|
|
}
|
|
|
|
int CHardwareConfig::MaxNumLights() const
|
|
{
|
|
return m_Caps.m_MaxNumLights;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsHardwareLighting() const
|
|
{
|
|
if ( (ShaderUtil()->GetConfig().dxSupportLevel > 0) && (GetDXSupportLevel() < 70) )
|
|
return false;
|
|
|
|
return m_Caps.m_SupportsHardwareLighting;
|
|
}
|
|
|
|
int CHardwareConfig::MaxBlendMatrices() const
|
|
{
|
|
if ( (ShaderUtil()->GetConfig().dxSupportLevel > 0) && (GetDXSupportLevel() < 70) )
|
|
return 1;
|
|
|
|
return m_Caps.m_MaxBlendMatrices;
|
|
}
|
|
|
|
int CHardwareConfig::MaxBlendMatrixIndices() const
|
|
{
|
|
if ( (ShaderUtil()->GetConfig().dxSupportLevel > 0) && (GetDXSupportLevel() < 70) )
|
|
return 1;
|
|
|
|
return m_Caps.m_MaxBlendMatrixIndices;
|
|
}
|
|
|
|
int CHardwareConfig::MaxTextureAspectRatio() const
|
|
{
|
|
return m_Caps.m_MaxTextureAspectRatio;
|
|
}
|
|
|
|
int CHardwareConfig::MaxVertexShaderBlendMatrices() const
|
|
{
|
|
if ( (ShaderUtil()->GetConfig().dxSupportLevel > 0) && (GetDXSupportLevel() < 70) )
|
|
return 1;
|
|
|
|
return m_Caps.m_MaxVertexShaderBlendMatrices;
|
|
}
|
|
|
|
// Useful for testing fastclip on Windows
|
|
extern ConVar mat_fastclip;
|
|
|
|
int CHardwareConfig::MaxUserClipPlanes() const
|
|
{
|
|
if ( mat_fastclip.GetBool() )
|
|
return 0;
|
|
|
|
return m_Caps.m_MaxUserClipPlanes;
|
|
}
|
|
|
|
bool CHardwareConfig::UseFastClipping() const
|
|
{
|
|
// rbarris broke this up for easier view of outcome in debugger
|
|
bool fastclip = mat_fastclip.GetBool();
|
|
|
|
bool result = m_Caps.m_UseFastClipping || fastclip;
|
|
|
|
return result;
|
|
}
|
|
|
|
int CHardwareConfig::MaxTextureDepth() const
|
|
{
|
|
return m_Caps.m_MaxTextureDepth;
|
|
}
|
|
|
|
int CHardwareConfig::GetDXSupportLevel() const
|
|
{
|
|
if ( ShaderUtil()->GetConfig().dxSupportLevel != 0 )
|
|
{
|
|
return min( ShaderUtil()->GetConfig().dxSupportLevel, m_Caps.m_nDXSupportLevel );
|
|
}
|
|
|
|
return m_Caps.m_nDXSupportLevel;
|
|
}
|
|
|
|
const char *CHardwareConfig::GetShaderDLLName() const
|
|
{
|
|
return ( m_Caps.m_pShaderDLL && m_Caps.m_pShaderDLL[0] ) ? m_Caps.m_pShaderDLL : "DEFAULT";
|
|
}
|
|
|
|
bool CHardwareConfig::ReadPixelsFromFrontBuffer() const
|
|
{
|
|
if ( IsX360() )
|
|
{
|
|
// future proof safety, not allowing the front read path
|
|
return false;
|
|
}
|
|
|
|
// GR - in DX 9.0a can blit from MSAA back buffer
|
|
return false;
|
|
}
|
|
|
|
bool CHardwareConfig::PreferDynamicTextures() const
|
|
{
|
|
if ( IsX360() )
|
|
{
|
|
// future proof safety, not allowing these
|
|
return false;
|
|
}
|
|
|
|
return m_Caps.m_PreferDynamicTextures;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsHDR() const
|
|
{
|
|
// This is a deprecated function. . use GetHDRType instead. For shipping HL2, this always being false is correct.
|
|
Assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsHDRMode( HDRType_t nHDRType ) const
|
|
{
|
|
switch( nHDRType )
|
|
{
|
|
case HDR_TYPE_NONE:
|
|
return true;
|
|
|
|
case HDR_TYPE_INTEGER:
|
|
return ( m_Caps.m_MaxHDRType == HDR_TYPE_INTEGER ) || ( m_Caps.m_MaxHDRType == HDR_TYPE_FLOAT );
|
|
|
|
case HDR_TYPE_FLOAT:
|
|
return ( m_Caps.m_MaxHDRType == HDR_TYPE_FLOAT );
|
|
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
bool CHardwareConfig::HasProjectedBumpEnv() const
|
|
{
|
|
return m_Caps.m_HasProjectedBumpEnv;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsSpheremapping() const
|
|
{
|
|
return m_Caps.m_bSupportsSpheremapping;
|
|
}
|
|
|
|
bool CHardwareConfig::NeedsAAClamp() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool CHardwareConfig::NeedsATICentroidHack() const
|
|
{
|
|
return m_Caps.m_bNeedsATICentroidHack;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsColorOnSecondStream() const
|
|
{
|
|
return m_Caps.m_bColorOnSecondStream;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsStaticPlusDynamicLighting() const
|
|
{
|
|
return GetDXSupportLevel() >= 80;
|
|
}
|
|
|
|
bool CHardwareConfig::PreferReducedFillrate() const
|
|
{
|
|
return ShaderUtil()->GetConfig().ReduceFillrate();
|
|
}
|
|
|
|
// This is the max dx support level supported by the card
|
|
int CHardwareConfig::GetMaxDXSupportLevel() const
|
|
{
|
|
return m_ActualCaps.m_nMaxDXSupportLevel;
|
|
}
|
|
|
|
bool CHardwareConfig::SpecifiesFogColorInLinearSpace() const
|
|
{
|
|
return m_Caps.m_bFogColorSpecifiedInLinearSpace;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsSRGB() const
|
|
{
|
|
return m_Caps.m_SupportsSRGB;
|
|
}
|
|
|
|
bool CHardwareConfig::FakeSRGBWrite() const
|
|
{
|
|
return m_Caps.m_FakeSRGBWrite;
|
|
}
|
|
|
|
bool CHardwareConfig::CanDoSRGBReadFromRTs() const
|
|
{
|
|
return m_Caps.m_CanDoSRGBReadFromRTs;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsGLMixedSizeTargets() const
|
|
{
|
|
return m_Caps.m_bSupportsGLMixedSizeTargets;
|
|
}
|
|
|
|
bool CHardwareConfig::IsAAEnabled() const
|
|
{
|
|
return g_pShaderDevice ? g_pShaderDevice->IsAAEnabled() : false;
|
|
// bool bAntialiasing = ( m_PresentParameters.MultiSampleType != D3DMULTISAMPLE_NONE );
|
|
// return bAntialiasing;
|
|
}
|
|
|
|
int CHardwareConfig::GetVertexTextureCount() const
|
|
{
|
|
return m_Caps.m_nVertexTextureCount;
|
|
}
|
|
|
|
int CHardwareConfig::GetMaxVertexTextureDimension() const
|
|
{
|
|
return m_Caps.m_nMaxVertexTextureDimension;
|
|
}
|
|
|
|
HDRType_t CHardwareConfig::GetHDRType() const
|
|
{
|
|
bool enabled = m_bHDREnabled;
|
|
int dxlev = GetDXSupportLevel();
|
|
int dxsupp = dxlev >= 90;
|
|
HDRType_t caps_hdr = m_Caps.m_HDRType;
|
|
HDRType_t result = HDR_TYPE_NONE;
|
|
|
|
//printf("\nCHardwareConfig::GetHDRType...");
|
|
if (enabled)
|
|
{
|
|
//printf("-> enabled...");
|
|
if (dxsupp)
|
|
{
|
|
//printf("-> supported...");
|
|
result = caps_hdr;
|
|
}
|
|
}
|
|
|
|
//printf("-> result is %d.\n", result);
|
|
return result;
|
|
|
|
/*
|
|
if ( m_bHDREnabled && ( GetDXSupportLevel() >= 90 ) )
|
|
return m_Caps.m_HDRType;
|
|
return HDR_TYPE_NONE;
|
|
*/
|
|
}
|
|
|
|
HDRType_t CHardwareConfig::GetHardwareHDRType() const
|
|
{
|
|
return m_Caps.m_HDRType;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsStreamOffset() const
|
|
{
|
|
return ( (GetDXSupportLevel() >= 90) && m_Caps.m_bSupportsStreamOffset );
|
|
}
|
|
|
|
int CHardwareConfig::StencilBufferBits() const
|
|
{
|
|
return g_pShaderDevice ? g_pShaderDevice->StencilBufferBits() : 0;
|
|
}
|
|
|
|
int CHardwareConfig:: MaxViewports() const
|
|
{
|
|
return m_Caps.m_nMaxViewports;
|
|
}
|
|
|
|
int CHardwareConfig::GetActualSamplerCount() const
|
|
{
|
|
return m_ActualCaps.m_NumSamplers;
|
|
}
|
|
|
|
int CHardwareConfig::GetActualTextureStageCount() const
|
|
{
|
|
return m_ActualCaps.m_NumTextureStages;
|
|
}
|
|
|
|
const char *CHardwareConfig::GetHWSpecificShaderDLLName() const
|
|
{
|
|
return m_Caps.m_pShaderDLL && m_Caps.m_pShaderDLL[0] ? m_Caps.m_pShaderDLL : NULL;
|
|
}
|
|
|
|
bool CHardwareConfig::SupportsMipmapping() const
|
|
{
|
|
return m_Caps.m_SupportsMipmapping;
|
|
}
|
|
|
|
bool CHardwareConfig::ActuallySupportsPixelShaders_2_b() const
|
|
{
|
|
return m_ActualCaps.m_SupportsPixelShaders_2_b;
|
|
}
|