d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
521 Commits
25 Branches
6 Tags
221 MiB
Tree: b9cf6b2c7e
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b9cf6b2c7e'
${ noResults }
source-engine/materialsystem/shaderapidx9/shadershadowdx8.cpp

1827 lines
55 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright 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 );
// Methods related to stencil. obsolete
virtual void EnableStencil( bool bEnable )
{
}
virtual void StencilFunc( ShaderStencilFunc_t stencilFunc )
{
}
virtual void StencilPassOp( ShaderStencilOp_t stencilOp )
{
}
virtual void StencilFailOp( ShaderStencilOp_t stencilOp )
{
}
virtual void StencilDepthFailOp( ShaderStencilOp_t stencilOp )
{
}
virtual void StencilReference( int nReference )
{
}
virtual void StencilMask( int nMask )
{
}
virtual void StencilWriteMask( int nMask )
{
}
// Suppresses/activates color writing
void EnableColorWrites( bool bEnable );
void EnableAlphaWrites( bool bEnable );
// Methods related to alpha blending
void EnableBlending( bool bEnable );
void BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor );
void BlendOp( ShaderBlendOp_t blendOp );
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 );
// constant color
void EnableConstantColor( bool bEnable );
// Indicates we're going to light the model
void EnableLighting( bool bEnable );
// Indicates specular lighting is going to be used
void EnableSpecular( 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 );
// Indicates we're going to be using the ambient cube
void EnableAmbientLightCubeOnStage0( bool bEnable );
// Activate/deactivate skinning
void EnableVertexBlend( bool bEnable );
// per texture unit stuff
void OverbrightValue( TextureStage_t stage, float value );
void EnableTexture( Sampler_t stage, bool bEnable );
void EnableTexGen( TextureStage_t stage, bool bEnable );
void TexGen( TextureStage_t stage, ShaderTexGenParam_t param );
void TextureCoordinate( TextureStage_t stage, int useCoord );
// alternate method of specifying per-texture unit stuff, more flexible and more complicated
// Can be used to specify different operation per channel (alpha/color)...
void EnableCustomPixelPipe( bool bEnable );
void CustomTextureStages( int stageCount );
void CustomTextureOperation( TextureStage_t stage, ShaderTexChannel_t channel,
ShaderTexOp_t op, ShaderTexArg_t arg1, ShaderTexArg_t arg2 );
// A simpler method of dealing with alpha modulation
void EnableAlphaPipe( bool bEnable );
void EnableConstantAlpha( bool bEnable );
void EnableVertexAlpha( bool bEnable );
void EnableTextureAlpha( TextureStage_t stage, bool bEnable );
// helper functions
void EnableSphereMapping( TextureStage_t stage, bool bEnable );
// Last call to be make before snapshotting
void ComputeAggregateShadowState( );
// Gets at the shadow state
const ShadowState_t & GetShadowState();
const ShadowShaderState_t & GetShadowShaderState();
// GR - Separate alpha blending
void EnableBlendingSeparateAlpha( bool bEnable );
void BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor );
void FogMode( ShaderFogMode_t fogMode );
void DisableFogGammaCorrection( bool bDisable );
void SetDiffuseMaterialSource( ShaderMaterialSource_t materialSource );
virtual void SetMorphFormat( MorphFormat_t flags );
// Alpha to coverage
void EnableAlphaToCoverage( bool bEnable );
private:
struct TextureStageState_t
{
int m_TexCoordIndex;
int m_TexCoordinate;
float m_OverbrightVal;
ShaderTexArg_t m_Arg[2][2];
ShaderTexOp_t m_Op[2];
unsigned char m_TexGenEnable:1;
unsigned char m_TextureAlphaEnable:1;
};
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 the FVF vertex shader
void ConfigureFVFVertexShader( unsigned int flags );
void ConfigureCustomFVFVertexShader( unsigned int flags );
// Configures our texture indices
void ConfigureTextureCoordinates( unsigned int flags );
// Returns a blend value based on overbrighting
D3DTEXTUREOP OverbrightBlendValue( TextureStage_t stage );
// Sets the desired color and alpha op state
void DrawFlags( unsigned int flags );
// Computes a vertex format for the draw flags
VertexFormat_t FlagsToVertexFormat( int flags ) const;
// Indicates we've got a constant color specified
bool HasConstantColor() const;
// Configures the alpha pipe
void ConfigureAlphaPipe( unsigned int flags );
// returns true if we're using texture coordinates at a given stage
bool IsUsingTextureCoordinates( Sampler_t stage ) const;
// Recomputes the tex coord index
void RecomputeTexCoordIndex( TextureStage_t stage );
// State needed to create the snapshots
IMaterialSystemHardwareConfig* m_pHardwareConfig;
// Separate alpha control?
bool m_AlphaPipe;
// Constant color state
bool m_HasConstantColor;
bool m_HasConstantAlpha;
// Vertex color state
bool m_HasVertexAlpha;
// funky custom method of specifying shader state
bool m_CustomTextureStageState;
// Number of stages used by the custom pipeline
int m_CustomTextureStages;
// Number of bones...
int m_NumBlendVertices;
// Draw flags
int m_DrawFlags;
// Alpha blending...
D3DBLEND m_SrcBlend;
D3DBLEND m_DestBlend;
D3DBLENDOP m_BlendOp;
// GR - Separate alpha blending...
D3DBLEND m_SrcBlendAlpha;
D3DBLEND m_DestBlendAlpha;
D3DBLENDOP m_BlendOpAlpha;
// Alpha testing
D3DCMPFUNC m_AlphaFunc;
int m_AlphaRef;
// Stencil
D3DCMPFUNC m_StencilFunc;
int m_StencilRef;
int m_StencilMask;
DWORD m_StencilFail;
DWORD m_StencilZFail;
DWORD m_StencilPass;
int m_StencilWriteMask;
// The current shadow state
ShadowState_t m_ShadowState;
ShadowShaderState_t m_ShadowShaderState;
// State info stores with each texture stage
TextureStageState_t m_TextureStage[MAX_TEXTURE_STAGES];
SamplerState_t m_SamplerState[MAX_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_DrawFlags(0), m_pHardwareConfig(0), m_HasConstantColor(false)
{
memset( &m_ShadowState, 0, sizeof(m_ShadowState) );
memset( &m_TextureStage, 0, sizeof(m_TextureStage) );
}
CShaderShadowDX8::~CShaderShadowDX8()
{
}
//-----------------------------------------------------------------------------
// Initialize render state
//-----------------------------------------------------------------------------
void CShaderShadowDX8::Init( )
{
m_pHardwareConfig = HardwareConfig();
// Clear out the shadow state
memset( &m_ShadowState, 0, sizeof(m_ShadowState) );
// No funky custom methods..
m_CustomTextureStageState = false;
// No constant color modulation
m_HasConstantColor = false;
m_HasConstantAlpha = false;
m_HasVertexAlpha = false;
m_ShadowShaderState.m_ModulateConstantColor = false;
m_ShadowState.m_bDisableFogGammaCorrection = false;
// By default we're using fixed function
m_ShadowState.m_UsingFixedFunction = true;
// Lighting off by default
m_ShadowState.m_Lighting = 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;
// Drawing nothing..
m_DrawFlags = 0;
// No alpha control
m_AlphaPipe = false;
// Vertex blending
m_NumBlendVertices = 0;
m_ShadowState.m_VertexBlendEnable = false;
// NOTE: If you change these defaults, change the code in ComputeAggregateShadowState + CreateTransitionTableEntry
int i;
for (i = 0; i < MAX_TEXTURE_STAGES; ++i)
{
m_ShadowState.m_TextureStage[i].m_ColorOp = D3DTOP_DISABLE;
m_ShadowState.m_TextureStage[i].m_ColorArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_ColorArg2 = (i == 0) ? D3DTA_DIFFUSE : D3DTA_CURRENT;
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_DISABLE;
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = (i == 0) ? D3DTA_DIFFUSE : D3DTA_CURRENT;
m_ShadowState.m_TextureStage[i].m_TexCoordIndex = i;
}
for (i = 0; i < MAX_SAMPLERS; ++i)
{
m_ShadowState.m_SamplerState[i].m_TextureEnable = false;
m_ShadowState.m_SamplerState[i].m_SRGBReadEnable = false;
m_ShadowState.m_SamplerState[i].m_Fetch4Enable = false;
#ifdef DX_TO_GL_ABSTRACTION
m_ShadowState.m_SamplerState[i].m_ShadowFilterEnable = false;
#endif
// 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 );
EnableLighting( false );
EnableConstantColor( false );
EnableBlending( false );
BlendFunc( SHADER_BLEND_ONE, SHADER_BLEND_ZERO );
BlendOp( SHADER_BLEND_OP_ADD );
// GR - separate alpha
EnableBlendingSeparateAlpha( false );
BlendFuncSeparateAlpha( SHADER_BLEND_ONE, 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 );
EnableVertexBlend( false );
EnableSpecular( false );
EnableSRGBWrite( false );
DrawFlags( SHADER_DRAW_POSITION );
EnableCustomPixelPipe( false );
CustomTextureStages( 0 );
EnableAlphaPipe( false );
EnableConstantAlpha( false );
EnableVertexAlpha( false );
SetVertexShader( NULL, 0 );
SetPixelShader( NULL, 0 );
FogMode( SHADER_FOGMODE_DISABLED );
DisableFogGammaCorrection( false );
SetDiffuseMaterialSource( SHADER_MATERIALSOURCE_MATERIAL );
EnableStencil( false );
StencilFunc( SHADER_STENCILFUNC_ALWAYS );
StencilPassOp( SHADER_STENCILOP_KEEP );
StencilFailOp( SHADER_STENCILOP_KEEP );
StencilDepthFailOp( SHADER_STENCILOP_KEEP );
StencilReference( 0 );
StencilMask( 0xFFFFFFFF );
StencilWriteMask( 0xFFFFFFFF );
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 );
}
int nTextureStageCount = HardwareConfig()->GetTextureStageCount();
for( i = 0; i < nTextureStageCount; i++ )
{
EnableTexGen( (TextureStage_t)i, false );
OverbrightValue( (TextureStage_t)i, 1.0f );
EnableTextureAlpha( (TextureStage_t)i, false );
CustomTextureOperation( (TextureStage_t)i, SHADER_TEXCHANNEL_COLOR,
SHADER_TEXOP_DISABLE, SHADER_TEXARG_TEXTURE, SHADER_TEXARG_PREVIOUSSTAGE );
CustomTextureOperation( (TextureStage_t)i, SHADER_TEXCHANNEL_ALPHA,
SHADER_TEXOP_DISABLE, SHADER_TEXARG_TEXTURE, SHADER_TEXARG_PREVIOUSSTAGE );
}
}
//-----------------------------------------------------------------------------
// 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_ZFunc = zFunc;
}
void CShaderShadowDX8::EnableDepthWrites( bool bEnable )
{
m_ShadowState.m_ZWriteEnable = bEnable;
}
void CShaderShadowDX8::EnableDepthTest( bool bEnable )
{
m_ShadowState.m_ZEnable = bEnable ? D3DZB_TRUE : D3DZB_FALSE;
}
void CShaderShadowDX8::EnablePolyOffset( PolygonOffsetMode_t nOffsetMode )
{
m_ShadowState.m_ZBias = nOffsetMode;
}
//-----------------------------------------------------------------------------
// Color write state
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableColorWrites( bool bEnable )
{
if (bEnable)
{
m_ShadowState.m_ColorWriteEnable |= D3DCOLORWRITEENABLE_BLUE |
D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED;
}
else
{
m_ShadowState.m_ColorWriteEnable &= ~( D3DCOLORWRITEENABLE_BLUE |
D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED );
}
}
void CShaderShadowDX8::EnableAlphaWrites( bool bEnable )
{
if (bEnable)
{
m_ShadowState.m_ColorWriteEnable |= D3DCOLORWRITEENABLE_ALPHA;
}
else
{
m_ShadowState.m_ColorWriteEnable &= ~D3DCOLORWRITEENABLE_ALPHA;
}
}
//-----------------------------------------------------------------------------
// Alpha blending states
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableBlending( bool bEnable )
{
m_ShadowState.m_AlphaBlendEnable = bEnable;
}
// GR - separate alpha
void CShaderShadowDX8::EnableBlendingSeparateAlpha( bool bEnable )
{
m_ShadowState.m_SeparateAlphaBlendEnable = bEnable;
}
void CShaderShadowDX8::EnableAlphaTest( bool bEnable )
{
m_ShadowState.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;
}
// GR - separate alpha blend
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_FillMode = fillMode;
}
//-----------------------------------------------------------------------------
// Backface cull states
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableCulling( bool bEnable )
{
m_ShadowState.m_CullEnable = bEnable;
}
//-----------------------------------------------------------------------------
// Alpha to coverage
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableAlphaToCoverage( bool bEnable )
{
m_ShadowState.m_EnableAlphaToCoverage = bEnable;
}
//-----------------------------------------------------------------------------
// Indicates we've got a constant color specified
//-----------------------------------------------------------------------------
bool CShaderShadowDX8::HasConstantColor() const
{
return m_HasConstantColor;
}
void CShaderShadowDX8::EnableConstantColor( bool bEnable )
{
m_HasConstantColor = bEnable;
}
//-----------------------------------------------------------------------------
// A simpler method of dealing with alpha modulation
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableAlphaPipe( bool bEnable )
{
m_AlphaPipe = bEnable;
}
void CShaderShadowDX8::EnableConstantAlpha( bool bEnable )
{
m_HasConstantAlpha = bEnable;
}
void CShaderShadowDX8::EnableVertexAlpha( bool bEnable )
{
m_HasVertexAlpha = bEnable;
}
void CShaderShadowDX8::EnableTextureAlpha( TextureStage_t stage, bool bEnable )
{
if ( stage < m_pHardwareConfig->GetSamplerCount() )
{
m_TextureStage[stage].m_TextureAlphaEnable = bEnable;
}
}
//-----------------------------------------------------------------------------
// Indicates we're going to light the model
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableLighting( bool bEnable )
{
m_ShadowState.m_Lighting = bEnable;
}
//-----------------------------------------------------------------------------
// Enables specular lighting (lighting has also got to be enabled)
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableSpecular( bool bEnable )
{
m_ShadowState.m_SpecularEnable = 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_SRGBWriteEnable = bEnable;
}
else
{
m_ShadowState.m_SRGBWriteEnable = false;
}
}
//-----------------------------------------------------------------------------
// Activate/deactivate skinning
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableVertexBlend( bool bEnable )
{
// Activate/deactivate skinning. Indexed blending is automatically
// enabled if it's available for this hardware. When blending is enabled,
// we allocate enough room for 3 weights (max allowed)
if ((m_pHardwareConfig->MaxBlendMatrices() > 0) || (!bEnable))
{
m_ShadowState.m_VertexBlendEnable = bEnable;
}
}
//-----------------------------------------------------------------------------
// Texturemapping state
//-----------------------------------------------------------------------------
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::EnableSRGBRead( Sampler_t sampler, bool bEnable )
{
if ( !m_pHardwareConfig->SupportsSRGB() )
{
m_ShadowState.m_SamplerState[sampler].m_SRGBReadEnable = false;
return;
}
if ( sampler < m_pHardwareConfig->GetSamplerCount() )
{
m_ShadowState.m_SamplerState[sampler].m_SRGBReadEnable = bEnable;
}
else
{
Warning( "Attempting set SRGBRead state on an invalid sampler (%d)!\n", sampler );
}
}
void CShaderShadowDX8::SetShadowDepthFiltering( Sampler_t stage )
{
#ifdef DX_TO_GL_ABSTRACTION
if ( stage < m_pHardwareConfig->GetSamplerCount() )
{
m_ShadowState.m_SamplerState[stage].m_ShadowFilterEnable = true;
return;
}
#else
if ( !m_pHardwareConfig->SupportsFetch4() )
{
m_ShadowState.m_SamplerState[stage].m_Fetch4Enable = false;
return;
}
if ( stage < m_pHardwareConfig->GetSamplerCount() )
{
m_ShadowState.m_SamplerState[stage].m_Fetch4Enable = true;
return;
}
#endif
Warning( "Attempting set shadow filtering state on an invalid sampler (%d)!\n", stage );
}
//-----------------------------------------------------------------------------
// Binds texture coordinates to a particular stage...
//-----------------------------------------------------------------------------
void CShaderShadowDX8::TextureCoordinate( TextureStage_t stage, int useTexCoord )
{
if ( stage < m_pHardwareConfig->GetTextureStageCount() )
{
m_TextureStage[stage].m_TexCoordinate = useTexCoord;
// Need to recompute the texCoordIndex, since that's affected by this
RecomputeTexCoordIndex(stage);
}
}
//-----------------------------------------------------------------------------
// Automatic texture coordinate generation
//-----------------------------------------------------------------------------
void CShaderShadowDX8::RecomputeTexCoordIndex( TextureStage_t stage )
{
int texCoordIndex = m_TextureStage[stage].m_TexCoordinate;
if (m_TextureStage[stage].m_TexGenEnable)
texCoordIndex |= m_TextureStage[stage].m_TexCoordIndex;
m_ShadowState.m_TextureStage[stage].m_TexCoordIndex = texCoordIndex;
}
//-----------------------------------------------------------------------------
// Automatic texture coordinate generation
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableTexGen( TextureStage_t stage, bool bEnable )
{
if ( stage >= m_pHardwareConfig->GetTextureStageCount() )
{
Assert( 0 );
return;
}
m_TextureStage[stage].m_TexGenEnable = bEnable;
RecomputeTexCoordIndex(stage);
}
//-----------------------------------------------------------------------------
// Automatic texture coordinate generation
//-----------------------------------------------------------------------------
void CShaderShadowDX8::TexGen( TextureStage_t stage, ShaderTexGenParam_t param )
{
#ifdef FIXED_FUNCTION_PIPELINE
if ( stage >= m_pHardwareConfig->GetTextureStageCount() )
return;
switch( param )
{
case SHADER_TEXGENPARAM_OBJECT_LINEAR:
m_TextureStage[stage].m_TexCoordIndex = 0;
break;
case SHADER_TEXGENPARAM_EYE_LINEAR:
m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_CAMERASPACEPOSITION;
break;
case SHADER_TEXGENPARAM_SPHERE_MAP:
if ( m_pHardwareConfig->SupportsSpheremapping() )
{
m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_SPHEREMAP;
}
else
{
m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;
}
break;
case SHADER_TEXGENPARAM_CAMERASPACEREFLECTIONVECTOR:
m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;
break;
case SHADER_TEXGENPARAM_CAMERASPACENORMAL:
m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_CAMERASPACENORMAL;
break;
}
// Set the board state...
RecomputeTexCoordIndex(stage);
#endif
}
//-----------------------------------------------------------------------------
// Overbrighting
//-----------------------------------------------------------------------------
void CShaderShadowDX8::OverbrightValue( TextureStage_t stage, float value )
{
if ( m_pHardwareConfig->SupportsOverbright() &&
( stage < m_pHardwareConfig->GetTextureStageCount() ) )
{
m_TextureStage[stage].m_OverbrightVal = value;
}
}
//-----------------------------------------------------------------------------
// alternate method of specifying per-texture unit stuff, more flexible and more complicated
// Can be used to specify different operation per channel (alpha/color)...
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableCustomPixelPipe( bool bEnable )
{
m_CustomTextureStageState = bEnable;
}
void CShaderShadowDX8::CustomTextureStages( int stageCount )
{
m_CustomTextureStages = stageCount;
Assert( stageCount <= m_pHardwareConfig->GetTextureStageCount() );
if ( stageCount > m_pHardwareConfig->GetTextureStageCount() )
stageCount = m_pHardwareConfig->GetTextureStageCount();
}
void CShaderShadowDX8::CustomTextureOperation( TextureStage_t stage,
ShaderTexChannel_t channel, ShaderTexOp_t op, ShaderTexArg_t arg1, ShaderTexArg_t arg2 )
{
m_TextureStage[stage].m_Op[channel]= op;
m_TextureStage[stage].m_Arg[channel][0] = arg1;
m_TextureStage[stage].m_Arg[channel][1] = arg2;
}
//-----------------------------------------------------------------------------
// 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
nFlags |= VERTEX_FORMAT_VERTEX_SHADER;
m_ShadowShaderState.m_VertexUsage = MeshMgr()->ComputeVertexFormat( nFlags, nTexCoordCount,
pTexCoordDimensions, 0, nUserDataSize );
m_ShadowState.m_UsingFixedFunction = false;
// 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 );
}
}
//-----------------------------------------------------------------------------
// Compute the vertex format from vertex descriptor flags
//-----------------------------------------------------------------------------
void CShaderShadowDX8::SetMorphFormat( MorphFormat_t flags )
{
m_ShadowShaderState.m_MorphUsage = flags;
}
//-----------------------------------------------------------------------------
// 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;
}
//-----------------------------------------------------------------------------
// 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;
}
inline D3DTEXTUREOP CShaderShadowDX8::OverbrightBlendValue( TextureStage_t stage )
{
D3DTEXTUREOP colorop;
if (m_TextureStage[stage].m_OverbrightVal < 2.0F)
colorop = D3DTOP_MODULATE;
else if (m_TextureStage[stage].m_OverbrightVal < 4.0F)
colorop = D3DTOP_MODULATE2X;
else
colorop = D3DTOP_MODULATE4X;
return colorop;
}
static inline int ComputeArg( ShaderTexArg_t arg )
{
switch(arg)
{
case SHADER_TEXARG_TEXTURE:
return D3DTA_TEXTURE;
case SHADER_TEXARG_ZERO:
return D3DTA_SPECULAR | D3DTA_COMPLEMENT;
case SHADER_TEXARG_ONE:
return D3DTA_SPECULAR;
case SHADER_TEXARG_TEXTUREALPHA:
return D3DTA_TEXTURE | D3DTA_ALPHAREPLICATE;
case SHADER_TEXARG_INVTEXTUREALPHA:
return D3DTA_TEXTURE | D3DTA_ALPHAREPLICATE | D3DTA_COMPLEMENT;
case SHADER_TEXARG_NONE:
case SHADER_TEXARG_VERTEXCOLOR:
return D3DTA_DIFFUSE;
case SHADER_TEXARG_SPECULARCOLOR:
return D3DTA_SPECULAR;
case SHADER_TEXARG_CONSTANTCOLOR:
return D3DTA_TFACTOR;
case SHADER_TEXARG_PREVIOUSSTAGE:
return D3DTA_CURRENT;
}
Assert(0);
return D3DTA_TEXTURE;
}
static inline D3DTEXTUREOP ComputeOp( ShaderTexOp_t op )
{
switch(op)
{
case SHADER_TEXOP_MODULATE:
return D3DTOP_MODULATE;
case SHADER_TEXOP_MODULATE2X:
return D3DTOP_MODULATE2X;
case SHADER_TEXOP_MODULATE4X:
return D3DTOP_MODULATE4X;
case SHADER_TEXOP_SELECTARG1:
return D3DTOP_SELECTARG1;
case SHADER_TEXOP_SELECTARG2:
return D3DTOP_SELECTARG2;
case SHADER_TEXOP_ADD:
return D3DTOP_ADD;
case SHADER_TEXOP_SUBTRACT:
return D3DTOP_SUBTRACT;
case SHADER_TEXOP_ADDSIGNED2X:
return D3DTOP_ADDSIGNED2X;
case SHADER_TEXOP_BLEND_CONSTANTALPHA:
return D3DTOP_BLENDFACTORALPHA;
case SHADER_TEXOP_BLEND_PREVIOUSSTAGEALPHA:
return D3DTOP_BLENDCURRENTALPHA;
case SHADER_TEXOP_BLEND_TEXTUREALPHA:
return D3DTOP_BLENDTEXTUREALPHA;
case SHADER_TEXOP_MODULATECOLOR_ADDALPHA:
return D3DTOP_MODULATECOLOR_ADDALPHA;
case SHADER_TEXOP_MODULATEINVCOLOR_ADDALPHA:
return D3DTOP_MODULATEINVCOLOR_ADDALPHA;
case SHADER_TEXOP_DOTPRODUCT3:
return D3DTOP_DOTPRODUCT3;
case SHADER_TEXOP_DISABLE:
return D3DTOP_DISABLE;
}
Assert(0);
return D3DTOP_MODULATE;
}
void CShaderShadowDX8::ConfigureCustomFVFVertexShader( unsigned int flags )
{
int i;
for ( i = 0; i < m_CustomTextureStages; ++i)
{
m_ShadowState.m_TextureStage[i].m_ColorArg1 = ComputeArg( m_TextureStage[i].m_Arg[0][0] );
m_ShadowState.m_TextureStage[i].m_ColorArg2 = ComputeArg( m_TextureStage[i].m_Arg[0][1] );
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = ComputeArg( m_TextureStage[i].m_Arg[1][0] );
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = ComputeArg( m_TextureStage[i].m_Arg[1][1] );
m_ShadowState.m_TextureStage[i].m_ColorOp = ComputeOp( m_TextureStage[i].m_Op[0] );
m_ShadowState.m_TextureStage[i].m_AlphaOp = ComputeOp( m_TextureStage[i].m_Op[1] );
}
// Deal with texture stage 1 -> n
for ( i = m_CustomTextureStages; i < m_pHardwareConfig->GetTextureStageCount(); ++i )
{
m_ShadowState.m_TextureStage[i].m_ColorArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_ColorArg2 = D3DTA_CURRENT;
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = D3DTA_CURRENT;
m_ShadowState.m_TextureStage[i].m_ColorOp = D3DTOP_DISABLE;
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_DISABLE;
}
}
//-----------------------------------------------------------------------------
// Sets up the alpha texture stage state
//-----------------------------------------------------------------------------
void CShaderShadowDX8::ConfigureAlphaPipe( unsigned int flags )
{
// Are we using color?
bool isUsingVertexAlpha = m_HasVertexAlpha && ((flags & SHADER_DRAW_COLOR) != 0);
bool isUsingConstantAlpha = m_HasConstantAlpha;
int lastTextureStage = m_pHardwareConfig->GetTextureStageCount() - 1;
while ( lastTextureStage >= 0 )
{
if ( m_TextureStage[lastTextureStage].m_TextureAlphaEnable )
break;
--lastTextureStage;
}
for ( int i = 0; i < m_pHardwareConfig->GetTextureStageCount(); ++i )
{
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_MODULATE;
if ( m_TextureStage[i].m_TextureAlphaEnable )
{
if (i == 0)
{
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_AlphaArg2 =
isUsingConstantAlpha ? D3DTA_TFACTOR : D3DTA_DIFFUSE;
if (!isUsingConstantAlpha && !isUsingVertexAlpha)
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_SELECTARG1;
if (isUsingConstantAlpha)
isUsingConstantAlpha = false;
else if (isUsingVertexAlpha)
isUsingVertexAlpha = false;
}
else
{
// Deal with texture stage 0
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = D3DTA_CURRENT;
}
}
else
{
// Blat out unused stages
if ((i > lastTextureStage) && !isUsingVertexAlpha && !isUsingConstantAlpha)
{
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = D3DTA_CURRENT;
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_DISABLE;
continue;
}
// No texture coordinates; try to fold in vertex or constant alpha
if (i == 0)
{
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = D3DTA_DIFFUSE;
if (isUsingVertexAlpha)
{
m_ShadowState.m_TextureStage[i].m_AlphaOp =
isUsingConstantAlpha ? D3DTOP_MODULATE : D3DTOP_SELECTARG2;
}
else
{
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_SELECTARG1;
}
isUsingVertexAlpha = false;
isUsingConstantAlpha = false;
}
else
{
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_CURRENT;
if (isUsingConstantAlpha)
{
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = D3DTA_TFACTOR;
isUsingConstantAlpha = false;
}
else if (isUsingVertexAlpha)
{
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = D3DTA_DIFFUSE;
isUsingVertexAlpha = false;
}
else
{
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = D3DTA_DIFFUSE;
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_SELECTARG1;
}
}
}
}
}
//-----------------------------------------------------------------------------
// Sets up the texture stage state
//-----------------------------------------------------------------------------
void CShaderShadowDX8::ConfigureFVFVertexShader( unsigned int flags )
{
// For non-modulation, we can't really use the path below...
if (m_CustomTextureStageState)
{
ConfigureCustomFVFVertexShader( flags );
return;
}
// Deal with texture stage 0
m_ShadowState.m_TextureStage[0].m_ColorArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[0].m_ColorArg2 = D3DTA_DIFFUSE;
m_ShadowState.m_TextureStage[0].m_AlphaArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[0].m_AlphaArg2 = D3DTA_DIFFUSE;
// Are we using color?
bool isUsingVertexColor = (flags & SHADER_DRAW_COLOR) != 0;
bool isUsingConstantColor = (flags & SHADER_HAS_CONSTANT_COLOR) != 0;
// Are we using texture coordinates?
if ( IsUsingTextureCoordinates( SHADER_SAMPLER0 ) )
{
if (isUsingVertexColor)
{
m_ShadowState.m_TextureStage[0].m_ColorOp = OverbrightBlendValue(SHADER_TEXTURE_STAGE0);
m_ShadowState.m_TextureStage[0].m_AlphaOp = D3DTOP_MODULATE;
}
else
{
// Just blend in the constant color here, and don't blend it in below
m_ShadowState.m_TextureStage[0].m_ColorArg2 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[0].m_AlphaArg2 = D3DTA_TFACTOR;
isUsingConstantColor = false;
m_ShadowState.m_TextureStage[0].m_ColorOp = OverbrightBlendValue(SHADER_TEXTURE_STAGE0);
m_ShadowState.m_TextureStage[0].m_AlphaOp = D3DTOP_MODULATE;
}
}
else
{
// Are we using color?
if (isUsingVertexColor)
{
// Color, but no texture
if ( m_TextureStage[0].m_OverbrightVal < 2.0f )
{
// Use diffuse * constant color, if we have a constant color
if (isUsingConstantColor)
{
m_ShadowState.m_TextureStage[0].m_ColorArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[0].m_AlphaArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[0].m_ColorOp = OverbrightBlendValue((TextureStage_t)0);
m_ShadowState.m_TextureStage[0].m_AlphaOp = D3DTOP_MODULATE;
// This'll make sure we don't apply the constant color again below
isUsingConstantColor = false;
}
else
{
m_ShadowState.m_TextureStage[0].m_ColorOp = D3DTOP_SELECTARG2;
m_ShadowState.m_TextureStage[0].m_AlphaOp = D3DTOP_SELECTARG2;
}
}
else if (m_TextureStage[0].m_OverbrightVal < 4.0f)
{
// Produce diffuse + diffuse
m_ShadowState.m_TextureStage[0].m_ColorArg1 = D3DTA_DIFFUSE;
m_ShadowState.m_TextureStage[0].m_ColorOp = D3DTOP_ADD;
m_ShadowState.m_TextureStage[0].m_AlphaOp = D3DTOP_SELECTARG2;
}
else
{
// no 4x overbright yet!
Assert(0);
}
}
else
{
// No texture, no color
if (isUsingConstantColor)
{
m_ShadowState.m_TextureStage[0].m_ColorArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[0].m_AlphaArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[0].m_ColorOp = D3DTOP_SELECTARG1;
m_ShadowState.m_TextureStage[0].m_AlphaOp = D3DTOP_SELECTARG1;
// This'll make sure we don't apply the constant color again below
isUsingConstantColor = false;
}
else
{
// Deal with texture stage 0
m_ShadowState.m_TextureStage[0].m_ColorArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[0].m_AlphaArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[0].m_ColorOp = D3DTOP_SELECTARG1;
m_ShadowState.m_TextureStage[0].m_AlphaOp = D3DTOP_SELECTARG1;
}
}
}
// Deal with texture stage 1 -> n
int lastUsedTextureStage = 0;
for ( int i = 1; i < m_pHardwareConfig->GetTextureStageCount(); ++i )
{
m_ShadowState.m_TextureStage[i].m_ColorArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_ColorArg2 = D3DTA_CURRENT;
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = D3DTA_CURRENT;
// Not doing anything? Disable the stage
if ( !IsUsingTextureCoordinates( (Sampler_t)i ) )
{
if (m_TextureStage[i].m_OverbrightVal < 2.0f)
{
m_ShadowState.m_TextureStage[i].m_ColorOp = D3DTOP_DISABLE;
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_DISABLE;
}
else
{
// Here, we're modulating. Add in the constant color if we need to...
m_ShadowState.m_TextureStage[i].m_ColorArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[i].m_ColorOp = OverbrightBlendValue((TextureStage_t)i);
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_MODULATE;
isUsingConstantColor = false;
lastUsedTextureStage = i;
}
}
else
{
// Here, we're modulating. Keep track of the last modulation stage,
// cause the constant color modulation comes in the stage after that
lastUsedTextureStage = i;
m_ShadowState.m_TextureStage[i].m_ColorOp = OverbrightBlendValue((TextureStage_t)i);
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_MODULATE;
}
}
// massive amounts of suck: gotta overbright here if we really
// wanted to overbright stage0 but couldn't because of the add.
// This isn't totally correct, but there's no way around putting it here
// because we can't texture out of stage2 on low or medium end hardware
m_ShadowShaderState.m_ModulateConstantColor = false;
if (isUsingConstantColor)
{
++lastUsedTextureStage;
if (isUsingConstantColor &&
(lastUsedTextureStage >= m_pHardwareConfig->GetTextureStageCount()))
{
// This is the case where we'd want to modulate in a particular texture
// stage, but we can't because there aren't enough. In this case, we're gonna
// need to do the modulation in the per-vertex color.
m_ShadowShaderState.m_ModulateConstantColor = true;
}
else
{
AssertOnce (lastUsedTextureStage < 2);
// Here, we've got enough texture stages to do the modulation
m_ShadowState.m_TextureStage[lastUsedTextureStage].m_ColorArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[lastUsedTextureStage].m_ColorArg2 = D3DTA_CURRENT;
m_ShadowState.m_TextureStage[lastUsedTextureStage].m_AlphaArg1 = D3DTA_TFACTOR;
m_ShadowState.m_TextureStage[lastUsedTextureStage].m_AlphaArg2 = D3DTA_CURRENT;
m_ShadowState.m_TextureStage[lastUsedTextureStage].m_ColorOp = D3DTOP_MODULATE;
m_ShadowState.m_TextureStage[lastUsedTextureStage].m_AlphaOp = D3DTOP_MODULATE;
}
}
// Overwrite the alpha stuff if we asked to independently control it
if (m_AlphaPipe)
{
ConfigureAlphaPipe( flags );
}
}
//-----------------------------------------------------------------------------
// Makes sure we report if we're getting garbage.
//-----------------------------------------------------------------------------
void CShaderShadowDX8::DrawFlags( unsigned int flags )
{
m_DrawFlags = flags;
m_ShadowState.m_UsingFixedFunction = true;
}
//-----------------------------------------------------------------------------
// Compute texture coordinates
//-----------------------------------------------------------------------------
void CShaderShadowDX8::ConfigureTextureCoordinates( unsigned int flags )
{
// default...
for (int i = 0; i < m_pHardwareConfig->GetTextureStageCount(); ++i)
{
TextureCoordinate( (TextureStage_t)i, i );
}
if (flags & SHADER_DRAW_TEXCOORD0)
{
Assert( (flags & SHADER_DRAW_LIGHTMAP_TEXCOORD0) == 0 );
TextureCoordinate( SHADER_TEXTURE_STAGE0, 0 );
}
else if (flags & SHADER_DRAW_LIGHTMAP_TEXCOORD0)
{
TextureCoordinate( SHADER_TEXTURE_STAGE0, 1 );
}
else if (flags & SHADER_DRAW_SECONDARY_TEXCOORD0 )
{
TextureCoordinate( SHADER_TEXTURE_STAGE0, 2 );
}
if (flags & SHADER_DRAW_TEXCOORD1)
{
Assert( (flags & SHADER_DRAW_LIGHTMAP_TEXCOORD1) == 0 );
TextureCoordinate( SHADER_TEXTURE_STAGE1, 0 );
}
else if (flags & SHADER_DRAW_LIGHTMAP_TEXCOORD1)
{
TextureCoordinate( SHADER_TEXTURE_STAGE1, 1 );
}
else if (flags & SHADER_DRAW_SECONDARY_TEXCOORD1 )
{
TextureCoordinate( SHADER_TEXTURE_STAGE1, 2 );
}
}
//-----------------------------------------------------------------------------
// Converts draw flags into vertex format
//-----------------------------------------------------------------------------
VertexFormat_t CShaderShadowDX8::FlagsToVertexFormat( int flags ) const
{
// Flags -1 occurs when there's an error condition;
// we'll just give em the max space and let them fill it in.
int formatFlags = 0;
int texCoordSize[VERTEX_MAX_TEXTURE_COORDINATES] = { 0, 0, 0, 0, 0, 0, 0, 0 };
int userDataSize = 0;
int numBones = 0;
// Flags -1 occurs when there's an error condition;
// we'll just give em the max space and let them fill it in.
if (flags == -1)
{
formatFlags = VERTEX_POSITION | VERTEX_NORMAL | VERTEX_COLOR |
VERTEX_TANGENT_S | VERTEX_TANGENT_T;
texCoordSize[0] = texCoordSize[1] = texCoordSize[2] = 2;
}
else
{
if (flags & SHADER_DRAW_POSITION)
formatFlags |= VERTEX_POSITION;
if (flags & SHADER_DRAW_NORMAL)
formatFlags |= VERTEX_NORMAL;
if (flags & SHADER_DRAW_COLOR)
formatFlags |= VERTEX_COLOR;
if( flags & SHADER_DRAW_SPECULAR )
formatFlags |= VERTEX_SPECULAR;
if (flags & SHADER_TEXCOORD_MASK)
{
// normal texture coords into texture 0
texCoordSize[0] = 2;
}
if (flags & SHADER_LIGHTMAP_TEXCOORD_MASK)
{
// lightmaps go into texcoord 1
texCoordSize[1] = 2;
}
if (flags & SHADER_SECONDARY_TEXCOORD_MASK)
{
// any texgen, or secondary texture coordinate is put into texcoord 2
texCoordSize[2] = 2;
}
}
// Hardware skinning... always store space for up to 3 bones
// and always assume index blend enabled if available
if (m_ShadowState.m_VertexBlendEnable)
{
if (HardwareConfig()->MaxBlendMatrixIndices() > 0)
formatFlags |= VERTEX_BONE_INDEX;
if (HardwareConfig()->MaxBlendMatrices() > 2)
numBones = 2; // the third bone weight is implied
else
numBones = HardwareConfig()->MaxBlendMatrices() - 1;
}
return MeshMgr()->ComputeVertexFormat( formatFlags, VERTEX_MAX_TEXTURE_COORDINATES,
texCoordSize, numBones, userDataSize );
}
//-----------------------------------------------------------------------------
// Computes shadow state based on bunches of other parameters
//-----------------------------------------------------------------------------
void CShaderShadowDX8::ComputeAggregateShadowState( )
{
unsigned int flags = 0;
// Initialize the texture stage usage; this may get changed later
for (int i = 0; i < m_pHardwareConfig->GetSamplerCount(); ++i)
{
m_ShadowState.m_SamplerState[i].m_TextureEnable =
IsUsingTextureCoordinates( (Sampler_t)i );
// Deal with the alpha pipe
if ( m_ShadowState.m_UsingFixedFunction && m_AlphaPipe )
{
if ( m_TextureStage[i].m_TextureAlphaEnable )
{
m_ShadowState.m_SamplerState[i].m_TextureEnable = true;
}
}
}
// Always use the same alpha src + dest if it's disabled
// NOTE: This is essential for stateblocks to work
if ( m_ShadowState.m_AlphaBlendEnable )
{
m_ShadowState.m_SrcBlend = m_SrcBlend;
m_ShadowState.m_DestBlend = m_DestBlend;
m_ShadowState.m_BlendOp = m_BlendOp;
}
else
{
m_ShadowState.m_SrcBlend = D3DBLEND_ONE;
m_ShadowState.m_DestBlend = D3DBLEND_ZERO;
m_ShadowState.m_BlendOp = D3DBLENDOP_ADD;
}
// GR
if (m_ShadowState.m_SeparateAlphaBlendEnable)
{
m_ShadowState.m_SrcBlendAlpha = m_SrcBlendAlpha;
m_ShadowState.m_DestBlendAlpha = m_DestBlendAlpha;
m_ShadowState.m_BlendOpAlpha = m_BlendOpAlpha;
}
else
{
m_ShadowState.m_SrcBlendAlpha = D3DBLEND_ONE;
m_ShadowState.m_DestBlendAlpha = D3DBLEND_ZERO;
m_ShadowState.m_BlendOpAlpha = D3DBLENDOP_ADD;
}
// Use the same func if it's disabled
if (m_ShadowState.m_AlphaTestEnable)
{
// If alpha test is enabled, just use the values set
m_ShadowState.m_AlphaFunc = m_AlphaFunc;
m_ShadowState.m_AlphaRef = m_AlphaRef;
}
else
{
// A default value
m_ShadowState.m_AlphaFunc = D3DCMP_GREATEREQUAL;
m_ShadowState.m_AlphaRef = 0;
// If not alpha testing and doing a standard alpha blend, force on alpha testing
if ( m_ShadowState.m_AlphaBlendEnable )
{
if ( ( m_ShadowState.m_SrcBlend == D3DBLEND_SRCALPHA ) && ( m_ShadowState.m_DestBlend == D3DBLEND_INVSRCALPHA ) )
{
m_ShadowState.m_AlphaFunc = D3DCMP_GREATEREQUAL;
m_ShadowState.m_AlphaRef = 1;
}
}
}
if ( m_ShadowState.m_UsingFixedFunction )
{
flags = m_DrawFlags;
// We need to take this bad boy into account
if (HasConstantColor())
flags |= SHADER_HAS_CONSTANT_COLOR;
// We need to take lighting into account..
if ( m_ShadowState.m_Lighting )
flags |= SHADER_DRAW_NORMAL;
if (m_ShadowState.m_Lighting)
flags |= SHADER_DRAW_COLOR;
// Look for inconsistency in the shadow state (can't have texgen &
// SHADER_DRAW_TEXCOORD or SHADER_DRAW_SECONDARY_TEXCOORD0 on the same stage)
if (flags & (SHADER_DRAW_TEXCOORD0 | SHADER_DRAW_SECONDARY_TEXCOORD0))
{
Assert( (m_ShadowState.m_TextureStage[0].m_TexCoordIndex & 0xFFFF0000) == 0 );
}
if (flags & (SHADER_DRAW_TEXCOORD1 | SHADER_DRAW_SECONDARY_TEXCOORD1))
{
Assert( (m_ShadowState.m_TextureStage[1].m_TexCoordIndex & 0xFFFF0000) == 0 );
}
if (flags & (SHADER_DRAW_TEXCOORD2 | SHADER_DRAW_SECONDARY_TEXCOORD2))
{
Assert( (m_ShadowState.m_TextureStage[2].m_TexCoordIndex & 0xFFFF0000) == 0 );
}
if (flags & (SHADER_DRAW_TEXCOORD3 | SHADER_DRAW_SECONDARY_TEXCOORD3))
{
Assert( (m_ShadowState.m_TextureStage[3].m_TexCoordIndex & 0xFFFF0000) == 0 );
}
// Vertex usage has already been set for pixel + vertex shaders
m_ShadowShaderState.m_VertexUsage = FlagsToVertexFormat( flags );
// Configure the texture stages
ConfigureFVFVertexShader(flags);
#if 0
//#ifdef _DEBUG
// NOTE: This must be true for stateblocks to work
for ( i = 0; i < m_pHardwareConfig->GetTextureStageCount(); ++i )
{
if ( m_ShadowState.m_TextureStage[i].m_ColorOp == D3DTOP_DISABLE )
{
Assert( m_ShadowState.m_TextureStage[i].m_ColorArg1 == D3DTA_TEXTURE );
Assert( m_ShadowState.m_TextureStage[i].m_ColorArg2 == ((i == 0) ? D3DTA_DIFFUSE : D3DTA_CURRENT) );
}
if ( m_ShadowState.m_TextureStage[i].m_AlphaOp == D3DTOP_DISABLE )
{
Assert( m_ShadowState.m_TextureStage[i].m_AlphaArg1 == D3DTA_TEXTURE );
Assert( m_ShadowState.m_TextureStage[i].m_AlphaArg2 == ((i == 0) ? D3DTA_DIFFUSE : D3DTA_CURRENT) );
}
}
#endif
}
else
{
// Pixel shaders, disable everything so as to prevent unnecessary state changes....
for ( int i = 0; i < m_pHardwareConfig->GetTextureStageCount(); ++i )
{
m_ShadowState.m_TextureStage[i].m_ColorArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_ColorArg2 = (i == 0) ? D3DTA_DIFFUSE : D3DTA_CURRENT;
m_ShadowState.m_TextureStage[i].m_AlphaArg1 = D3DTA_TEXTURE;
m_ShadowState.m_TextureStage[i].m_AlphaArg2 = (i == 0) ? D3DTA_DIFFUSE : D3DTA_CURRENT;
m_ShadowState.m_TextureStage[i].m_ColorOp = D3DTOP_DISABLE;
m_ShadowState.m_TextureStage[i].m_AlphaOp = D3DTOP_DISABLE;
m_ShadowState.m_TextureStage[i].m_TexCoordIndex = i;
}
m_ShadowState.m_Lighting = false;
m_ShadowState.m_SpecularEnable = false;
m_ShadowState.m_VertexBlendEnable = false;
m_ShadowShaderState.m_ModulateConstantColor = false;
}
// Compute texture coordinates
ConfigureTextureCoordinates(flags);
// Alpha to coverage
if ( m_ShadowState.m_EnableAlphaToCoverage )
{
// Only allow this to be enabled if blending is disabled and testing is enabled
if ( ( m_ShadowState.m_AlphaBlendEnable == true ) || ( m_ShadowState.m_AlphaTestEnable == false ) )
{
m_ShadowState.m_EnableAlphaToCoverage = false;
}
}
}
void CShaderShadowDX8::FogMode( ShaderFogMode_t fogMode )
{
Assert( fogMode >= 0 && fogMode < SHADER_FOGMODE_NUMFOGMODES );
m_ShadowState.m_FogMode = fogMode;
}
void CShaderShadowDX8::DisableFogGammaCorrection( bool bDisable )
{
m_ShadowState.m_bDisableFogGammaCorrection = bDisable;
}
void CShaderShadowDX8::SetDiffuseMaterialSource( ShaderMaterialSource_t materialSource )
{
COMPILE_TIME_ASSERT( ( int )D3DMCS_MATERIAL == ( int )SHADER_MATERIALSOURCE_MATERIAL );
COMPILE_TIME_ASSERT( ( int )D3DMCS_COLOR1 == ( int )SHADER_MATERIALSOURCE_COLOR1 );
COMPILE_TIME_ASSERT( ( int )D3DMCS_COLOR2 == ( int )SHADER_MATERIALSOURCE_COLOR2 );
Assert( materialSource == SHADER_MATERIALSOURCE_MATERIAL ||
materialSource == SHADER_MATERIALSOURCE_COLOR1 ||
materialSource == SHADER_MATERIALSOURCE_COLOR2 );
m_ShadowState.m_DiffuseMaterialSource = ( D3DMATERIALCOLORSOURCE )materialSource;
}