diff options
Diffstat (limited to 'materialsystem/shaderapidx9/hardwareconfig.cpp')
| -rw-r--r-- | materialsystem/shaderapidx9/hardwareconfig.cpp | 1311 |
1 files changed, 1311 insertions, 0 deletions
diff --git a/materialsystem/shaderapidx9/hardwareconfig.cpp b/materialsystem/shaderapidx9/hardwareconfig.cpp new file mode 100644 index 0000000..133be43 --- /dev/null +++ b/materialsystem/shaderapidx9/hardwareconfig.cpp @@ -0,0 +1,1311 @@ +//========= 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; +} |