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.
362 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 8fbc002a37
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8fbc002a37'
${ noResults }
source-engine/materialsystem/shaderapidx9/TransitionTable.cpp

1924 lines
65 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
#define DISABLE_PROTECTED_THINGS
#include "togl/rendermechanism.h"
#include "TransitionTable.h"
#include "recording.h"
#include "shaderapidx8.h"
#include "shaderapi/ishaderutil.h"
#include "tier1/convar.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "vertexshaderdx8.h"
#include "tier0/vprof.h"
#include "shaderdevicedx8.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
enum
{
TEXTURE_STAGE_BIT_COUNT = 4,
TEXTURE_STAGE_MAX_STAGE = 1 << TEXTURE_STAGE_BIT_COUNT,
TEXTURE_STAGE_MASK = TEXTURE_STAGE_MAX_STAGE - 1,
TEXTURE_OP_BIT_COUNT = 7 - TEXTURE_STAGE_BIT_COUNT,
TEXTURE_OP_SHIFT = TEXTURE_STAGE_BIT_COUNT,
TEXTURE_OP_MASK = ((1 << TEXTURE_OP_BIT_COUNT) - 1) << TEXTURE_OP_SHIFT,
};
//-----------------------------------------------------------------------------
// Texture op compressing/uncompressing
//-----------------------------------------------------------------------------
inline unsigned char TextureOp( TextureStateFunc_t func, int stage )
{
// This fails if we've added too many texture stages states to fit in a byte.
COMPILE_TIME_ASSERT( TEXTURE_STATE_COUNT < (1 << TEXTURE_OP_BIT_COUNT) );
Assert( stage < TEXTURE_STAGE_MAX_STAGE );
return ((func << TEXTURE_OP_SHIFT) & TEXTURE_OP_MASK) | (stage & TEXTURE_STAGE_MASK);
}
inline void GetTextureOp( unsigned char nBits, TextureStateFunc_t *pFunc, int *pStage )
{
*pStage = (nBits & TEXTURE_STAGE_MASK);
*pFunc = (TextureStateFunc_t)((nBits & TEXTURE_OP_MASK) >> TEXTURE_OP_SHIFT);
}
//-----------------------------------------------------------------------------
// Stats
//-----------------------------------------------------------------------------
static int s_pRenderTransitions[RENDER_STATE_COUNT];
static int s_pTextureTransitions[TEXTURE_STATE_COUNT][TEXTURE_STAGE_MAX_STAGE];
//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
CTransitionTable *g_pTransitionTable = NULL;
#ifdef DEBUG_BOARD_STATE
inline ShadowState_t& BoardState()
{
return g_pTransitionTable->BoardState();
}
#endif
inline CTransitionTable::CurrentState_t& CurrentState()
{
return g_pTransitionTable->CurrentState();
}
//-----------------------------------------------------------------------------
// Less functions
//-----------------------------------------------------------------------------
bool CTransitionTable::ShadowStateDictLessFunc::Less( const CTransitionTable::ShadowStateDictEntry_t &src1, const CTransitionTable::ShadowStateDictEntry_t &src2, void *pCtx )
{
return src1.m_nChecksum < src2.m_nChecksum;
}
bool CTransitionTable::SnapshotDictLessFunc::Less( const CTransitionTable::SnapshotDictEntry_t &src1, const CTransitionTable::SnapshotDictEntry_t &src2, void *pCtx )
{
return src1.m_nChecksum < src2.m_nChecksum;
}
bool CTransitionTable::UniqueSnapshotLessFunc::Less( const CTransitionTable::TransitionList_t &src1, const CTransitionTable::TransitionList_t &src2, void *pCtx )
{
return src1.m_NumOperations > src2.m_NumOperations;
}
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CTransitionTable::CTransitionTable() : m_DefaultStateSnapshot(-1),
m_CurrentShadowId(-1), m_CurrentSnapshotId(-1), m_TransitionOps( 0, 8192 ), m_ShadowStateList( 0, 256 ),
m_TransitionTable( 0, 256 ), m_SnapshotList( 0, 256 ),
m_ShadowStateDict(0, 256 ),
m_SnapshotDict( 0, 256 ),
m_UniqueTransitions( 0, 4096 )
{
Assert( !g_pTransitionTable );
g_pTransitionTable = this;
#ifdef DEBUG_BOARD_STATE
memset( &m_BoardState, 0, sizeof( m_BoardState ) );
memset( &m_BoardShaderState, 0, sizeof( m_BoardShaderState ) );
#endif
}
CTransitionTable::~CTransitionTable()
{
Assert( g_pTransitionTable == this );
g_pTransitionTable = NULL;
}
//-----------------------------------------------------------------------------
// Initialization, shutdown
//-----------------------------------------------------------------------------
bool CTransitionTable::Init( )
{
return true;
}
void CTransitionTable::Shutdown( )
{
Reset();
}
//-----------------------------------------------------------------------------
// Creates a shadow, adding an entry into the shadow list and transition table
//-----------------------------------------------------------------------------
StateSnapshot_t CTransitionTable::CreateStateSnapshot( ShadowStateId_t shadowStateId, const ShadowShaderState_t& currentShaderState )
{
StateSnapshot_t snapshotId = m_SnapshotList.AddToTail();
// Copy our snapshot into the list
SnapshotShaderState_t &shaderState = m_SnapshotList[snapshotId];
shaderState.m_ShadowStateId = shadowStateId;
memcpy( &shaderState.m_ShaderState, &currentShaderState, sizeof(ShadowShaderState_t) );
memset( shaderState.m_ShaderState.m_nReserved, 0, sizeof( shaderState.m_ShaderState.m_nReserved ) );
shaderState.m_nReserved = 0; // needed to get a good CRC
shaderState.m_nReserved2 = 0;
// Insert entry into the lookup table
SnapshotDictEntry_t insert;
CRC32_Init( &insert.m_nChecksum );
CRC32_ProcessBuffer( &insert.m_nChecksum, &shaderState, sizeof(SnapshotShaderState_t) );
CRC32_Final( &insert.m_nChecksum );
insert.m_nSnapshot = snapshotId;
m_SnapshotDict.Insert( insert );
return snapshotId;
}
//-----------------------------------------------------------------------------
// Creates a shadow, adding an entry into the shadow list and transition table
//-----------------------------------------------------------------------------
CTransitionTable::ShadowStateId_t CTransitionTable::CreateShadowState( const ShadowState_t &currentState )
{
int newShaderState = m_ShadowStateList.AddToTail();
// Copy our snapshot into the list
memcpy( &m_ShadowStateList[newShaderState], &currentState, sizeof(ShadowState_t) );
// all existing states must transition to the new state
int i;
for ( i = 0; i < newShaderState; ++i )
{
// Add a new transition to all existing states
int newElem = m_TransitionTable[i].AddToTail();
m_TransitionTable[i][newElem].m_FirstOperation = INVALID_TRANSITION_OP;
m_TransitionTable[i][newElem].m_NumOperations = 0;
}
// Add a new vector for this transition
int newTransitionElem = m_TransitionTable.AddToTail();
m_TransitionTable[newTransitionElem].EnsureCapacity( 32 );
Assert( newShaderState == newTransitionElem );
for ( i = 0; i <= newShaderState; ++i )
{
// Add a new transition from all existing states
int newElem = m_TransitionTable[newShaderState].AddToTail();
m_TransitionTable[newShaderState][newElem].m_FirstOperation = INVALID_TRANSITION_OP;
m_TransitionTable[newShaderState][newElem].m_NumOperations = 0;
}
// Insert entry into the lookup table
ShadowStateDictEntry_t insert;
CRC32_Init( &insert.m_nChecksum );
CRC32_ProcessBuffer( &insert.m_nChecksum, &m_ShadowStateList[newShaderState], sizeof(ShadowState_t) );
CRC32_Final( &insert.m_nChecksum );
insert.m_nShadowStateId = newShaderState;
m_ShadowStateDict.Insert( insert );
return newShaderState;
}
//-----------------------------------------------------------------------------
// Finds a snapshot, if it exists. Or creates a new one if it doesn't.
//-----------------------------------------------------------------------------
CTransitionTable::ShadowStateId_t CTransitionTable::FindShadowState( const ShadowState_t& currentState ) const
{
ShadowStateDictEntry_t find;
CRC32_Init( &find.m_nChecksum );
CRC32_ProcessBuffer( &find.m_nChecksum, &currentState, sizeof(ShadowState_t) );
CRC32_Final( &find.m_nChecksum );
int nDictCount = m_ShadowStateDict.Count();
int i = m_ShadowStateDict.FindLessOrEqual( find );
if ( i < 0 )
return (ShadowStateId_t)-1;
for ( ; i < nDictCount; ++i )
{
const ShadowStateDictEntry_t &entry = m_ShadowStateDict[i];
// Didn't find a match
if ( entry.m_nChecksum > find.m_nChecksum )
break;
if ( entry.m_nChecksum != find.m_nChecksum )
continue;
ShadowStateId_t nShadowState = entry.m_nShadowStateId;
if (!memcmp(&m_ShadowStateList[nShadowState], &currentState, sizeof(ShadowState_t) ))
return nShadowState;
}
// Need to create a new one
return (ShadowStateId_t)-1;
}
//-----------------------------------------------------------------------------
// Finds a snapshot, if it exists. Or creates a new one if it doesn't.
//-----------------------------------------------------------------------------
StateSnapshot_t CTransitionTable::FindStateSnapshot( ShadowStateId_t id, const ShadowShaderState_t& currentState ) const
{
SnapshotShaderState_t temp;
temp.m_ShaderState = currentState;
temp.m_ShadowStateId = id;
memset( temp.m_ShaderState.m_nReserved, 0, sizeof( temp.m_ShaderState.m_nReserved ) );
temp.m_nReserved = 0; // needed to get a good CRC
temp.m_nReserved2 = 0;
SnapshotDictEntry_t find;
CRC32_Init( &find.m_nChecksum );
CRC32_ProcessBuffer( &find.m_nChecksum, &temp, sizeof(temp) );
CRC32_Final( &find.m_nChecksum );
int nDictCount = m_SnapshotDict.Count();
int i = m_SnapshotDict.FindLessOrEqual( find );
if ( i < 0 )
return (StateSnapshot_t)-1;
for ( ; i < nDictCount; ++i )
{
// Didn't find a match
if ( m_SnapshotDict[i].m_nChecksum > find.m_nChecksum )
break;
if ( m_SnapshotDict[i].m_nChecksum != find.m_nChecksum )
continue;
StateSnapshot_t nShapshot = m_SnapshotDict[i].m_nSnapshot;
if ( (id == m_SnapshotList[nShapshot].m_ShadowStateId) &&
!memcmp(&m_SnapshotList[nShapshot].m_ShaderState, &currentState, sizeof(ShadowShaderState_t)) )
{
return nShapshot;
}
}
// Need to create a new one
return (StateSnapshot_t)-1;
}
//-----------------------------------------------------------------------------
// Used to clear the transition table when we know it's become invalid.
//-----------------------------------------------------------------------------
void CTransitionTable::Reset()
{
m_ShadowStateList.RemoveAll();
m_SnapshotList.RemoveAll();
m_TransitionTable.RemoveAll();
m_TransitionOps.RemoveAll();
m_ShadowStateDict.RemoveAll();
m_SnapshotDict.RemoveAll();
m_UniqueTransitions.RemoveAll();
m_CurrentShadowId = -1;
m_CurrentSnapshotId = -1;
m_DefaultStateSnapshot = -1;
}
//-----------------------------------------------------------------------------
// Sets the texture stage state
//-----------------------------------------------------------------------------
#ifdef _WIN32
#pragma warning( disable : 4189 )
#endif
static inline void SetTextureStageState( int stage, D3DTEXTURESTAGESTATETYPE state, DWORD val )
{
#if !defined( _X360 )
Assert( !g_pShaderDeviceDx8->IsDeactivated() );
Dx9Device()->SetTextureStageState( stage, state, val );
#endif
}
//Moved to a #define so every instance of this skips unsupported render states at compile time
#define SetSamplerState( _stage, _state, _val ) \
{ \
if ( (_state != D3DSAMP_NOTSUPPORTED) ) \
{ \
Assert( !g_pShaderDeviceDx8->IsDeactivated() ); \
Dx9Device()->SetSamplerState( _stage, _state, _val ); \
} \
}
//Moved to a #define so every instance of this skips unsupported render states at compile time
#define SetRenderState( _state, _val ) \
{ \
if ( _state != D3DRS_NOTSUPPORTED ) \
{ \
Assert( !g_pShaderDeviceDx8->IsDeactivated() ); \
Dx9Device()->SetRenderState( _state, _val ); \
} \
}
#ifdef DX_TO_GL_ABSTRACTION
#define SetRenderStateConstMacro( state, val ) { if ( state != D3DRS_NOTSUPPORTED ) Dx9Device()->SetRenderStateConstInline( state, val ); }
#else
#define SetRenderStateConstMacro( state, val ) SetRenderState( state, val )
#endif
#ifdef _WIN32
#pragma warning( default : 4189 )
#endif
//-----------------------------------------------------------------------------
// Methods that actually apply the state
//-----------------------------------------------------------------------------
#ifdef DEBUG_BOARD_STATE
static bool g_SpewTransitions = false;
#define UPDATE_BOARD_RENDER_STATE( _d3dState, _state ) \
{ \
BoardState().m_ ## _state = shaderState.m_ ## _state; \
if (g_SpewTransitions) \
{ \
char buf[128]; \
sprintf( buf, "Apply %s : %d\n", #_d3dState, shaderState.m_ ## _state ); \
Plat_DebugString(buf); \
} \
}
#define UPDATE_BOARD_TEXTURE_STAGE_STATE( _d3dState, _state, _stage ) \
{ \
BoardState().m_TextureStage[_stage].m_ ## _state = shaderState.m_TextureStage[_stage].m_ ## _state; \
if (g_SpewTransitions) \
{ \
char buf[128]; \
sprintf( buf, "Apply Tex %s (%d): %d\n", #_d3dState, _stage, shaderState.m_TextureStage[_stage].m_ ## _state ); \
Plat_DebugString(buf); \
} \
}
#define UPDATE_BOARD_SAMPLER_STATE( _d3dState, _state, _stage ) \
{ \
BoardState().m_SamplerState[_stage].m_ ## _state = shaderState.m_SamplerState[_stage].m_ ## _state; \
if (g_SpewTransitions) \
{ \
char buf[128]; \
sprintf( buf, "Apply SamplerSate %s (%d): %d\n", #_d3dState, stage, shaderState.m_SamplerState[_stage].m_ ## _state ); \
Plat_DebugString(buf); \
} \
}
#else
#define UPDATE_BOARD_RENDER_STATE( _d3dState, _state ) {}
#define UPDATE_BOARD_TEXTURE_STAGE_STATE( _d3dState, _state, _stage ) {}
#define UPDATE_BOARD_SAMPLER_STATE( _d3dState, _state, _stage ) {}
#endif
#define APPLY_RENDER_STATE_FUNC( _d3dState, _state ) \
void Apply ## _state( const ShadowState_t& shaderState, int arg ) \
{ \
SetRenderState( _d3dState, shaderState.m_ ## _state ); \
UPDATE_BOARD_RENDER_STATE( _d3dState, _state ); \
}
#define APPLY_TEXTURE_STAGE_STATE_FUNC( _d3dState, _state ) \
void Apply ## _state( const ShadowState_t& shaderState, int stage ) \
{ \
SetTextureStageState( stage, _d3dState, shaderState.m_TextureStage[stage].m_ ## _state ); \
UPDATE_BOARD_TEXTURE_STAGE_STATE( _d3dState, _state, stage ); \
}
#define APPLY_SAMPLER_STATE_FUNC( _d3dState, _state ) \
void Apply ## _state( const ShadowState_t& shaderState, int stage ) \
{ \
SetSamplerState( stage, _d3dState, shaderState.m_SamplerState[stage].m_ ## _state ); \
UPDATE_BOARD_SAMPLER_STATE( _d3dState, _state, stage ); \
}
// Special overridden sampler state to turn on Fetch4 on ATI hardware (and 360?)
void ApplyFetch4Enable( const ShadowState_t& shaderState, int stage )
{
if ( ShaderAPI()->SupportsFetch4() )
{
SetSamplerState( stage, ATISAMP_FETCH4, shaderState.m_SamplerState[stage].m_Fetch4Enable ? ATI_FETCH4_ENABLE : ATI_FETCH4_DISABLE );
}
UPDATE_BOARD_SAMPLER_STATE( ATISAMP_FETCH4, Fetch4Enable, stage );
}
#ifdef DX_TO_GL_ABSTRACTION
void ApplyShadowFilterEnable( const ShadowState_t& shaderState, int stage )
{
SetSamplerState( stage, D3DSAMP_SHADOWFILTER, shaderState.m_SamplerState[stage].m_ShadowFilterEnable );
UPDATE_BOARD_SAMPLER_STATE( D3DSAMP_SHADOWFILTER, ShadowFilterEnable, stage );
}
#endif
//APPLY_RENDER_STATE_FUNC( D3DRS_ZWRITEENABLE, ZWriteEnable )
//APPLY_RENDER_STATE_FUNC( D3DRS_COLORWRITEENABLE, ColorWriteEnable )
APPLY_RENDER_STATE_FUNC( D3DRS_FILLMODE, FillMode )
APPLY_RENDER_STATE_FUNC( D3DRS_LIGHTING, Lighting )
APPLY_RENDER_STATE_FUNC( D3DRS_SPECULARENABLE, SpecularEnable )
APPLY_RENDER_STATE_FUNC( D3DRS_DIFFUSEMATERIALSOURCE, DiffuseMaterialSource )
APPLY_TEXTURE_STAGE_STATE_FUNC( D3DTSS_TEXCOORDINDEX, TexCoordIndex )
void ApplyZWriteEnable( const ShadowState_t& shaderState, int arg )
{
SetRenderStateConstMacro( D3DRS_ZWRITEENABLE, shaderState.m_ZWriteEnable );
#if defined( _X360 )
//SetRenderStateConstMacro( D3DRS_HIZWRITEENABLE, shaderState.m_ZWriteEnable ? D3DHIZ_AUTOMATIC : D3DHIZ_DISABLE );
#endif
UPDATE_BOARD_RENDER_STATE( D3DRS_ZWRITEENABLE, ZWriteEnable );
}
void ApplyColorWriteEnable( const ShadowState_t& shaderState, int arg )
{
SetRenderState( D3DRS_COLORWRITEENABLE, shaderState.m_ColorWriteEnable );
g_pTransitionTable->CurrentState().m_ColorWriteEnable = shaderState.m_ColorWriteEnable;
UPDATE_BOARD_RENDER_STATE( D3DRS_COLORWRITEENABLE, ColorWriteEnable );
}
void ApplySRGBReadEnable( const ShadowState_t& shaderState, int stage )
{
# if ( !defined( _X360 ) )
{
SetSamplerState( stage, D3DSAMP_SRGBTEXTURE, shaderState.m_SamplerState[stage].m_SRGBReadEnable );
}
# else
{
ShaderAPI()->ApplySRGBReadState( stage, shaderState.m_SamplerState[stage].m_SRGBReadEnable );
}
# endif
UPDATE_BOARD_SAMPLER_STATE( D3DSAMP_SRGBTEXTURE, SRGBReadEnable, stage );
}
void ApplySRGBWriteEnable( const ShadowState_t& shadowState, int stageUnused )
{
g_pTransitionTable->ApplySRGBWriteEnable( shadowState );
}
void CTransitionTable::ApplySRGBWriteEnable( const ShadowState_t& shaderState )
{
// ApplySRGBWriteEnable set to true means that the shader is writing linear values.
if ( CurrentState().m_bLinearColorSpaceFrameBufferEnable )
{
// The shader had better be writing linear values since we can't convert to gamma here.
// Can't leave this assert here since there are cases where the shader is doing the right thing.
// This is good to test occasionally to make sure that the shaders are doing the right thing.
// Assert( shaderState.m_SRGBWriteEnable );
// render target is linear
SetRenderStateConstMacro( D3DRS_SRGBWRITEENABLE, 0 );
ShaderAPI()->EnabledSRGBWrite( false );
// fog isn't fixed-function with linear frame buffers, so don't bother with that here.
}
else
{
// render target is gamma
// SRGBWrite enable can affect the space in which fog color is defined
if ( HardwareConfig()->NeedsShaderSRGBConversion() )
{
if ( HardwareConfig()->SupportsPixelShaders_2_b() ) //in 2b supported devices, we never actually enable SRGB writes, but instead handle the conversion in the pixel shader. But we want all other code to be unaware.
{
SetRenderStateConstMacro( D3DRS_SRGBWRITEENABLE, 0 );
}
else
{
SetRenderStateConstMacro( D3DRS_SRGBWRITEENABLE, shaderState.m_SRGBWriteEnable );
}
}
else
{
SetRenderStateConstMacro( D3DRS_SRGBWRITEENABLE, shaderState.m_SRGBWriteEnable );
}
ShaderAPI()->EnabledSRGBWrite( shaderState.m_SRGBWriteEnable );
if ( HardwareConfig()->SpecifiesFogColorInLinearSpace() )
{
ShaderAPI()->ApplyFogMode( shaderState.m_FogMode, shaderState.m_SRGBWriteEnable, shaderState.m_bDisableFogGammaCorrection );
}
}
#ifdef _DEBUG
BoardState().m_SRGBWriteEnable = shaderState.m_SRGBWriteEnable;
if (g_SpewTransitions)
{
char buf[128];
sprintf( buf, "Apply %s : %d\n", "D3DRS_SRGBWRITEENABLE", shaderState.m_SRGBWriteEnable );
Plat_DebugString(buf);
}
#endif
}
void ApplyDisableFogGammaCorrection( const ShadowState_t& shadowState, int stageUnused )
{
ShaderAPI()->ApplyFogMode( shadowState.m_FogMode, shadowState.m_SRGBWriteEnable, shadowState.m_bDisableFogGammaCorrection );
#ifdef DEBUG_BOARD_STATE
g_pTransitionTable->BoardState().m_bDisableFogGammaCorrection = shadowState.m_bDisableFogGammaCorrection;
#endif
}
void ApplyDepthTest( const ShadowState_t& state, int stage )
{
g_pTransitionTable->ApplyDepthTest( state );
}
void CTransitionTable::SetZEnable( D3DZBUFFERTYPE nEnable )
{
if (m_CurrentState.m_ZEnable != nEnable )
{
SetRenderStateConstMacro( D3DRS_ZENABLE, nEnable );
#if defined( _X360 )
//SetRenderState( D3DRS_HIZENABLE, nEnable ? D3DHIZ_AUTOMATIC : D3DHIZ_DISABLE );
#endif
m_CurrentState.m_ZEnable = nEnable;
}
}
void CTransitionTable::SetZFunc( D3DCMPFUNC nCmpFunc )
{
if (m_CurrentState.m_ZFunc != nCmpFunc )
{
SetRenderStateConstMacro( D3DRS_ZFUNC, nCmpFunc );
m_CurrentState.m_ZFunc = nCmpFunc;
}
}
void CTransitionTable::ApplyDepthTest( const ShadowState_t& state )
{
SetZEnable( state.m_ZEnable );
if (state.m_ZEnable != D3DZB_FALSE)
{
SetZFunc( state.m_ZFunc );
}
if (m_CurrentState.m_ZBias != state.m_ZBias)
{
ShaderAPI()->ApplyZBias( state );
m_CurrentState.m_ZBias = (PolygonOffsetMode_t) state.m_ZBias; // Cast two bits from m_ZBias
}
#ifdef DEBUG_BOARD_STATE
// This isn't quite true, but it's necessary for other error checking to work
BoardState().m_ZEnable = state.m_ZEnable;
BoardState().m_ZFunc = state.m_ZFunc;
BoardState().m_ZBias = state.m_ZBias;
#endif
}
void ApplyAlphaTest( const ShadowState_t& state, int stage )
{
g_pTransitionTable->ApplyAlphaTest( state );
}
void CTransitionTable::ApplyAlphaTest( const ShadowState_t& state )
{
if (m_CurrentState.m_AlphaTestEnable != state.m_AlphaTestEnable)
{
SetRenderStateConstMacro( D3DRS_ALPHATESTENABLE, state.m_AlphaTestEnable );
m_CurrentState.m_AlphaTestEnable = state.m_AlphaTestEnable;
}
if (state.m_AlphaTestEnable)
{
// Set the blend state here...
if (m_CurrentState.m_AlphaFunc != state.m_AlphaFunc)
{
SetRenderStateConstMacro( D3DRS_ALPHAFUNC, state.m_AlphaFunc );
m_CurrentState.m_AlphaFunc = state.m_AlphaFunc;
}
if (m_CurrentState.m_AlphaRef != state.m_AlphaRef)
{
SetRenderStateConstMacro( D3DRS_ALPHAREF, state.m_AlphaRef );
m_CurrentState.m_AlphaRef = state.m_AlphaRef;
}
}
#ifdef DEBUG_BOARD_STATE
// This isn't quite true, but it's necessary for other error checking to work
BoardState().m_AlphaTestEnable = state.m_AlphaTestEnable;
BoardState().m_AlphaFunc = state.m_AlphaFunc;
BoardState().m_AlphaRef = state.m_AlphaRef;
#endif
}
void ApplyAlphaBlend( const ShadowState_t& state, int stage )
{
g_pTransitionTable->ApplyAlphaBlend( state );
}
void CTransitionTable::ApplyAlphaBlend( const ShadowState_t& state )
{
if (m_CurrentState.m_AlphaBlendEnable != state.m_AlphaBlendEnable)
{
SetRenderStateConstMacro( D3DRS_ALPHABLENDENABLE, state.m_AlphaBlendEnable );
m_CurrentState.m_AlphaBlendEnable = state.m_AlphaBlendEnable;
}
if (state.m_AlphaBlendEnable)
{
// Set the blend state here...
if (m_CurrentState.m_SrcBlend != state.m_SrcBlend)
{
SetRenderStateConstMacro( D3DRS_SRCBLEND, state.m_SrcBlend );
m_CurrentState.m_SrcBlend = state.m_SrcBlend;
}
if (m_CurrentState.m_DestBlend != state.m_DestBlend)
{
SetRenderStateConstMacro( D3DRS_DESTBLEND, state.m_DestBlend );
m_CurrentState.m_DestBlend = state.m_DestBlend;
}
if (m_CurrentState.m_BlendOp != state.m_BlendOp )
{
SetRenderStateConstMacro( D3DRS_BLENDOP, state.m_BlendOp );
m_CurrentState.m_BlendOp = state.m_BlendOp;
}
}
#ifdef DEBUG_BOARD_STATE
// This isn't quite true, but it's necessary for other error checking to work
BoardState().m_AlphaBlendEnable = state.m_AlphaBlendEnable;
BoardState().m_SrcBlend = state.m_SrcBlend;
BoardState().m_DestBlend = state.m_DestBlend;
BoardState().m_BlendOp = state.m_BlendOp;
#endif
}
void ApplySeparateAlphaBlend( const ShadowState_t& state, int stage )
{
g_pTransitionTable->ApplySeparateAlphaBlend( state );
}
void CTransitionTable::ApplySeparateAlphaBlend( const ShadowState_t& state )
{
if (m_CurrentState.m_SeparateAlphaBlendEnable != state.m_SeparateAlphaBlendEnable)
{
SetRenderStateConstMacro( D3DRS_SEPARATEALPHABLENDENABLE, state.m_SeparateAlphaBlendEnable );
m_CurrentState.m_SeparateAlphaBlendEnable = state.m_SeparateAlphaBlendEnable;
}
if (state.m_SeparateAlphaBlendEnable)
{
// Set the blend state here...
if (m_CurrentState.m_SrcBlendAlpha != state.m_SrcBlendAlpha)
{
SetRenderStateConstMacro( D3DRS_SRCBLENDALPHA, state.m_SrcBlendAlpha );
m_CurrentState.m_SrcBlendAlpha = state.m_SrcBlendAlpha;
}
if (m_CurrentState.m_DestBlendAlpha != state.m_DestBlendAlpha)
{
SetRenderStateConstMacro( D3DRS_DESTBLENDALPHA, state.m_DestBlendAlpha );
m_CurrentState.m_DestBlendAlpha = state.m_DestBlendAlpha;
}
if (m_CurrentState.m_BlendOpAlpha != state.m_BlendOpAlpha )
{
SetRenderStateConstMacro( D3DRS_BLENDOPALPHA, state.m_BlendOpAlpha );
m_CurrentState.m_BlendOpAlpha = state.m_BlendOpAlpha;
}
}
#ifdef DEBUG_BOARD_STATE
// This isn't quite true, but it's necessary for other error checking to work
BoardState().m_SeparateAlphaBlendEnable = state.m_SeparateAlphaBlendEnable;
BoardState().m_SrcBlendAlpha = state.m_SrcBlendAlpha;
BoardState().m_DestBlendAlpha = state.m_DestBlendAlpha;
BoardState().m_BlendOpAlpha = state.m_BlendOpAlpha;
#endif
}
//-----------------------------------------------------------------------------
// Applies alpha texture op
//-----------------------------------------------------------------------------
void ApplyColorTextureStage( const ShadowState_t& state, int stage )
{
g_pTransitionTable->ApplyColorTextureStage( state, stage );
}
void ApplyAlphaTextureStage( const ShadowState_t& state, int stage )
{
g_pTransitionTable->ApplyAlphaTextureStage( state, stage );
}
void CTransitionTable::ApplyColorTextureStage( const ShadowState_t& state, int stage )
{
D3DTEXTUREOP op = state.m_TextureStage[stage].m_ColorOp;
int arg1 = state.m_TextureStage[stage].m_ColorArg1;
int arg2 = state.m_TextureStage[stage].m_ColorArg2;
if (m_CurrentState.m_TextureStage[stage].m_ColorOp != op)
{
SetTextureStageState( stage, D3DTSS_COLOROP, op );
m_CurrentState.m_TextureStage[stage].m_ColorOp = op;
}
if (op != D3DTOP_DISABLE)
{
if (m_CurrentState.m_TextureStage[stage].m_ColorArg1 != arg1)
{
SetTextureStageState( stage, D3DTSS_COLORARG1, arg1 );
m_CurrentState.m_TextureStage[stage].m_ColorArg1 = arg1;
}
if (m_CurrentState.m_TextureStage[stage].m_ColorArg2 != arg2)
{
SetTextureStageState( stage, D3DTSS_COLORARG2, arg2 );
m_CurrentState.m_TextureStage[stage].m_ColorArg2 = arg2;
}
}
#ifdef DEBUG_BOARD_STATE
// This isn't quite true, but it's necessary for other error checking to work
BoardState().m_TextureStage[stage].m_ColorOp = op;
BoardState().m_TextureStage[stage].m_ColorArg1 = arg1;
BoardState().m_TextureStage[stage].m_ColorArg2 = arg2;
#endif
}
void CTransitionTable::ApplyAlphaTextureStage( const ShadowState_t& state, int stage )
{
D3DTEXTUREOP op = state.m_TextureStage[stage].m_AlphaOp;
int arg1 = state.m_TextureStage[stage].m_AlphaArg1;
int arg2 = state.m_TextureStage[stage].m_AlphaArg2;
if (m_CurrentState.m_TextureStage[stage].m_AlphaOp != op)
{
SetTextureStageState( stage, D3DTSS_ALPHAOP, op );
m_CurrentState.m_TextureStage[stage].m_AlphaOp = op;
}
if (op != D3DTOP_DISABLE)
{
if (m_CurrentState.m_TextureStage[stage].m_AlphaArg1 != arg1)
{
SetTextureStageState( stage, D3DTSS_ALPHAARG1, arg1 );
m_CurrentState.m_TextureStage[stage].m_AlphaArg1 = arg1;
}
if (m_CurrentState.m_TextureStage[stage].m_AlphaArg2 != arg2)
{
SetTextureStageState( stage, D3DTSS_ALPHAARG2, arg2 );
m_CurrentState.m_TextureStage[stage].m_AlphaArg2 = arg2;
}
}
#ifdef DEBUG_BOARD_STATE
// This isn't quite true, but it's necessary for other error checking to work
BoardState().m_TextureStage[stage].m_AlphaOp = op;
BoardState().m_TextureStage[stage].m_AlphaArg1 = arg1;
BoardState().m_TextureStage[stage].m_AlphaArg2 = arg2;
#endif
}
void ApplyActivateFixedFunction( const ShadowState_t& state, int stage )
{
int nStageCount = HardwareConfig()->GetTextureStageCount();
for ( int i = 0; i < nStageCount; ++i )
{
g_pTransitionTable->ApplyColorTextureStage( state, i );
g_pTransitionTable->ApplyAlphaTextureStage( state, i );
}
}
//-----------------------------------------------------------------------------
// Enables textures
//-----------------------------------------------------------------------------
void ApplyTextureEnable( const ShadowState_t& state, int stage )
{
// This may well enable/disable textures that are already enabled/disabled
// but the ShaderAPI will handle that
int i;
int nSamplerCount = HardwareConfig()->GetSamplerCount();
for ( i = 0; i < nSamplerCount; ++i )
{
ShaderAPI()->ApplyTextureEnable( state, i );
#ifdef DEBUG_BOARD_STATE
BoardState().m_SamplerState[i].m_TextureEnable = state.m_SamplerState[i].m_TextureEnable;
#endif
}
// Needed to prevent mat_dxlevel assertions
#ifdef DEBUG_BOARD_STATE
for ( i = nSamplerCount; i < MAX_SAMPLERS; ++i )
{
BoardState().m_SamplerState[i].m_TextureEnable = false;
}
#endif
}
//-----------------------------------------------------------------------------
// All transitions below this point depend on dynamic render state
// FIXME: Eliminate these virtual calls?
//-----------------------------------------------------------------------------
void ApplyCullEnable( const ShadowState_t& state, int arg )
{
ShaderAPI()->ApplyCullEnable( state.m_CullEnable );
#ifdef DEBUG_BOARD_STATE
BoardState().m_CullEnable = state.m_CullEnable;
#endif
}
//-----------------------------------------------------------------------------
void ApplyAlphaToCoverage( const ShadowState_t& state, int arg )
{
ShaderAPI()->ApplyAlphaToCoverage( state.m_EnableAlphaToCoverage );
#ifdef DEBUG_BOARD_STATE
BoardState().m_EnableAlphaToCoverage = state.m_EnableAlphaToCoverage;
#endif
}
//-----------------------------------------------------------------------------
void ApplyVertexBlendEnable( const ShadowState_t& state, int stage )
{
ShaderAPI()->SetVertexBlendState( state.m_VertexBlendEnable ? -1 : 0 );
#ifdef DEBUG_BOARD_STATE
BoardState().m_VertexBlendEnable = state.m_VertexBlendEnable;
#endif
}
//-----------------------------------------------------------------------------
// Outputs the fog mode string
//-----------------------------------------------------------------------------
#ifdef RECORDING
const char *ShaderFogModeToString( ShaderFogMode_t fogMode )
{
switch( fogMode )
{
case SHADER_FOGMODE_DISABLED:
return "SHADER_FOGMODE_DISABLED";
case SHADER_FOGMODE_OO_OVERBRIGHT:
return "SHADER_FOGMODE_OO_OVERBRIGHT";
case SHADER_FOGMODE_BLACK:
return "SHADER_FOGMODE_BLACK";
case SHADER_FOGMODE_GREY:
return "SHADER_FOGMODE_GREY";
case SHADER_FOGMODE_FOGCOLOR:
return "SHADER_FOGMODE_FOGCOLOR";
case SHADER_FOGMODE_WHITE:
return "SHADER_FOGMODE_WHITE";
case SHADER_FOGMODE_NUMFOGMODES:
return "SHADER_FOGMODE_NUMFOGMODES";
default:
return "ERROR";
}
}
#endif
// Uses GetConfig().overbright and GetSceneFogMode, so
// will have to fix up the state manually when those change.
void ApplyFogMode( const ShadowState_t& state, int arg )
{
#ifdef RECORDING
char buf[1024];
sprintf( buf, "ApplyFogMode( %s )", ShaderFogModeToString( state.m_FogMode ) );
RECORD_DEBUG_STRING( buf );
#endif
ShaderAPI()->ApplyFogMode( state.m_FogMode, state.m_SRGBWriteEnable, state.m_bDisableFogGammaCorrection );
#ifdef DEBUG_BOARD_STATE
BoardState().m_FogMode = state.m_FogMode;
#endif
}
//-----------------------------------------------------------------------------
// Function tables mapping enum to function
//-----------------------------------------------------------------------------
ApplyStateFunc_t s_pRenderFunctionTable[] =
{
ApplyDepthTest,
ApplyZWriteEnable,
ApplyColorWriteEnable,
ApplyAlphaTest,
ApplyFillMode,
ApplyLighting,
ApplySpecularEnable,
ApplySRGBWriteEnable,
ApplyAlphaBlend,
ApplySeparateAlphaBlend,
ApplyCullEnable,
ApplyVertexBlendEnable,
ApplyFogMode,
ApplyActivateFixedFunction,
ApplyTextureEnable, // Enables textures on *all* stages
ApplyDiffuseMaterialSource,
ApplyDisableFogGammaCorrection,
ApplyAlphaToCoverage,
};
ApplyStateFunc_t s_pTextureFunctionTable[] =
{
ApplyTexCoordIndex,
ApplySRGBReadEnable,
ApplyFetch4Enable,
#ifdef DX_TO_GL_ABSTRACTION
ApplyShadowFilterEnable,
#endif
// Fixed function states
ApplyColorTextureStage,
ApplyAlphaTextureStage,
};
//-----------------------------------------------------------------------------
// Creates an entry in the state transition table
//-----------------------------------------------------------------------------
inline void CTransitionTable::AddTransition( RenderStateFunc_t func )
{
int nElem = m_TransitionOps.AddToTail();
TransitionOp_t &op = m_TransitionOps[nElem];
op.m_nInfo.m_bIsTextureCode = false;
op.m_nInfo.m_nOpCode = func;
// Stats
// ++s_pRenderTransitions[ func ];
}
inline void CTransitionTable::AddTextureTransition( TextureStateFunc_t func, int stage )
{
int nElem = m_TransitionOps.AddToTail();
TransitionOp_t &op = m_TransitionOps[nElem];
op.m_nInfo.m_bIsTextureCode = true;
op.m_nInfo.m_nOpCode = TextureOp( func, stage );
// Stats
// ++s_pTextureTransitions[ func ][stage];
}
#define ADD_RENDER_STATE_TRANSITION( _state ) \
if (bForce || (toState.m_ ## _state != fromState.m_ ## _state)) \
{ \
AddTransition( RENDER_STATE_ ## _state ); \
++numOps; \
}
#define ADD_TEXTURE_STAGE_STATE_TRANSITION( _stage, _state )\
if (bForce || (toState.m_TextureStage[_stage].m_ ## _state != fromState.m_TextureStage[_stage].m_ ## _state)) \
{ \
Assert( _stage < MAX_TEXTURE_STAGES ); \
AddTextureTransition( TEXTURE_STATE_ ## _state, _stage ); \
++numOps; \
}
#define ADD_SAMPLER_STATE_TRANSITION( _stage, _state )\
if (bForce || (toState.m_SamplerState[_stage].m_ ## _state != fromState.m_SamplerState[_stage].m_ ## _state)) \
{ \
Assert( _stage < MAX_SAMPLERS ); \
AddTextureTransition( TEXTURE_STATE_ ## _state, _stage ); \
++numOps; \
}
int CTransitionTable::CreateNormalTransitions( const ShadowState_t& fromState, const ShadowState_t& toState, bool bForce )
{
int numOps = 0;
// Special case for alpha blending to eliminate extra transitions
bool blendEnableDifferent = (toState.m_AlphaBlendEnable != fromState.m_AlphaBlendEnable);
bool srcBlendDifferent = toState.m_AlphaBlendEnable && (toState.m_SrcBlend != fromState.m_SrcBlend);
bool destBlendDifferent = toState.m_AlphaBlendEnable && (toState.m_DestBlend != fromState.m_DestBlend);
bool blendOpDifferent = toState.m_AlphaBlendEnable && ( toState.m_BlendOp != fromState.m_BlendOp );
if (bForce || blendOpDifferent || blendEnableDifferent || srcBlendDifferent || destBlendDifferent)
{
AddTransition( RENDER_STATE_AlphaBlend );
++numOps;
}
// Shouldn't have m_SeparateAlphaBlendEnable set unless m_AlphaBlendEnable is also set.
Assert ( toState.m_AlphaBlendEnable || !toState.m_SeparateAlphaBlendEnable );
bool blendSeparateAlphaEnableDifferent = (toState.m_SeparateAlphaBlendEnable != fromState.m_SeparateAlphaBlendEnable);
bool srcBlendAlphaDifferent = toState.m_SeparateAlphaBlendEnable && (toState.m_SrcBlendAlpha != fromState.m_SrcBlendAlpha);
bool destBlendAlphaDifferent = toState.m_SeparateAlphaBlendEnable && (toState.m_DestBlendAlpha != fromState.m_DestBlendAlpha);
bool blendOpAlphaDifferent = toState.m_SeparateAlphaBlendEnable && ( toState.m_BlendOpAlpha != fromState.m_BlendOpAlpha );
if (bForce || blendOpAlphaDifferent || blendSeparateAlphaEnableDifferent || srcBlendAlphaDifferent || destBlendAlphaDifferent)
{
AddTransition( RENDER_STATE_SeparateAlphaBlend );
++numOps;
}
bool bAlphaTestEnableDifferent = (toState.m_AlphaTestEnable != fromState.m_AlphaTestEnable);
bool bAlphaFuncDifferent = toState.m_AlphaTestEnable && (toState.m_AlphaFunc != fromState.m_AlphaFunc);
bool bAlphaRefDifferent = toState.m_AlphaTestEnable && (toState.m_AlphaRef != fromState.m_AlphaRef);
if (bForce || bAlphaTestEnableDifferent || bAlphaFuncDifferent || bAlphaRefDifferent)
{
AddTransition( RENDER_STATE_AlphaTest );
++numOps;
}
bool bDepthTestEnableDifferent = (toState.m_ZEnable != fromState.m_ZEnable);
bool bDepthFuncDifferent = (toState.m_ZEnable != D3DZB_FALSE) && (toState.m_ZFunc != fromState.m_ZFunc);
bool bDepthBiasDifferent = (toState.m_ZBias != fromState.m_ZBias);
if (bForce || bDepthTestEnableDifferent || bDepthFuncDifferent || bDepthBiasDifferent)
{
AddTransition( RENDER_STATE_DepthTest );
++numOps;
}
if ( bForce || (toState.m_UsingFixedFunction && !fromState.m_UsingFixedFunction) )
{
AddTransition( RENDER_STATE_ActivateFixedFunction );
++numOps;
}
if ( bForce || (toState.m_bDisableFogGammaCorrection != fromState.m_bDisableFogGammaCorrection) )
{
AddTransition( RENDER_STATE_DisableFogGammaCorrection );
++numOps;
}
int nStageCount = HardwareConfig()->GetTextureStageCount();
int i;
for ( i = 0; i < nStageCount; ++i )
{
// Special case for texture stage ops to eliminate extra transitions
// NOTE: If we're forcing transitions, then ActivateFixedFunction above will take care of all these transitions
if ( !bForce && toState.m_UsingFixedFunction && fromState.m_UsingFixedFunction )
{
const TextureStageShadowState_t& fromTexture = fromState.m_TextureStage[i];
const TextureStageShadowState_t& toTexture = toState.m_TextureStage[i];
bool fromEnabled = (fromTexture.m_ColorOp != D3DTOP_DISABLE);
bool toEnabled = (toTexture.m_ColorOp != D3DTOP_DISABLE);
if ( fromEnabled || toEnabled )
{
bool opDifferent = (toTexture.m_ColorOp != fromTexture.m_ColorOp);
bool arg1Different = (toTexture.m_ColorArg1 != fromTexture.m_ColorArg1);
bool arg2Different = (toTexture.m_ColorArg2 != fromTexture.m_ColorArg2);
if (opDifferent || arg1Different || arg2Different )
{
AddTextureTransition( TEXTURE_STATE_ColorTextureStage, i );
++numOps;
}
}
fromEnabled = (fromTexture.m_AlphaOp != D3DTOP_DISABLE);
toEnabled = (toTexture.m_AlphaOp != D3DTOP_DISABLE);
if ( fromEnabled || toEnabled )
{
bool opDifferent = (toTexture.m_AlphaOp != fromTexture.m_AlphaOp);
bool arg1Different = (toTexture.m_AlphaArg1 != fromTexture.m_AlphaArg1);
bool arg2Different = (toTexture.m_AlphaArg2 != fromTexture.m_AlphaArg2);
if (opDifferent || arg1Different || arg2Different )
{
AddTextureTransition( TEXTURE_STATE_AlphaTextureStage, i );
++numOps;
}
}
}
ADD_TEXTURE_STAGE_STATE_TRANSITION( i, TexCoordIndex );
}
int nSamplerCount = HardwareConfig()->GetSamplerCount();
for ( int i = 0; i < nSamplerCount; ++i )
{
ADD_SAMPLER_STATE_TRANSITION( i, SRGBReadEnable );
ADD_SAMPLER_STATE_TRANSITION( i, Fetch4Enable );
#ifdef DX_TO_GL_ABSTRACTION
ADD_SAMPLER_STATE_TRANSITION( i, ShadowFilterEnable );
#endif
}
return numOps;
}
void CTransitionTable::CreateTransitionTableEntry( int to, int from )
{
// You added or removed a state to the enums but not to the function table lists!
COMPILE_TIME_ASSERT( sizeof(s_pRenderFunctionTable) == sizeof(ApplyStateFunc_t) * RENDER_STATE_COUNT );
COMPILE_TIME_ASSERT( sizeof(s_pTextureFunctionTable) == sizeof(ApplyStateFunc_t) * TEXTURE_STATE_COUNT );
// If from < 0, that means add *all* transitions into it.
unsigned int firstElem = m_TransitionOps.Count();
unsigned short numOps = 0;
const ShadowState_t& toState = m_ShadowStateList[to];
const ShadowState_t& fromState = (from >= 0) ? m_ShadowStateList[from] : m_ShadowStateList[to];
bool bForce = (from < 0);
ADD_RENDER_STATE_TRANSITION( ZWriteEnable )
ADD_RENDER_STATE_TRANSITION( ColorWriteEnable )
ADD_RENDER_STATE_TRANSITION( FillMode )
ADD_RENDER_STATE_TRANSITION( Lighting )
ADD_RENDER_STATE_TRANSITION( SpecularEnable )
ADD_RENDER_STATE_TRANSITION( SRGBWriteEnable )
ADD_RENDER_STATE_TRANSITION( DiffuseMaterialSource )
// Some code for the non-trivial transitions
numOps += CreateNormalTransitions( fromState, toState, bForce );
// NOTE: From here on down are transitions that depend on dynamic state
// and which can therefore not appear in the state block
ADD_RENDER_STATE_TRANSITION( CullEnable )
ADD_RENDER_STATE_TRANSITION( EnableAlphaToCoverage )
ADD_RENDER_STATE_TRANSITION( VertexBlendEnable )
// NOTE! : Have to do the extra check for changes in m_UsingFixedFunction
// since d3d fog state is different if you are using fixed function vs.
// using a vsh/psh.
// This code is derived from: ADD_RENDER_STATE_TRANSITION( FogMode )
// If ADD_RENDER_STATE_TRANSITION ever changes, this needs to be updated!
// This is another reason to try to have very little fixed function in the dx8/dx9 path.
if( bForce || (toState.m_FogMode != fromState.m_FogMode ) ||
( toState.m_UsingFixedFunction != fromState.m_UsingFixedFunction ) )
{
AddTransition( RENDER_STATE_FogMode );
++numOps;
}
bool bDifferentTexturesEnabled = false;
int nSamplerCount = HardwareConfig()->GetSamplerCount();
for ( int i = 0; i < nSamplerCount; ++i )
{
if ( toState.m_SamplerState[i].m_TextureEnable != fromState.m_SamplerState[i].m_TextureEnable )
{
bDifferentTexturesEnabled = true;
break;
}
}
if ( bForce || bDifferentTexturesEnabled )
{
AddTransition( RENDER_STATE_TextureEnable );
++numOps;
}
// Look for identical transition lists, and use those instead...
TransitionList_t& transition = (from >= 0) ?
m_TransitionTable[to][from] : m_DefaultTransition;
Assert( numOps <= 255 );
transition.m_NumOperations = numOps;
// This condition can happen, and is valid. It occurs when we snapshot
// state but do not generate a transition function for that state
if (numOps == 0)
{
transition.m_FirstOperation = INVALID_TRANSITION_OP;
return;
}
// An optimization to try to early out of the identical transition check
// taking advantage of the fact that the matrix is usually diagonal.
unsigned int nFirstTest = INVALID_TRANSITION_OP;
if (from >= 0)
{
TransitionList_t &diagonalList = m_TransitionTable[from][to];
if ( diagonalList.m_NumOperations == numOps )
{
nFirstTest = diagonalList.m_FirstOperation;
}
}
unsigned int identicalListFirstElem = FindIdenticalTransitionList( firstElem, numOps, nFirstTest );
if (identicalListFirstElem == INVALID_TRANSITION_OP)
{
transition.m_FirstOperation = firstElem;
m_UniqueTransitions.Insert( transition );
Assert( (int)firstElem + (int)numOps < 16777215 );
if( (int)firstElem + (int)numOps >= 16777215 )
{
Warning("**** WARNING: Transition table overflow. Grab Brian\n");
}
}
else
{
// Remove the transitions ops we made; use the duplicate copy
transition.m_FirstOperation = identicalListFirstElem;
m_TransitionOps.RemoveMultiple( firstElem, numOps );
}
}
//-----------------------------------------------------------------------------
// Tests a snapshot to see if it can be used
//-----------------------------------------------------------------------------
#define PERFORM_RENDER_STATE_TRANSITION( _state, _func ) \
::Apply ## _func( _state, 0 );
#define PERFORM_TEXTURE_STAGE_STATE_TRANSITION( _state, _stage, _func ) \
::Apply ## _func( _state, _stage );
#define PERFORM_SAMPLER_STATE_TRANSITION( _state, _stage, _func ) \
::Apply ## _func( _state, _stage );
bool CTransitionTable::TestShadowState( const ShadowState_t& state, const ShadowShaderState_t &shaderState )
{
PERFORM_RENDER_STATE_TRANSITION( state, DepthTest )
PERFORM_RENDER_STATE_TRANSITION( state, ZWriteEnable )
PERFORM_RENDER_STATE_TRANSITION( state, ColorWriteEnable )
PERFORM_RENDER_STATE_TRANSITION( state, AlphaTest )
PERFORM_RENDER_STATE_TRANSITION( state, FillMode )
PERFORM_RENDER_STATE_TRANSITION( state, Lighting )
PERFORM_RENDER_STATE_TRANSITION( state, SpecularEnable )
PERFORM_RENDER_STATE_TRANSITION( state, SRGBWriteEnable )
PERFORM_RENDER_STATE_TRANSITION( state, AlphaBlend )
PERFORM_RENDER_STATE_TRANSITION( state, SeparateAlphaBlend )
PERFORM_RENDER_STATE_TRANSITION( state, CullEnable )
PERFORM_RENDER_STATE_TRANSITION( state, AlphaToCoverage )
PERFORM_RENDER_STATE_TRANSITION( state, VertexBlendEnable )
PERFORM_RENDER_STATE_TRANSITION( state, FogMode )
PERFORM_RENDER_STATE_TRANSITION( state, ActivateFixedFunction )
PERFORM_RENDER_STATE_TRANSITION( state, TextureEnable )
PERFORM_RENDER_STATE_TRANSITION( state, DiffuseMaterialSource )
int i;
int nStageCount = HardwareConfig()->GetTextureStageCount();
for ( i = 0; i < nStageCount; ++i )
{
PERFORM_TEXTURE_STAGE_STATE_TRANSITION( state, i, ColorTextureStage );
PERFORM_TEXTURE_STAGE_STATE_TRANSITION( state, i, AlphaTextureStage );
PERFORM_TEXTURE_STAGE_STATE_TRANSITION( state, i, TexCoordIndex );
}
int nSamplerCount = HardwareConfig()->GetSamplerCount();
for ( i = 0; i < nSamplerCount; ++i )
{
PERFORM_SAMPLER_STATE_TRANSITION( state, i, SRGBReadEnable );
PERFORM_SAMPLER_STATE_TRANSITION( state, i, Fetch4Enable );
#ifdef DX_TO_GL_ABSTRACTION
PERFORM_SAMPLER_STATE_TRANSITION( state, i, ShadowFilterEnable );
#endif
}
// Just make sure we've got a good snapshot
RECORD_COMMAND( DX8_VALIDATE_DEVICE, 0 );
#if !defined( _X360 )
DWORD numPasses;
HRESULT hr = Dx9Device()->ValidateDevice( &numPasses );
bool ok = !FAILED(hr);
#else
bool ok = true;
#endif
// Now set the board state to match the default state
ApplyTransition( m_DefaultTransition, m_DefaultStateSnapshot );
ShaderManager()->SetVertexShader( shaderState.m_VertexShader );
ShaderManager()->SetPixelShader( shaderState.m_PixelShader );
return ok;
}
//-----------------------------------------------------------------------------
// Finds identical transition lists and shares them
//-----------------------------------------------------------------------------
unsigned int CTransitionTable::FindIdenticalTransitionList( unsigned int firstElem,
unsigned short numOps, unsigned int nFirstTest ) const
{
VPROF("CTransitionTable::FindIdenticalTransitionList");
// As it turns out, this works most of the time
if ( nFirstTest != INVALID_TRANSITION_OP )
{
const TransitionOp_t *pCurrOp = &m_TransitionOps[firstElem];
const TransitionOp_t *pTestOp = &m_TransitionOps[nFirstTest];
if ( !memcmp( pCurrOp, pTestOp, numOps * sizeof(TransitionOp_t) ) )
return nFirstTest;
}
// Look for a common list
const TransitionOp_t &op = m_TransitionOps[firstElem];
int nCount = m_UniqueTransitions.Count();
for ( int i = 0; i < nCount; ++i )
{
const TransitionList_t &list = m_UniqueTransitions[i];
// We can early out here because we've sorted the unique transitions
// descending by count
if ( list.m_NumOperations < numOps )
return INVALID_TRANSITION_OP;
// If we don't find a match in the first
int nPotentialMatch;
int nLastTest = list.m_FirstOperation + list.m_NumOperations - numOps;
for ( nPotentialMatch = list.m_FirstOperation; nPotentialMatch <= nLastTest; ++nPotentialMatch )
{
// Find the first match
const TransitionOp_t &testOp = m_TransitionOps[nPotentialMatch];
if ( testOp.m_nBits == op.m_nBits )
break;
}
// No matches found, continue
if ( nPotentialMatch > nLastTest )
continue;
// Ok, found a match of the first op, lets see if they all match
if ( numOps == 1 )
return nPotentialMatch;
const TransitionOp_t *pCurrOp = &m_TransitionOps[firstElem + 1];
const TransitionOp_t *pTestOp = &m_TransitionOps[nPotentialMatch + 1];
if ( !memcmp( pCurrOp, pTestOp, (numOps - 1) * sizeof(TransitionOp_t) ) )
return nPotentialMatch;
}
return INVALID_TRANSITION_OP;
}
//-----------------------------------------------------------------------------
// Create startup snapshot
//-----------------------------------------------------------------------------
void CTransitionTable::TakeDefaultStateSnapshot( )
{
if (m_DefaultStateSnapshot == -1)
{
m_DefaultStateSnapshot = TakeSnapshot();
// This will create a transition which sets *all* shadowed state
CreateTransitionTableEntry( m_DefaultStateSnapshot, -1 );
}
}
//-----------------------------------------------------------------------------
// Applies the transition list
//-----------------------------------------------------------------------------
void CTransitionTable::ApplyTransitionList( int snapshot, int nFirstOp, int nOpCount )
{
VPROF("CTransitionTable::ApplyTransitionList");
// Don't bother if there's nothing to do
if (nOpCount > 0)
{
// Trying to avoid function overhead here
ShadowState_t& shadowState = m_ShadowStateList[snapshot];
TransitionOp_t* pTransitionOp = &m_TransitionOps[nFirstOp];
for (int i = 0; i < nOpCount; ++i )
{
// invoke the transition method
if ( pTransitionOp->m_nInfo.m_bIsTextureCode )
{
TextureStateFunc_t code;
int nStage;
GetTextureOp( pTransitionOp->m_nInfo.m_nOpCode, &code, &nStage );
(*s_pTextureFunctionTable[code])( shadowState, nStage );
}
else
{
(*s_pRenderFunctionTable[pTransitionOp->m_nInfo.m_nOpCode])( shadowState, 0 );
}
++pTransitionOp;
}
}
}
//-----------------------------------------------------------------------------
// Apply startup snapshot
//-----------------------------------------------------------------------------
#ifdef _WIN32
#pragma warning( disable : 4189 )
#endif
void CTransitionTable::ApplyTransition( TransitionList_t& list, int snapshot )
{
VPROF("CTransitionTable::ApplyTransition");
if ( g_pShaderDeviceDx8->IsDeactivated() )
return;
// Transition lists when using state blocks have 2 parts: the first
// is the stateblock part, which is states that are not related to
// dynamic state at all; followed by states that *are* affected by dynamic state
int nFirstOp = list.m_FirstOperation;
int nOpCount = list.m_NumOperations;
ApplyTransitionList( snapshot, nFirstOp, nOpCount );
// Semi-hacky code to override what the transitions are doing
PerformShadowStateOverrides();
// Set the current snapshot id
m_CurrentShadowId = snapshot;
#ifdef DEBUG_BOARD_STATE
// Copy over the board states that aren't explicitly in the transition table
// so the assertion works...
int i;
int nSamplerCount = HardwareConfig()->GetSamplerCount();
for ( i = nSamplerCount; i < MAX_SAMPLERS; ++i )
{
m_BoardState.m_SamplerState[i].m_TextureEnable =
CurrentShadowState()->m_SamplerState[i].m_TextureEnable;
}
int nTextureStageCount = HardwareConfig()->GetTextureStageCount();
for ( i = nTextureStageCount; i < MAX_TEXTURE_STAGES; ++i )
{
memcpy( &m_BoardState.m_TextureStage[i], &CurrentShadowState()->m_TextureStage[i], sizeof(TextureStageShadowState_t) );
}
m_BoardState.m_UsingFixedFunction = CurrentShadowState()->m_UsingFixedFunction;
// State blocks bypass the code that sets the board state
#ifdef _DEBUG
// NOTE: A memcmp here isn't enough since we don't set alpha args in cases where the op is nothing.
// Assert( !memcmp( &m_BoardState, &CurrentShadowState(), sizeof(m_BoardState) ) );
const ShadowState_t &testState1 = *CurrentShadowState();
ShadowState_t testState2 = m_BoardState;
if ( testState1.m_ZEnable == D3DZB_FALSE )
{
testState2.m_ZBias = testState1.m_ZBias;
testState2.m_ZFunc = testState1.m_ZFunc;
}
if ( !testState1.m_AlphaTestEnable )
{
testState2.m_AlphaRef = testState1.m_AlphaRef;
testState2.m_AlphaFunc = testState1.m_AlphaFunc;
}
for( i = 0; i < nTextureStageCount; i++ )
{
if ( !testState1.m_UsingFixedFunction )
{
testState2.m_TextureStage[i].m_ColorOp = testState1.m_TextureStage[i].m_ColorOp;
testState2.m_TextureStage[i].m_ColorArg1 = testState1.m_TextureStage[i].m_ColorArg1;
testState2.m_TextureStage[i].m_ColorArg2 = testState1.m_TextureStage[i].m_ColorArg2;
testState2.m_TextureStage[i].m_AlphaOp = testState1.m_TextureStage[i].m_AlphaOp;
testState2.m_TextureStage[i].m_AlphaArg1 = testState1.m_TextureStage[i].m_AlphaArg1;
testState2.m_TextureStage[i].m_AlphaArg2 = testState1.m_TextureStage[i].m_AlphaArg2;
}
else
{
if ( testState1.m_TextureStage[i].m_ColorOp == D3DTOP_DISABLE )
{
testState2.m_TextureStage[i].m_ColorArg1 = testState1.m_TextureStage[i].m_ColorArg1;
testState2.m_TextureStage[i].m_ColorArg2 = testState1.m_TextureStage[i].m_ColorArg2;
}
if ( testState1.m_TextureStage[i].m_AlphaOp == D3DTOP_DISABLE )
{
testState2.m_TextureStage[i].m_AlphaArg1 = testState1.m_TextureStage[i].m_AlphaArg1;
testState2.m_TextureStage[i].m_AlphaArg2 = testState1.m_TextureStage[i].m_AlphaArg2;
}
}
}
Assert( !memcmp( &testState1, &testState2, sizeof( testState1 ) ) );
#endif
#endif
}
#ifdef _WIN32
#pragma warning( default : 4189 )
#endif
//-----------------------------------------------------------------------------
// Takes a snapshot, hooks it into the material
//-----------------------------------------------------------------------------
StateSnapshot_t CTransitionTable::TakeSnapshot( )
{
// Do any final computation of the shadow state
ShaderShadow()->ComputeAggregateShadowState();
// Get the current snapshot
const ShadowState_t& currentState = ShaderShadow()->GetShadowState();
// Create a new snapshot
ShadowStateId_t shadowStateId = FindShadowState( currentState );
if (shadowStateId == -1)
{
// Create entry in state transition table
shadowStateId = CreateShadowState( currentState );
// Now create new transition entries
for (int to = 0; to < shadowStateId; ++to)
{
CreateTransitionTableEntry( to, shadowStateId );
}
for (int from = 0; from < shadowStateId; ++from)
{
CreateTransitionTableEntry( shadowStateId, from );
}
}
const ShadowShaderState_t& currentShaderState = ShaderShadow()->GetShadowShaderState();
StateSnapshot_t snapshotId = FindStateSnapshot( shadowStateId, currentShaderState );
if (snapshotId == -1)
{
// Create entry in state transition table
snapshotId = CreateStateSnapshot( shadowStateId, currentShaderState );
}
return snapshotId;
}
//-----------------------------------------------------------------------------
// Apply shader state (stuff that doesn't lie in the transition table)
//-----------------------------------------------------------------------------
void CTransitionTable::ApplyShaderState( const ShadowState_t &shadowState, const ShadowShaderState_t &shaderState )
{
VPROF("CTransitionTable::ApplyShaderState");
// Don't bother testing against the current state because there
// could well be dynamic state modifiers affecting this too....
if ( !shadowState.m_UsingFixedFunction )
{
// FIXME: Improve early-binding of vertex shader index
ShaderManager()->SetVertexShader( shaderState.m_VertexShader );
ShaderManager()->SetPixelShader( shaderState.m_PixelShader );
#ifdef DEBUG_BOARD_STATE
BoardShaderState().m_VertexShader = shaderState.m_VertexShader;
BoardShaderState().m_PixelShader = shaderState.m_PixelShader;
BoardShaderState().m_nStaticVshIndex = shaderState.m_nStaticVshIndex;
BoardShaderState().m_nStaticPshIndex = shaderState.m_nStaticPshIndex;
#endif
}
else
{
ShaderManager()->SetVertexShader( INVALID_SHADER );
ShaderManager()->SetPixelShader( INVALID_SHADER );
#if defined( _X360 )
// no fixed function support
Assert( 0 );
#endif
#ifdef DEBUG_BOARD_STATE
BoardShaderState().m_VertexShader = INVALID_SHADER;
BoardShaderState().m_PixelShader = INVALID_SHADER;
BoardShaderState().m_nStaticVshIndex = 0;
BoardShaderState().m_nStaticPshIndex = 0;
#endif
}
}
//-----------------------------------------------------------------------------
// Makes the board state match the snapshot
//-----------------------------------------------------------------------------
void CTransitionTable::UseSnapshot( StateSnapshot_t snapshotId )
{
VPROF("CTransitionTable::UseSnapshot");
ShadowStateId_t id = m_SnapshotList[snapshotId].m_ShadowStateId;
if (m_CurrentSnapshotId != snapshotId)
{
// First apply things that are in the transition table
if ( m_CurrentShadowId != id )
{
TransitionList_t& transition = m_TransitionTable[id][m_CurrentShadowId];
ApplyTransition( transition, id );
}
// NOTE: There is an opportunity here to set non-dynamic state that we don't
// store in the transition list if we ever need it.
m_CurrentSnapshotId = snapshotId;
}
// NOTE: This occurs regardless of whether the snapshot changed because it depends
// on dynamic state (namely, the dynamic vertex + pixel shader index)
// Followed by things that are not
ApplyShaderState( m_ShadowStateList[id], m_SnapshotList[snapshotId].m_ShaderState );
#ifdef _DEBUG
// NOTE: We can't ship with this active because mod makers may well violate this rule
// We don't want no stinking fixed-function on hardware that has vertex and pixel shaders. .
// This could cause a serious perf hit.
if( HardwareConfig()->SupportsVertexAndPixelShaders() )
{
// Assert( !CurrentShadowState().m_UsingFixedFunction );
}
#endif
}
//-----------------------------------------------------------------------------
// Cause the board to match the default state snapshot
//-----------------------------------------------------------------------------
void CTransitionTable::UseDefaultState( )
{
VPROF("CTransitionTable::UseDefaultState");
// Need to blat these out because they are tested during transitions
m_CurrentState.m_AlphaBlendEnable = false;
m_CurrentState.m_SrcBlend = D3DBLEND_ONE;
m_CurrentState.m_DestBlend = D3DBLEND_ZERO;
m_CurrentState.m_BlendOp = D3DBLENDOP_ADD;
SetRenderStateConstMacro( D3DRS_ALPHABLENDENABLE, m_CurrentState.m_AlphaBlendEnable );
SetRenderStateConstMacro( D3DRS_SRCBLEND, m_CurrentState.m_SrcBlend );
SetRenderStateConstMacro( D3DRS_DESTBLEND, m_CurrentState.m_DestBlend );
SetRenderStateConstMacro( D3DRS_BLENDOP, m_CurrentState.m_BlendOp );
m_CurrentState.m_SeparateAlphaBlendEnable = false;
m_CurrentState.m_SrcBlendAlpha = D3DBLEND_ONE;
m_CurrentState.m_DestBlendAlpha = D3DBLEND_ZERO;
m_CurrentState.m_BlendOpAlpha = D3DBLENDOP_ADD;
SetRenderStateConstMacro( D3DRS_SEPARATEALPHABLENDENABLE, m_CurrentState.m_SeparateAlphaBlendEnable );
SetRenderStateConstMacro( D3DRS_SRCBLENDALPHA, m_CurrentState.m_SrcBlendAlpha );
SetRenderStateConstMacro( D3DRS_DESTBLENDALPHA, m_CurrentState.m_DestBlendAlpha );
SetRenderStateConstMacro( D3DRS_BLENDOPALPHA, m_CurrentState.m_BlendOpAlpha );
m_CurrentState.m_ZEnable = D3DZB_TRUE;
m_CurrentState.m_ZFunc = D3DCMP_LESSEQUAL;
m_CurrentState.m_ZBias = SHADER_POLYOFFSET_DISABLE;
SetRenderStateConstMacro( D3DRS_ZENABLE, m_CurrentState.m_ZEnable );
#if defined( _X360 )
//SetRenderStateConstMacro( D3DRS_HIZENABLE, m_CurrentState.m_ZEnable ? D3DHIZ_AUTOMATIC : D3DHIZ_DISABLE );
#endif
SetRenderStateConstMacro( D3DRS_ZFUNC, m_CurrentState.m_ZFunc );
m_CurrentState.m_AlphaTestEnable = false;
m_CurrentState.m_AlphaFunc = D3DCMP_GREATEREQUAL;
m_CurrentState.m_AlphaRef = 0;
SetRenderStateConstMacro( D3DRS_ALPHATESTENABLE, m_CurrentState.m_AlphaTestEnable );
SetRenderStateConstMacro( D3DRS_ALPHAFUNC, m_CurrentState.m_AlphaFunc );
SetRenderStateConstMacro( D3DRS_ALPHAREF, m_CurrentState.m_AlphaRef );
int nTextureStages = ShaderAPI()->GetActualTextureStageCount();
for ( int i = 0; i < nTextureStages; ++i)
{
TextureStage(i).m_ColorOp = D3DTOP_DISABLE;
TextureStage(i).m_ColorArg1 = D3DTA_TEXTURE;
TextureStage(i).m_ColorArg2 = (i == 0) ? D3DTA_DIFFUSE : D3DTA_CURRENT;
TextureStage(i).m_AlphaOp = D3DTOP_DISABLE;
TextureStage(i).m_AlphaArg1 = D3DTA_TEXTURE;
TextureStage(i).m_AlphaArg2 = (i == 0) ? D3DTA_DIFFUSE : D3DTA_CURRENT;
SetTextureStageState( i, D3DTSS_COLOROP, TextureStage(i).m_ColorOp );
SetTextureStageState( i, D3DTSS_COLORARG1, TextureStage(i).m_ColorArg1 );
SetTextureStageState( i, D3DTSS_COLORARG2, TextureStage(i).m_ColorArg2 );
SetTextureStageState( i, D3DTSS_ALPHAOP, TextureStage(i).m_AlphaOp );
SetTextureStageState( i, D3DTSS_ALPHAARG1, TextureStage(i).m_AlphaArg1 );
SetTextureStageState( i, D3DTSS_ALPHAARG2, TextureStage(i).m_AlphaArg2 );
}
int nSamplerCount = ShaderAPI()->GetActualSamplerCount();
for ( int i = 0; i < nSamplerCount; ++i)
{
SetSamplerState( i, D3DSAMP_SRGBTEXTURE, SamplerState(i).m_SRGBReadEnable );
// Set default Fetch4 state on parts which support it
if ( ShaderAPI()->SupportsFetch4() )
{
SetSamplerState( i, ATISAMP_FETCH4, SamplerState(i).m_Fetch4Enable ? ATI_FETCH4_ENABLE : ATI_FETCH4_DISABLE );
}
#ifdef DX_TO_GL_ABSTRACTION
SetSamplerState( i, D3DSAMP_SHADOWFILTER, SamplerState(i).m_ShadowFilterEnable );
#endif
}
// Disable z overrides...
m_CurrentState.m_bOverrideDepthEnable = false;
m_CurrentState.m_bOverrideAlphaWriteEnable = false;
m_CurrentState.m_bOverrideColorWriteEnable = false;
m_CurrentState.m_ForceDepthFuncEquals = false;
m_CurrentState.m_bLinearColorSpaceFrameBufferEnable = false;
ApplyTransition( m_DefaultTransition, m_DefaultStateSnapshot );
ShaderManager()->SetVertexShader( INVALID_SHADER );
ShaderManager()->SetPixelShader( INVALID_SHADER );
m_CurrentSnapshotId = -1;
}
//-----------------------------------------------------------------------------
// Snapshotted state overrides
//-----------------------------------------------------------------------------
void CTransitionTable::ForceDepthFuncEquals( bool bEnable )
{
if( bEnable != m_CurrentState.m_ForceDepthFuncEquals )
{
// Do this so that we can call this from within the rendering code
// See OverrideDepthEnable + PerformShadowStateOverrides for a version
// that isn't expected to be called from within rendering code
if( !ShaderAPI()->IsRenderingMesh() )
{
ShaderAPI()->FlushBufferedPrimitives();
}
m_CurrentState.m_ForceDepthFuncEquals = bEnable;
if( bEnable )
{
SetZFunc( D3DCMP_EQUAL );
}
else
{
if ( CurrentShadowState() )
{
SetZFunc( CurrentShadowState()->m_ZFunc );
}
}
}
}
void CTransitionTable::OverrideDepthEnable( bool bEnable, bool bDepthEnable )
{
if ( bEnable != m_CurrentState.m_bOverrideDepthEnable )
{
ShaderAPI()->FlushBufferedPrimitives();
m_CurrentState.m_bOverrideDepthEnable = bEnable;
m_CurrentState.m_OverrideZWriteEnable = bDepthEnable ? D3DZB_TRUE : D3DZB_FALSE;
if ( m_CurrentState.m_bOverrideDepthEnable )
{
SetZEnable( D3DZB_TRUE );
SetRenderStateConstMacro( D3DRS_ZWRITEENABLE, m_CurrentState.m_OverrideZWriteEnable );
#if defined( _X360 )
//SetRenderStateConstMacro( D3DRS_HIZWRITEENABLE, m_CurrentState.m_OverrideZWriteEnable ? D3DHIZ_AUTOMATIC : D3DHIZ_DISABLE );
#endif
}
else
{
if ( CurrentShadowState() )
{
SetZEnable( CurrentShadowState()->m_ZEnable );
SetRenderStateConstMacro( D3DRS_ZWRITEENABLE, CurrentShadowState()->m_ZWriteEnable );
#if defined( _X360 )
//SetRenderStateConstMacro( D3DRS_HIZWRITEENABLE, CurrentShadowState()->m_ZWriteEnable ? D3DHIZ_AUTOMATIC : D3DHIZ_DISABLE );
#endif
}
}
}
}
void CTransitionTable::OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable )
{
if ( bOverrideEnable != m_CurrentState.m_bOverrideAlphaWriteEnable )
{
ShaderAPI()->FlushBufferedPrimitives();
m_CurrentState.m_bOverrideAlphaWriteEnable = bOverrideEnable;
m_CurrentState.m_bOverriddenAlphaWriteValue = bAlphaWriteEnable;
DWORD dwSetValue = m_CurrentState.m_ColorWriteEnable;
if ( m_CurrentState.m_bOverrideAlphaWriteEnable )
{
if( m_CurrentState.m_bOverriddenAlphaWriteValue )
{
dwSetValue |= D3DCOLORWRITEENABLE_ALPHA;
}
else
{
dwSetValue &= ~D3DCOLORWRITEENABLE_ALPHA;
}
}
else
{
if ( CurrentShadowState() )
{
//probably being paranoid, but only copy the alpha flag from the shadow state
dwSetValue &= ~D3DCOLORWRITEENABLE_ALPHA;
dwSetValue |= CurrentShadowState()->m_ColorWriteEnable & D3DCOLORWRITEENABLE_ALPHA;
}
}
if( dwSetValue != m_CurrentState.m_ColorWriteEnable )
{
m_CurrentState.m_ColorWriteEnable = dwSetValue;
SetRenderState( D3DRS_COLORWRITEENABLE, m_CurrentState.m_ColorWriteEnable );
}
}
}
void CTransitionTable::OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable )
{
if ( bOverrideEnable != m_CurrentState.m_bOverrideColorWriteEnable )
{
ShaderAPI()->FlushBufferedPrimitives();
m_CurrentState.m_bOverrideColorWriteEnable = bOverrideEnable;
m_CurrentState.m_bOverriddenColorWriteValue = bColorWriteEnable;
DWORD dwSetValue = m_CurrentState.m_ColorWriteEnable;
if ( m_CurrentState.m_bOverrideColorWriteEnable )
{
if( m_CurrentState.m_bOverriddenColorWriteValue )
{
dwSetValue |= (D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
}
else
{
dwSetValue &= ~(D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
}
}
else
{
if ( CurrentShadowState() )
{
//probably being paranoid, but only copy the alpha flag from the shadow state
dwSetValue &= ~(D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
dwSetValue |= CurrentShadowState()->m_ColorWriteEnable & (D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
}
}
if( dwSetValue != m_CurrentState.m_ColorWriteEnable )
{
m_CurrentState.m_ColorWriteEnable = dwSetValue;
SetRenderState( D3DRS_COLORWRITEENABLE, m_CurrentState.m_ColorWriteEnable );
}
}
}
void CTransitionTable::EnableLinearColorSpaceFrameBuffer( bool bEnable )
{
if ( m_CurrentState.m_bLinearColorSpaceFrameBufferEnable != bEnable && CurrentShadowState() )
{
ShaderAPI()->FlushBufferedPrimitives();
m_CurrentState.m_bLinearColorSpaceFrameBufferEnable = bEnable;
ApplySRGBWriteEnable( *CurrentShadowState() );
}
}
//-----------------------------------------------------------------------------
// Perform state block overrides
//-----------------------------------------------------------------------------
void CTransitionTable::PerformShadowStateOverrides( )
{
VPROF("CTransitionTable::PerformShadowStateOverrides");
// Deal with funky overrides here, because the state blocks can't...
if ( m_CurrentState.m_ForceDepthFuncEquals )
{
SetZFunc( D3DCMP_EQUAL );
}
if ( m_CurrentState.m_bOverrideDepthEnable )
{
SetZEnable( D3DZB_TRUE );
SetRenderStateConstMacro( D3DRS_ZWRITEENABLE, m_CurrentState.m_OverrideZWriteEnable );
#if defined( _X360 )
//SetRenderStateConstMacro( D3DRS_HIZWRITEENABLE, m_CurrentState.m_OverrideZWriteEnable ? D3DHIZ_AUTOMATIC : D3DHIZ_DISABLE );
#endif
}
if ( m_CurrentState.m_bOverrideAlphaWriteEnable )
{
DWORD dwSetValue = m_CurrentState.m_ColorWriteEnable & ~D3DCOLORWRITEENABLE_ALPHA;
dwSetValue |= m_CurrentState.m_bOverriddenAlphaWriteValue ? D3DCOLORWRITEENABLE_ALPHA : 0;
if ( dwSetValue != m_CurrentState.m_ColorWriteEnable )
{
m_CurrentState.m_ColorWriteEnable = dwSetValue;
SetRenderState( D3DRS_COLORWRITEENABLE, m_CurrentState.m_ColorWriteEnable );
}
}
if ( m_CurrentState.m_bOverrideColorWriteEnable )
{
DWORD dwSetValue = m_CurrentState.m_ColorWriteEnable & ~(D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
dwSetValue |= m_CurrentState.m_bOverriddenColorWriteValue ? (D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE) : 0;
if ( dwSetValue != m_CurrentState.m_ColorWriteEnable )
{
m_CurrentState.m_ColorWriteEnable = dwSetValue;
SetRenderState( D3DRS_COLORWRITEENABLE, m_CurrentState.m_ColorWriteEnable );
}
}
}