808 lines
24 KiB
C++
808 lines
24 KiB
C++
//===== Copyright <20> 1996-2005, Valve Corporation, All rights reserved. ======//
|
||
//
|
||
// Purpose:
|
||
//
|
||
// $NoKeywords: $
|
||
//
|
||
//===========================================================================//
|
||
#define DISABLE_PROTECTED_THINGS
|
||
#include "togl/rendermechanism.h"
|
||
#include "shadershadowdx8.h"
|
||
#include "locald3dtypes.h"
|
||
#include "utlvector.h"
|
||
#include "shaderapi/ishaderutil.h"
|
||
#include "shaderapidx8_global.h"
|
||
#include "shaderapidx8.h"
|
||
#include "materialsystem/imaterialsystemhardwareconfig.h"
|
||
#include "materialsystem/imaterialsystem.h"
|
||
#include "imeshdx8.h"
|
||
#include "materialsystem/materialsystem_config.h"
|
||
#include "vertexshaderdx8.h"
|
||
|
||
// NOTE: This must be the last file included!
|
||
#include "tier0/memdbgon.h"
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// The DX8 implementation of the shader setup interface
|
||
//-----------------------------------------------------------------------------
|
||
class CShaderShadowDX8 : public IShaderShadowDX8
|
||
{
|
||
public:
|
||
// constructor, destructor
|
||
CShaderShadowDX8( );
|
||
virtual ~CShaderShadowDX8();
|
||
|
||
// Initialize render state
|
||
void Init( );
|
||
|
||
// Sets the default state
|
||
void SetDefaultState();
|
||
|
||
// Methods related to depth buffering
|
||
void DepthFunc( ShaderDepthFunc_t depthFunc );
|
||
void EnableDepthWrites( bool bEnable );
|
||
void EnableDepthTest( bool bEnable );
|
||
void EnablePolyOffset( PolygonOffsetMode_t nOffsetMode );
|
||
|
||
// Suppresses/activates color writing
|
||
void EnableColorWrites( bool bEnable );
|
||
void EnableAlphaWrites( bool bEnable );
|
||
|
||
// Methods related to alpha blending
|
||
void EnableBlending( bool bEnable );
|
||
void EnableBlendingForceOpaque( bool bEnable );
|
||
void BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor );
|
||
void BlendOp( ShaderBlendOp_t blendOp );
|
||
void EnableBlendingSeparateAlpha( bool bEnable );
|
||
void BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor );
|
||
void BlendOpSeparateAlpha( ShaderBlendOp_t blendOp );
|
||
|
||
// Alpha testing
|
||
void EnableAlphaTest( bool bEnable );
|
||
void AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ );
|
||
|
||
// Wireframe/filled polygons
|
||
void PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode );
|
||
|
||
// Back face culling
|
||
void EnableCulling( bool bEnable );
|
||
|
||
// Convert from linear to gamma color space on writes to frame buffer.
|
||
void EnableSRGBWrite( bool bEnable );
|
||
|
||
// Convert from gamma to linear on texture fetch.
|
||
void EnableSRGBRead( Sampler_t stage, bool bEnable );
|
||
|
||
// Set up appropriate shadow filtering state (such as Fetch4 on ATI)
|
||
//void SetShadowDepthFiltering( Sampler_t stage );
|
||
|
||
// Computes the vertex format
|
||
virtual void VertexShaderVertexFormat( unsigned int nFlags,
|
||
int nTexCoordCount, int* pTexCoordDimensions, int nUserDataSize );
|
||
|
||
// Pixel and vertex shader methods
|
||
virtual void SetVertexShader( const char* pFileName, int nStaticVshIndex );
|
||
virtual void SetPixelShader( const char* pFileName, int nStaticPshIndex );
|
||
|
||
// Per texture unit stuff
|
||
void EnableTexture( Sampler_t stage, bool bEnable );
|
||
void EnableVertexTexture( VertexTextureSampler_t sampler, bool bEnable );
|
||
|
||
// Last call to be make before snapshotting
|
||
void ComputeAggregateShadowState( );
|
||
|
||
// Gets at the shadow state
|
||
const ShadowState_t & GetShadowState();
|
||
const ShadowShaderState_t & GetShadowShaderState();
|
||
|
||
void FogMode( ShaderFogMode_t fogMode, bool bVertexFog );
|
||
void DisableFogGammaCorrection( bool bDisable );
|
||
|
||
// Alpha to coverage
|
||
void EnableAlphaToCoverage( bool bEnable );
|
||
|
||
virtual float GetLightMapScaleFactor( void ) const;
|
||
|
||
private:
|
||
struct SamplerState_t
|
||
{
|
||
bool m_TextureEnable : 1;
|
||
};
|
||
|
||
// Computes the blend factor
|
||
D3DBLEND BlendFuncValue( ShaderBlendFactor_t factor ) const;
|
||
|
||
// Computes the blend op
|
||
D3DBLENDOP BlendOpValue( ShaderBlendOp_t blendOp ) const;
|
||
|
||
// Configures our texture indices
|
||
void ConfigureTextureCoordinates( unsigned int flags );
|
||
|
||
// returns true if we're using texture coordinates at a given stage
|
||
bool IsUsingTextureCoordinates( Sampler_t stage ) const;
|
||
|
||
// State needed to create the snapshots
|
||
IMaterialSystemHardwareConfig* m_pHardwareConfig;
|
||
|
||
// Alpha blending...
|
||
D3DBLEND m_SrcBlend;
|
||
D3DBLEND m_DestBlend;
|
||
D3DBLENDOP m_BlendOp;
|
||
|
||
// Separate alpha blending...
|
||
D3DBLEND m_SrcBlendAlpha;
|
||
D3DBLEND m_DestBlendAlpha;
|
||
D3DBLENDOP m_BlendOpAlpha;
|
||
|
||
// Alpha testing
|
||
D3DCMPFUNC m_AlphaFunc;
|
||
int m_AlphaRef;
|
||
|
||
// The current shadow state
|
||
ShadowState_t m_ShadowState;
|
||
ShadowShaderState_t m_ShadowShaderState;
|
||
|
||
// State info stores with each sampler stage
|
||
SamplerState_t m_SamplerState[MAX_SAMPLERS];
|
||
SamplerState_t m_VertexSamplerState[MAX_VERTEX_SAMPLERS];
|
||
};
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Class factory
|
||
//-----------------------------------------------------------------------------
|
||
static CShaderShadowDX8 g_ShaderShadow;
|
||
IShaderShadowDX8 *g_pShaderShadowDx8 = &g_ShaderShadow;
|
||
|
||
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderShadowDX8, IShaderShadow,
|
||
SHADERSHADOW_INTERFACE_VERSION, g_ShaderShadow )
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Global instance
|
||
//-----------------------------------------------------------------------------
|
||
IShaderShadowDX8* ShaderShadow()
|
||
{
|
||
return &g_ShaderShadow;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Constructor, destructor
|
||
//-----------------------------------------------------------------------------
|
||
CShaderShadowDX8::CShaderShadowDX8( ) : m_pHardwareConfig(0)
|
||
{
|
||
memset( &m_ShadowState, 0, sizeof(m_ShadowState) );
|
||
}
|
||
|
||
CShaderShadowDX8::~CShaderShadowDX8()
|
||
{
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Initialize render state
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::Init( )
|
||
{
|
||
m_pHardwareConfig = g_pHardwareConfig;
|
||
|
||
// Clear out the shadow state
|
||
memset( &m_ShadowState, 0, sizeof(m_ShadowState) );
|
||
|
||
m_ShadowState.m_FogAndMiscState.m_bDisableFogGammaCorrection = false;
|
||
|
||
// Pixel + vertex shaders
|
||
m_ShadowShaderState.m_VertexShader = INVALID_SHADER;
|
||
m_ShadowShaderState.m_PixelShader = INVALID_SHADER;
|
||
m_ShadowShaderState.m_nStaticPshIndex = 0;
|
||
m_ShadowShaderState.m_nStaticVshIndex = 0;
|
||
m_ShadowShaderState.m_VertexUsage = 0;
|
||
|
||
m_ShadowState.m_nFetch4Enable = 0;
|
||
#if ( defined ( DX_TO_GL_ABSTRACTION ) )
|
||
m_ShadowState.m_nShadowFilterEnable = 0;
|
||
#endif
|
||
|
||
for (int i = 0; i < MAX_SAMPLERS; ++i)
|
||
{
|
||
// A *real* measure if the texture stage is being used.
|
||
// we sometimes have to set the shadow state to not mirror this.
|
||
m_SamplerState[i].m_TextureEnable = false;
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Sets the default state
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::SetDefaultState()
|
||
{
|
||
DepthFunc( SHADER_DEPTHFUNC_NEAREROREQUAL );
|
||
EnableDepthWrites( true );
|
||
EnableDepthTest( true );
|
||
EnableColorWrites( true );
|
||
EnableAlphaWrites( false );
|
||
EnableAlphaTest( false );
|
||
EnableBlending( false );
|
||
BlendFunc( SHADER_BLEND_ZERO, SHADER_BLEND_ZERO );
|
||
BlendOp( SHADER_BLEND_OP_ADD );
|
||
EnableBlendingSeparateAlpha( false );
|
||
BlendFuncSeparateAlpha( SHADER_BLEND_ZERO, SHADER_BLEND_ZERO );
|
||
BlendOpSeparateAlpha( SHADER_BLEND_OP_ADD );
|
||
AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, 0.7f );
|
||
PolyMode( SHADER_POLYMODEFACE_FRONT_AND_BACK, SHADER_POLYMODE_FILL );
|
||
EnableCulling( true );
|
||
EnableAlphaToCoverage( false );
|
||
EnablePolyOffset( SHADER_POLYOFFSET_DISABLE );
|
||
EnableSRGBWrite( false );
|
||
SetVertexShader( NULL, 0 );
|
||
SetPixelShader( NULL, 0 );
|
||
FogMode( SHADER_FOGMODE_DISABLED, false );
|
||
DisableFogGammaCorrection( false );
|
||
m_ShadowShaderState.m_VertexUsage = 0;
|
||
|
||
int i;
|
||
int nSamplerCount = HardwareConfig()->GetSamplerCount();
|
||
for( i = 0; i < nSamplerCount; i++ )
|
||
{
|
||
EnableTexture( (Sampler_t)i, false );
|
||
EnableSRGBRead( (Sampler_t)i, false );
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Gets at the shadow state
|
||
//-----------------------------------------------------------------------------
|
||
const ShadowState_t &CShaderShadowDX8::GetShadowState()
|
||
{
|
||
return m_ShadowState;
|
||
}
|
||
|
||
const ShadowShaderState_t &CShaderShadowDX8::GetShadowShaderState()
|
||
{
|
||
return m_ShadowShaderState;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Depth functions...
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::DepthFunc( ShaderDepthFunc_t depthFunc )
|
||
{
|
||
D3DCMPFUNC zFunc;
|
||
|
||
switch( depthFunc )
|
||
{
|
||
case SHADER_DEPTHFUNC_NEVER:
|
||
zFunc = D3DCMP_NEVER;
|
||
break;
|
||
case SHADER_DEPTHFUNC_NEARER:
|
||
zFunc = (ShaderUtil()->GetConfig().bReverseDepth ^ ReverseDepthOnX360()) ? D3DCMP_GREATER : D3DCMP_LESS;
|
||
break;
|
||
case SHADER_DEPTHFUNC_EQUAL:
|
||
zFunc = D3DCMP_EQUAL;
|
||
break;
|
||
case SHADER_DEPTHFUNC_NEAREROREQUAL:
|
||
zFunc = (ShaderUtil()->GetConfig().bReverseDepth ^ ReverseDepthOnX360()) ? D3DCMP_GREATEREQUAL : D3DCMP_LESSEQUAL;
|
||
break;
|
||
case SHADER_DEPTHFUNC_FARTHER:
|
||
zFunc = (ShaderUtil()->GetConfig().bReverseDepth ^ ReverseDepthOnX360()) ? D3DCMP_LESS : D3DCMP_GREATER;
|
||
break;
|
||
case SHADER_DEPTHFUNC_NOTEQUAL:
|
||
zFunc = D3DCMP_NOTEQUAL;
|
||
break;
|
||
case SHADER_DEPTHFUNC_FARTHEROREQUAL:
|
||
zFunc = (ShaderUtil()->GetConfig().bReverseDepth ^ ReverseDepthOnX360()) ? D3DCMP_LESSEQUAL : D3DCMP_GREATEREQUAL;
|
||
break;
|
||
case SHADER_DEPTHFUNC_ALWAYS:
|
||
zFunc = D3DCMP_ALWAYS;
|
||
break;
|
||
default:
|
||
zFunc = D3DCMP_ALWAYS;
|
||
Warning( "DepthFunc: invalid param\n" );
|
||
break;
|
||
}
|
||
|
||
m_ShadowState.m_DepthTestState.m_ZFunc = zFunc;
|
||
}
|
||
|
||
void CShaderShadowDX8::EnableDepthWrites( bool bEnable )
|
||
{
|
||
m_ShadowState.m_DepthTestState.m_ZWriteEnable = bEnable;
|
||
}
|
||
|
||
void CShaderShadowDX8::EnableDepthTest( bool bEnable )
|
||
{
|
||
m_ShadowState.m_DepthTestState.m_ZEnable = bEnable ? D3DZB_TRUE : D3DZB_FALSE;
|
||
}
|
||
|
||
void CShaderShadowDX8::EnablePolyOffset( PolygonOffsetMode_t nOffsetMode )
|
||
{
|
||
m_ShadowState.m_DepthTestState.m_ZBias = nOffsetMode;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Color write state
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::EnableColorWrites( bool bEnable )
|
||
{
|
||
if (bEnable)
|
||
{
|
||
m_ShadowState.m_DepthTestState.m_ColorWriteEnable |= D3DCOLORWRITEENABLE_BLUE |
|
||
D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED;
|
||
}
|
||
else
|
||
{
|
||
m_ShadowState.m_DepthTestState.m_ColorWriteEnable &= ~( D3DCOLORWRITEENABLE_BLUE |
|
||
D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED );
|
||
}
|
||
}
|
||
|
||
void CShaderShadowDX8::EnableAlphaWrites( bool bEnable )
|
||
{
|
||
if (bEnable)
|
||
{
|
||
m_ShadowState.m_DepthTestState.m_ColorWriteEnable |= D3DCOLORWRITEENABLE_ALPHA;
|
||
}
|
||
else
|
||
{
|
||
m_ShadowState.m_DepthTestState.m_ColorWriteEnable &= ~D3DCOLORWRITEENABLE_ALPHA;
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Alpha blending states
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::EnableBlending( bool bEnable )
|
||
{
|
||
m_ShadowState.m_AlphaBlendState.m_AlphaBlendEnable = bEnable;
|
||
m_ShadowState.m_AlphaBlendState.m_AlphaBlendEnabledForceOpaque = false;
|
||
}
|
||
|
||
void CShaderShadowDX8::EnableBlendingForceOpaque( bool bEnable )
|
||
{
|
||
m_ShadowState.m_AlphaBlendState.m_AlphaBlendEnable = bEnable;
|
||
m_ShadowState.m_AlphaBlendState.m_AlphaBlendEnabledForceOpaque = true;
|
||
}
|
||
|
||
// Separate alpha blending
|
||
void CShaderShadowDX8::EnableBlendingSeparateAlpha( bool bEnable )
|
||
{
|
||
m_ShadowState.m_AlphaBlendState.m_SeparateAlphaBlendEnable = bEnable;
|
||
}
|
||
|
||
void CShaderShadowDX8::EnableAlphaTest( bool bEnable )
|
||
{
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_AlphaTestEnable = bEnable;
|
||
}
|
||
|
||
void CShaderShadowDX8::AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ )
|
||
{
|
||
D3DCMPFUNC d3dCmpFunc;
|
||
|
||
switch( alphaFunc )
|
||
{
|
||
case SHADER_ALPHAFUNC_NEVER:
|
||
d3dCmpFunc = D3DCMP_NEVER;
|
||
break;
|
||
case SHADER_ALPHAFUNC_LESS:
|
||
d3dCmpFunc = D3DCMP_LESS;
|
||
break;
|
||
case SHADER_ALPHAFUNC_EQUAL:
|
||
d3dCmpFunc = D3DCMP_EQUAL;
|
||
break;
|
||
case SHADER_ALPHAFUNC_LEQUAL:
|
||
d3dCmpFunc = D3DCMP_LESSEQUAL;
|
||
break;
|
||
case SHADER_ALPHAFUNC_GREATER:
|
||
d3dCmpFunc = D3DCMP_GREATER;
|
||
break;
|
||
case SHADER_ALPHAFUNC_NOTEQUAL:
|
||
d3dCmpFunc = D3DCMP_NOTEQUAL;
|
||
break;
|
||
case SHADER_ALPHAFUNC_GEQUAL:
|
||
d3dCmpFunc = D3DCMP_GREATEREQUAL;
|
||
break;
|
||
case SHADER_ALPHAFUNC_ALWAYS:
|
||
d3dCmpFunc = D3DCMP_ALWAYS;
|
||
break;
|
||
default:
|
||
Warning( "AlphaFunc: invalid param\n" );
|
||
return;
|
||
}
|
||
|
||
m_AlphaFunc = d3dCmpFunc;
|
||
m_AlphaRef = (int)(alphaRef * 255);
|
||
}
|
||
|
||
D3DBLEND CShaderShadowDX8::BlendFuncValue( ShaderBlendFactor_t factor ) const
|
||
{
|
||
switch( factor )
|
||
{
|
||
case SHADER_BLEND_ZERO:
|
||
return D3DBLEND_ZERO;
|
||
|
||
case SHADER_BLEND_ONE:
|
||
return D3DBLEND_ONE;
|
||
|
||
case SHADER_BLEND_DST_COLOR:
|
||
return D3DBLEND_DESTCOLOR;
|
||
|
||
case SHADER_BLEND_ONE_MINUS_DST_COLOR:
|
||
return D3DBLEND_INVDESTCOLOR;
|
||
|
||
case SHADER_BLEND_SRC_ALPHA:
|
||
return D3DBLEND_SRCALPHA;
|
||
|
||
case SHADER_BLEND_ONE_MINUS_SRC_ALPHA:
|
||
return D3DBLEND_INVSRCALPHA;
|
||
|
||
case SHADER_BLEND_DST_ALPHA:
|
||
return D3DBLEND_DESTALPHA;
|
||
|
||
case SHADER_BLEND_ONE_MINUS_DST_ALPHA:
|
||
return D3DBLEND_INVDESTALPHA;
|
||
|
||
case SHADER_BLEND_SRC_ALPHA_SATURATE:
|
||
return D3DBLEND_SRCALPHASAT;
|
||
|
||
case SHADER_BLEND_SRC_COLOR:
|
||
return D3DBLEND_SRCCOLOR;
|
||
|
||
case SHADER_BLEND_ONE_MINUS_SRC_COLOR:
|
||
return D3DBLEND_INVSRCCOLOR;
|
||
}
|
||
|
||
Warning( "BlendFunc: invalid factor\n" );
|
||
return D3DBLEND_ONE;
|
||
}
|
||
|
||
D3DBLENDOP CShaderShadowDX8::BlendOpValue( ShaderBlendOp_t blendOp ) const
|
||
{
|
||
switch( blendOp )
|
||
{
|
||
case SHADER_BLEND_OP_ADD:
|
||
return D3DBLENDOP_ADD;
|
||
|
||
case SHADER_BLEND_OP_SUBTRACT:
|
||
return D3DBLENDOP_SUBTRACT;
|
||
|
||
case SHADER_BLEND_OP_REVSUBTRACT:
|
||
return D3DBLENDOP_REVSUBTRACT;
|
||
|
||
case SHADER_BLEND_OP_MIN:
|
||
return D3DBLENDOP_MIN;
|
||
|
||
case SHADER_BLEND_OP_MAX:
|
||
return D3DBLENDOP_MAX;
|
||
}
|
||
|
||
Warning( "BlendOp: invalid op\n" );
|
||
return D3DBLENDOP_ADD;
|
||
}
|
||
|
||
void CShaderShadowDX8::BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
|
||
{
|
||
D3DBLEND d3dSrcFactor = BlendFuncValue( srcFactor );
|
||
D3DBLEND d3dDstFactor = BlendFuncValue( dstFactor );
|
||
m_SrcBlend = d3dSrcFactor;
|
||
m_DestBlend = d3dDstFactor;
|
||
}
|
||
|
||
// Separate alpha blending
|
||
void CShaderShadowDX8::BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
|
||
{
|
||
D3DBLEND d3dSrcFactor = BlendFuncValue( srcFactor );
|
||
D3DBLEND d3dDstFactor = BlendFuncValue( dstFactor );
|
||
m_SrcBlendAlpha = d3dSrcFactor;
|
||
m_DestBlendAlpha = d3dDstFactor;
|
||
}
|
||
|
||
void CShaderShadowDX8::BlendOp( ShaderBlendOp_t blendOp )
|
||
{
|
||
m_BlendOp = BlendOpValue( blendOp );
|
||
}
|
||
|
||
void CShaderShadowDX8::BlendOpSeparateAlpha( ShaderBlendOp_t blendOp )
|
||
{
|
||
m_BlendOpAlpha = BlendOpValue( blendOp );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Polygon fill mode states
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode )
|
||
{
|
||
// DX8 can't handle different modes on front and back faces
|
||
// FIXME: Assert( face == SHADER_POLYMODEFACE_FRONT_AND_BACK );
|
||
if (face == SHADER_POLYMODEFACE_BACK)
|
||
return;
|
||
|
||
D3DFILLMODE fillMode;
|
||
switch( polyMode )
|
||
{
|
||
case SHADER_POLYMODE_POINT:
|
||
fillMode = D3DFILL_POINT;
|
||
break;
|
||
case SHADER_POLYMODE_LINE:
|
||
fillMode = D3DFILL_WIREFRAME;
|
||
break;
|
||
case SHADER_POLYMODE_FILL:
|
||
fillMode = D3DFILL_SOLID;
|
||
break;
|
||
default:
|
||
Warning( "PolyMode: invalid poly mode\n" );
|
||
return;
|
||
}
|
||
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_FillMode = fillMode;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Backface cull states
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::EnableCulling( bool bEnable )
|
||
{
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_CullEnable = bEnable;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Alpha to coverage
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::EnableAlphaToCoverage( bool bEnable )
|
||
{
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_EnableAlphaToCoverage = bEnable;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Enables auto-conversion from linear to gamma space on write to framebuffer.
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::EnableSRGBWrite( bool bEnable )
|
||
{
|
||
if ( m_pHardwareConfig->SupportsSRGB() )
|
||
{
|
||
m_ShadowState.m_FogAndMiscState.m_SRGBWriteEnable = bEnable;
|
||
}
|
||
else
|
||
{
|
||
m_ShadowState.m_FogAndMiscState.m_SRGBWriteEnable = false;
|
||
}
|
||
}
|
||
|
||
void CShaderShadowDX8::EnableTexture( Sampler_t sampler, bool bEnable )
|
||
{
|
||
if ( sampler < m_pHardwareConfig->GetSamplerCount() )
|
||
{
|
||
m_SamplerState[sampler].m_TextureEnable = bEnable;
|
||
}
|
||
else
|
||
{
|
||
Warning( "Attempting to bind a texture to an invalid sampler (%d)!\n", sampler );
|
||
}
|
||
}
|
||
|
||
void CShaderShadowDX8::EnableVertexTexture( VertexTextureSampler_t vtSampler, bool bEnable )
|
||
{
|
||
if ( vtSampler < m_pHardwareConfig->GetVertexSamplerCount() )
|
||
{
|
||
m_VertexSamplerState[vtSampler].m_TextureEnable = bEnable;
|
||
}
|
||
else
|
||
{
|
||
Warning( "Attempting to bind a texture to an invalid vertex sampler (%d)!\n", vtSampler );
|
||
}
|
||
}
|
||
|
||
|
||
void CShaderShadowDX8::EnableSRGBRead( Sampler_t sampler, bool bEnable )
|
||
{
|
||
}
|
||
|
||
#if 0
|
||
void CShaderShadowDX8::SetShadowDepthFiltering( Sampler_t stage )
|
||
{
|
||
int nMask = ( 1 << stage );
|
||
if ( stage < m_pHardwareConfig->GetSamplerCount() )
|
||
{
|
||
#if ( defined ( POSIX ) )
|
||
// m_ShadowState.m_ShadowFilterEnable |= nMask;
|
||
#else
|
||
if ( !m_pHardwareConfig->SupportsFetch4() )
|
||
{
|
||
m_ShadowState.m_nFetch4Enable &= ~nMask;
|
||
}
|
||
else
|
||
{
|
||
m_ShadowState.m_nFetch4Enable |= nMask;
|
||
}
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
Warning( "Attempting set shadow filtering state on an invalid sampler (%d)!\n", stage );
|
||
}
|
||
}
|
||
#endif
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Compute the vertex format from vertex descriptor flags
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::VertexShaderVertexFormat( unsigned int nFlags,
|
||
int nTexCoordCount, int* pTexCoordDimensions, int nUserDataSize )
|
||
{
|
||
// Code that creates a Mesh should specify whether it contains bone weights+indices, *not* the shader.
|
||
Assert( ( nFlags & VERTEX_BONE_INDEX ) == 0 );
|
||
nFlags &= ~VERTEX_BONE_INDEX;
|
||
|
||
// This indicates we're using a vertex shader
|
||
m_ShadowShaderState.m_VertexUsage = MeshMgr()->ComputeVertexFormat( nFlags, nTexCoordCount,
|
||
pTexCoordDimensions, 0, nUserDataSize );
|
||
|
||
// Avoid an error if vertex stream 0 is too narrow
|
||
if ( CVertexBufferBase::VertexFormatSize( m_ShadowShaderState.m_VertexUsage ) <= 16 )
|
||
{
|
||
// FIXME: this is only necessary because we
|
||
// (a) put the flex normal/position stream in ALL vertex decls
|
||
// (b) bind stream 0's VB to stream 2 if there is no actual flex data
|
||
// ...it would be far more sensible to not add stream 2 to all vertex decls.
|
||
static bool bComplained = false;
|
||
if( !bComplained )
|
||
{
|
||
Warning( "ERROR: shader asking for a too-narrow vertex format - you will see errors if running with debug D3D DLLs!\n\tPadding the vertex format with extra texcoords\n\tWill not warn again.\n" );
|
||
bComplained = true;
|
||
}
|
||
// All vertex formats should contain position...
|
||
Assert( nFlags & VERTEX_POSITION );
|
||
nFlags |= VERTEX_POSITION;
|
||
// This error should occur only if we have zero texcoords, or if we have a single, 1-D texcoord
|
||
Assert( ( nTexCoordCount == 0 ) ||
|
||
( ( nTexCoordCount == 1 ) && pTexCoordDimensions && ( pTexCoordDimensions[0] == 1 ) ) );
|
||
nTexCoordCount = 1;
|
||
m_ShadowShaderState.m_VertexUsage = MeshMgr()->ComputeVertexFormat( nFlags, nTexCoordCount, NULL, 0, nUserDataSize );
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Pixel and vertex shader methods
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::SetVertexShader( const char* pFileName, int nStaticVshIndex )
|
||
{
|
||
char debugLabel[500] = "";
|
||
#ifdef DX_TO_GL_ABSTRACTION
|
||
Q_snprintf( debugLabel, sizeof(debugLabel), "vs-file %s vs-index %d", pFileName, nStaticVshIndex );
|
||
#endif
|
||
|
||
m_ShadowShaderState.m_VertexShader = ShaderManager()->CreateVertexShader( pFileName, nStaticVshIndex, debugLabel );
|
||
m_ShadowShaderState.m_nStaticVshIndex = nStaticVshIndex;
|
||
}
|
||
|
||
void CShaderShadowDX8::SetPixelShader( const char* pFileName, int nStaticPshIndex )
|
||
{
|
||
char debugLabel[500] = "";
|
||
#ifdef DX_TO_GL_ABSTRACTION
|
||
Q_snprintf( debugLabel, sizeof(debugLabel), "ps-file %s ps-index %d", pFileName, nStaticPshIndex );
|
||
#endif
|
||
|
||
m_ShadowShaderState.m_PixelShader = ShaderManager()->CreatePixelShader( pFileName, nStaticPshIndex, debugLabel );
|
||
m_ShadowShaderState.m_nStaticPshIndex = nStaticPshIndex;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Returns the lightmap scale factor
|
||
//-----------------------------------------------------------------------------
|
||
float CShaderShadowDX8::GetLightMapScaleFactor( void ) const
|
||
{
|
||
return g_pHardwareConfig->GetLightMapScaleFactor();
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Fog
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::FogMode( ShaderFogMode_t fogMode, bool bVertexFog )
|
||
{
|
||
Assert( fogMode >= 0 && fogMode < SHADER_FOGMODE_NUMFOGMODES );
|
||
m_ShadowState.m_FogAndMiscState.m_FogMode = fogMode;
|
||
m_ShadowState.m_FogAndMiscState.m_bVertexFogEnable = bVertexFog;
|
||
}
|
||
|
||
void CShaderShadowDX8::DisableFogGammaCorrection( bool bDisable )
|
||
{
|
||
m_ShadowState.m_FogAndMiscState.m_bDisableFogGammaCorrection = bDisable;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// NOTE: See Version 5 of this file for NVidia 8-stage shader stuff
|
||
//-----------------------------------------------------------------------------
|
||
inline bool CShaderShadowDX8::IsUsingTextureCoordinates( Sampler_t sampler ) const
|
||
{
|
||
return m_SamplerState[sampler].m_TextureEnable;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Computes shadow state based on bunches of other parameters
|
||
//-----------------------------------------------------------------------------
|
||
void CShaderShadowDX8::ComputeAggregateShadowState( )
|
||
{
|
||
// Initialize the texture stage usage; this may get changed later
|
||
int nEnableMask = 0;
|
||
for (int i = 0; i < m_pHardwareConfig->GetSamplerCount(); ++i)
|
||
{
|
||
if ( IsUsingTextureCoordinates( (Sampler_t)i ) )
|
||
{
|
||
nEnableMask |= ( 1 << i );
|
||
}
|
||
}
|
||
// Always use the same alpha src + dest if it's disabled
|
||
// NOTE: This is essential for stateblocks to work
|
||
if ( m_ShadowState.m_AlphaBlendState.m_AlphaBlendEnable )
|
||
{
|
||
m_ShadowState.m_AlphaBlendState.m_SrcBlend = m_SrcBlend;
|
||
m_ShadowState.m_AlphaBlendState.m_DestBlend = m_DestBlend;
|
||
m_ShadowState.m_AlphaBlendState.m_BlendOp = m_BlendOp;
|
||
}
|
||
else
|
||
{
|
||
m_ShadowState.m_AlphaBlendState.m_SrcBlend = D3DBLEND_ONE;
|
||
m_ShadowState.m_AlphaBlendState.m_DestBlend = D3DBLEND_ZERO;
|
||
m_ShadowState.m_AlphaBlendState.m_BlendOp = D3DBLENDOP_ADD;
|
||
}
|
||
|
||
// GR
|
||
if (m_ShadowState.m_AlphaBlendState.m_SeparateAlphaBlendEnable)
|
||
{
|
||
m_ShadowState.m_AlphaBlendState.m_SrcBlendAlpha = m_SrcBlendAlpha;
|
||
m_ShadowState.m_AlphaBlendState.m_DestBlendAlpha = m_DestBlendAlpha;
|
||
m_ShadowState.m_AlphaBlendState.m_BlendOpAlpha = m_BlendOpAlpha;
|
||
}
|
||
else
|
||
{
|
||
m_ShadowState.m_AlphaBlendState.m_SrcBlendAlpha = D3DBLEND_ONE;
|
||
m_ShadowState.m_AlphaBlendState.m_DestBlendAlpha = D3DBLEND_ZERO;
|
||
m_ShadowState.m_AlphaBlendState.m_BlendOpAlpha = D3DBLENDOP_ADD;
|
||
}
|
||
|
||
// Use the same func if it's disabled
|
||
if (m_ShadowState.m_AlphaTestAndMiscState.m_AlphaTestEnable)
|
||
{
|
||
// If alpha test is enabled, just use the values set
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_AlphaFunc = m_AlphaFunc;
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_AlphaRef = m_AlphaRef;
|
||
}
|
||
else
|
||
{
|
||
// A default value
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_AlphaFunc = D3DCMP_GREATEREQUAL;
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_AlphaRef = 0;
|
||
|
||
// If not alpha testing and doing a standard alpha blend, force on alpha testing
|
||
if ( m_ShadowState.m_AlphaBlendState.m_AlphaBlendEnable )
|
||
{
|
||
if ( ( m_ShadowState.m_AlphaBlendState.m_SrcBlend == D3DBLEND_SRCALPHA ) && ( m_ShadowState.m_AlphaBlendState.m_DestBlend == D3DBLEND_INVSRCALPHA ) )
|
||
{
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_AlphaFunc = D3DCMP_GREATEREQUAL;
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_AlphaRef = 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Alpha to coverage
|
||
if ( m_ShadowState.m_AlphaTestAndMiscState.m_EnableAlphaToCoverage )
|
||
{
|
||
// Only allow this to be enabled if blending is disabled and testing is enabled
|
||
if ( ( m_ShadowState.m_AlphaBlendState.m_AlphaBlendEnable == true ) || ( m_ShadowState.m_AlphaTestAndMiscState.m_AlphaTestEnable == false ) )
|
||
{
|
||
m_ShadowState.m_AlphaTestAndMiscState.m_EnableAlphaToCoverage = false;
|
||
}
|
||
}
|
||
}
|