1827 lines
55 KiB
C++
1827 lines
55 KiB
C++
//========= 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;
|
|
}
|