mirror of
https://github.com/celisej567/cool-source-archive.git
synced 2026-09-15 20:09:19 +03:00
608 lines
19 KiB
C++
608 lines
19 KiB
C++
//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//===========================================================================//
|
|
|
|
// HUH???
|
|
#define RAD_TELEMETRY_DISABLED
|
|
|
|
#include "shadershadowdx11.h"
|
|
#include "utlvector.h"
|
|
#include "materialsystem/imaterialsystem.h"
|
|
#include "IHardwareConfigInternal.h"
|
|
//#include "shadersystem.h"
|
|
//#include "shaderapi/ishaderutil.h"
|
|
#include "shaderapidx11_global.h"
|
|
#include "materialsystem/imesh.h"
|
|
#include "tier0/dbg.h"
|
|
#include "materialsystem/idebugtextureinfo.h"
|
|
#include "vertexshaderdx11.h"
|
|
|
|
#include "shaderapidx11.h"
|
|
#include "shaderdevicedx11.h"
|
|
#include "meshdx11.h"
|
|
|
|
// NOTE: This has to be the last file included!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Class Factory
|
|
//-----------------------------------------------------------------------------
|
|
static CShaderShadowDx11 s_ShaderShadow;
|
|
CShaderShadowDx11 *g_pShaderShadowDx11 = &s_ShaderShadow;
|
|
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderShadowDx11, IShaderShadow,
|
|
SHADERSHADOW_INTERFACE_VERSION, s_ShaderShadow )
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The shader shadow interface
|
|
//-----------------------------------------------------------------------------
|
|
CShaderShadowDx11::CShaderShadowDx11()
|
|
{
|
|
// Setup default shadow states
|
|
|
|
m_DefaultShadowState.desc.SetDefault();
|
|
|
|
m_DefaultCBState.SetDefault();
|
|
unsigned int iDefaultCB = FindOrCreateConstantBufferState( m_DefaultCBState );
|
|
m_DefaultShadowState.m_iGSConstantBufferState = iDefaultCB;
|
|
m_DefaultShadowState.m_iPSConstantBufferState = iDefaultCB;
|
|
m_DefaultShadowState.m_iVSConstantBufferState = iDefaultCB;
|
|
|
|
m_DefaultDepthStencilState.SetDefault();
|
|
m_DefaultRasterState.SetDefault();
|
|
m_DefaultBlendState.SetDefault();
|
|
}
|
|
|
|
CShaderShadowDx11::~CShaderShadowDx11()
|
|
{
|
|
}
|
|
|
|
// Sets the default *shadow* state
|
|
void CShaderShadowDx11::SetDefaultState()
|
|
{
|
|
m_ShadowState = StatesDx11::ShadowStateDesc();
|
|
m_ShadowState.SetDefault();
|
|
}
|
|
|
|
// Methods related to depth buffering
|
|
void CShaderShadowDx11::DepthFunc( ShaderDepthFunc_t depthFunc )
|
|
{
|
|
m_ShadowState.depthStencil.DepthFunc = (D3D11_COMPARISON_FUNC)depthFunc;
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableDepthWrites( bool bEnable )
|
|
{
|
|
m_ShadowState.depthStencil.DepthWriteMask = bEnable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableDepthTest( bool bEnable )
|
|
{
|
|
m_ShadowState.depthStencil.DepthEnable = bEnable;
|
|
}
|
|
|
|
void CShaderShadowDx11::EnablePolyOffset( PolygonOffsetMode_t nOffsetMode )
|
|
{
|
|
//m_ShadowState.rasterizer.DepthBias =
|
|
}
|
|
|
|
// Suppresses/activates color writing
|
|
void CShaderShadowDx11::EnableColorWrites( bool bEnable )
|
|
{
|
|
if ( bEnable )
|
|
{
|
|
m_ShadowState.blend.RenderTarget[0].RenderTargetWriteMask |=
|
|
D3D11_COLOR_WRITE_ENABLE_RED | D3D11_COLOR_WRITE_ENABLE_GREEN |
|
|
D3D11_COLOR_WRITE_ENABLE_BLUE;
|
|
}
|
|
else
|
|
{
|
|
m_ShadowState.blend.RenderTarget[0].RenderTargetWriteMask &=
|
|
~( D3D11_COLOR_WRITE_ENABLE_RED | D3D11_COLOR_WRITE_ENABLE_GREEN |
|
|
D3D11_COLOR_WRITE_ENABLE_BLUE );
|
|
}
|
|
|
|
}
|
|
|
|
// Suppresses/activates alpha writing
|
|
void CShaderShadowDx11::EnableAlphaWrites( bool bEnable )
|
|
{
|
|
if ( bEnable )
|
|
{
|
|
m_ShadowState.blend.RenderTarget[0].RenderTargetWriteMask |= D3D11_COLOR_WRITE_ENABLE_ALPHA;
|
|
}
|
|
else
|
|
{
|
|
m_ShadowState.blend.RenderTarget[0].RenderTargetWriteMask &= ~D3D11_COLOR_WRITE_ENABLE_ALPHA;
|
|
}
|
|
}
|
|
|
|
// Methods related to alpha blending
|
|
void CShaderShadowDx11::EnableBlending( bool bEnable )
|
|
{
|
|
m_ShadowState.blend.RenderTarget[0].BlendEnable = bEnable ? TRUE : FALSE;
|
|
}
|
|
|
|
void CShaderShadowDx11::BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
|
|
{
|
|
m_ShadowState.blend.RenderTarget[0].SrcBlend = TranslateD3D11BlendFunc( srcFactor );
|
|
m_ShadowState.blend.RenderTarget[0].DestBlend = TranslateD3D11BlendFunc( dstFactor );
|
|
}
|
|
|
|
// Alpha testing
|
|
// NOTE: Unused since alpha testing is no longer fixed-function in DX11.
|
|
// Just set an ALPHA_TEST combo in your shader and provide the
|
|
// reference value as a constant.
|
|
//
|
|
void CShaderShadowDx11::EnableAlphaTest( bool bEnable )
|
|
{
|
|
//m_ShadowState.bEnableAlphaTest = bEnable;
|
|
}
|
|
|
|
void CShaderShadowDx11::AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ )
|
|
{
|
|
//m_ShadowState.alphaTestFunc = alphaFunc;
|
|
//m_ShadowState.alphaTestRef = alphaRef;
|
|
}
|
|
|
|
// Wireframe/filled polygons
|
|
void CShaderShadowDx11::PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode )
|
|
{
|
|
D3D11_FILL_MODE mode;
|
|
switch ( polyMode )
|
|
{
|
|
case SHADER_POLYMODE_FILL:
|
|
mode = D3D11_FILL_SOLID;
|
|
break;
|
|
case SHADER_POLYMODE_LINE:
|
|
case SHADER_POLYMODE_POINT:
|
|
default:
|
|
mode = D3D11_FILL_WIREFRAME;
|
|
break;
|
|
}
|
|
m_ShadowState.rasterizer.FillMode = mode;
|
|
//m_ShadowState.rasterizer.CullMode =
|
|
//m_ShadowState.renderModeAttrib.polyMode = polyMode;
|
|
// m_ShadowState.renderModeAttrib.faceMode = face;
|
|
}
|
|
|
|
|
|
// Back face culling
|
|
void CShaderShadowDx11::EnableCulling( bool bEnable )
|
|
{
|
|
// DX11FIXME
|
|
//m_ShadowState.cullFaceAttrib.bEnable = bEnable;
|
|
m_ShadowState.rasterizer.CullMode = bEnable ? D3D11_CULL_BACK : D3D11_CULL_NONE;
|
|
//m_ShadowState.cullFaceAttrib.cullMode = MATERIAL_CULLMODE_CCW;
|
|
}
|
|
|
|
// constant color + transparency
|
|
void CShaderShadowDx11::EnableConstantColor( bool bEnable )
|
|
{
|
|
//m_ShadowState.bConstantColor = bEnable;
|
|
}
|
|
|
|
|
|
// Indicates the vertex format for use with a vertex shader
|
|
// The flags to pass in here come from the VertexFormatFlags_t enum
|
|
// If pTexCoordDimensions is *not* specified, we assume all coordinates
|
|
// are 2-dimensional
|
|
void CShaderShadowDx11::VertexShaderVertexFormat( unsigned int flags,
|
|
int numTexCoords, int* pTexCoordDimensions,
|
|
int userDataSize )
|
|
{
|
|
// Code that creates a Mesh should specify whether it contains bone weights+indices, *not* the shader.
|
|
Assert( ( flags & VERTEX_BONE_INDEX ) == 0 );
|
|
flags &= ~VERTEX_BONE_INDEX;
|
|
|
|
// This indicates we're using a vertex shader
|
|
flags |= VERTEX_FORMAT_VERTEX_SHADER;
|
|
m_ShadowState.vertexFormat = MeshMgr()->ComputeVertexFormat( flags, numTexCoords,
|
|
pTexCoordDimensions, 0, userDataSize );
|
|
// Avoid an error if vertex stream 0 is too narrow
|
|
if ( CVertexBufferBase::VertexFormatSize( m_ShadowState.vertexFormat ) <= 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( flags & VERTEX_POSITION );
|
|
flags |= VERTEX_POSITION;
|
|
// This error should occur only if we have zero texcoords, or if we have a single, 1-D texcoord
|
|
Assert( ( userDataSize == 0 ) ||
|
|
( ( userDataSize == 1 ) && pTexCoordDimensions && ( pTexCoordDimensions[0] == 1 ) ) );
|
|
numTexCoords = 1;
|
|
m_ShadowState.vertexFormat = MeshMgr()->ComputeVertexFormat(
|
|
flags, numTexCoords, NULL, 0, userDataSize );
|
|
}
|
|
}
|
|
|
|
// Indicates we're going to light the model
|
|
void CShaderShadowDx11::EnableLighting( bool bEnable )
|
|
{
|
|
//m_ShadowState.bLighting = bEnable;
|
|
}
|
|
|
|
// Activate/deactivate skinning
|
|
void CShaderShadowDx11::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 ( ( HardwareConfig()->MaxBlendMatrices() > 0 ) || ( !bEnable ) )
|
|
//{
|
|
//m_ShadowState.bVertexBlend = bEnable;
|
|
//}
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableTexture( Sampler_t sampler, bool bEnable )
|
|
{
|
|
//if ( sampler < HardwareConfig()->GetSamplerCount() )
|
|
//{
|
|
// m_ShadowState.samplerAttrib.EnableTexture( sampler, bEnable );
|
|
//}
|
|
//else
|
|
//{
|
|
// Warning( "Attempting to bind a texture to an invalid sampler (%d)!\n", sampler );
|
|
//}
|
|
}
|
|
|
|
// Sets the vertex and pixel shaders
|
|
void CShaderShadowDx11::SetVertexShader( const char *pShaderName, ShaderIndex_t vshIndex )
|
|
{
|
|
m_ShadowState.vertexShader = ShaderManager()->CreateVertexShader( pShaderName, vshIndex );
|
|
m_ShadowState.staticVertexShaderIndex = vshIndex;
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableBlendingSeparateAlpha( bool bEnable )
|
|
{
|
|
// DX11FIXME
|
|
//m_ShadowState.m_SeparateAlphaBlendEnable = bEnable;
|
|
//m_ShadowState.colorBlendAttrib.bIndependentAlphaBlend = bEnable;
|
|
}
|
|
|
|
void CShaderShadowDx11::SetPixelShader( const char *pShaderName, ShaderIndex_t pshIndex )
|
|
{
|
|
m_ShadowState.pixelShader = ShaderManager()->CreatePixelShader( pShaderName, pshIndex );
|
|
m_ShadowState.staticPixelShaderIndex = pshIndex;
|
|
}
|
|
|
|
void CShaderShadowDx11::SetMorphFormat( MorphFormat_t flags )
|
|
{
|
|
m_ShadowState.morphFormat = flags;
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableStencil( bool bEnable )
|
|
{
|
|
m_ShadowState.depthStencil.StencilEnable = bEnable;
|
|
}
|
|
|
|
void CShaderShadowDx11::StencilFunc( ShaderStencilFunc_t stencilFunc )
|
|
{
|
|
m_ShadowState.depthStencil.FrontFace.StencilFunc = (D3D11_COMPARISON_FUNC)stencilFunc;
|
|
}
|
|
|
|
void CShaderShadowDx11::StencilPassOp( ShaderStencilOp_t stencilOp )
|
|
{
|
|
m_ShadowState.depthStencil.FrontFace.StencilPassOp = (D3D11_STENCIL_OP)stencilOp;
|
|
}
|
|
|
|
void CShaderShadowDx11::StencilFailOp( ShaderStencilOp_t stencilOp )
|
|
{
|
|
m_ShadowState.depthStencil.FrontFace.StencilFailOp = (D3D11_STENCIL_OP)stencilOp;
|
|
}
|
|
|
|
void CShaderShadowDx11::StencilDepthFailOp( ShaderStencilOp_t stencilOp )
|
|
{
|
|
m_ShadowState.depthStencil.FrontFace.StencilDepthFailOp = (D3D11_STENCIL_OP)stencilOp;
|
|
}
|
|
|
|
void CShaderShadowDx11::StencilReference( int nReference )
|
|
{
|
|
m_ShadowState.depthStencil.StencilRef = nReference;
|
|
}
|
|
|
|
void CShaderShadowDx11::StencilMask( int nMask )
|
|
{
|
|
m_ShadowState.depthStencil.StencilWriteMask = nMask;
|
|
}
|
|
|
|
void CShaderShadowDx11::StencilWriteMask( int nMask )
|
|
{
|
|
m_ShadowState.depthStencil.StencilReadMask = nMask;
|
|
}
|
|
|
|
void CShaderShadowDx11::BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
|
|
{
|
|
//m_ShadowState.colorBlendAttrib.bIndependentAlphaBlend = true;
|
|
m_ShadowState.blend.RenderTarget[0].SrcBlendAlpha = TranslateD3D11BlendFunc( srcFactor );
|
|
m_ShadowState.blend.RenderTarget[0].DestBlendAlpha = TranslateD3D11BlendFunc( dstFactor );
|
|
}
|
|
|
|
// Alpha to coverage
|
|
void CShaderShadowDx11::EnableAlphaToCoverage( bool bEnable )
|
|
{
|
|
m_ShadowState.blend.AlphaToCoverageEnable = bEnable ? TRUE : FALSE;
|
|
}
|
|
|
|
void CShaderShadowDx11::FogMode( ShaderFogMode_t fogMode )
|
|
{
|
|
m_ShadowState.fogMode = fogMode;
|
|
}
|
|
|
|
|
|
StateSnapshot_t CShaderShadowDx11::FindOrCreateSnapshot()
|
|
{
|
|
StatesDx11::ShadowState lookup;
|
|
lookup.desc = m_ShadowState;
|
|
int i = m_ShadowStates.Find( lookup );
|
|
if ( i != m_ShadowStates.InvalidIndex() )
|
|
{
|
|
return i;
|
|
}
|
|
|
|
// Didn't find it, add entry
|
|
|
|
lookup.m_iBlendState = FindOrCreateBlendState( lookup.desc.blend );
|
|
lookup.m_iDepthStencilState = FindOrCreateDepthStencilState( lookup.desc.depthStencil );
|
|
lookup.m_iRasterState = FindOrCreateRasterState( lookup.desc.rasterizer );
|
|
lookup.m_iVSConstantBufferState = FindOrCreateConstantBufferState( lookup.desc.vsConstantBuffers );
|
|
lookup.m_iGSConstantBufferState = FindOrCreateConstantBufferState( lookup.desc.gsConstantBuffers );
|
|
lookup.m_iPSConstantBufferState = FindOrCreateConstantBufferState( lookup.desc.psConstantBuffers );
|
|
|
|
StateSnapshot_t snap = m_ShadowStates.AddToTail( lookup );
|
|
return snap;
|
|
}
|
|
|
|
const StatesDx11::ShadowState *CShaderShadowDx11::GetShadowState( StateSnapshot_t id )
|
|
{
|
|
if ( id == DEFAULT_SHADOW_STATE_ID )
|
|
return GetDefaultShadowState();
|
|
|
|
return &m_ShadowStates.Element( id );
|
|
}
|
|
|
|
const StatesDx11::ShadowState *CShaderShadowDx11::GetDefaultShadowState()
|
|
{
|
|
if ( !m_DefaultShadowState.desc.blend.m_pD3DState )
|
|
{
|
|
// Needed to wait until this was called to create the D3D state objects because
|
|
// D3D is not initialized when the constructor of this class is called.
|
|
|
|
m_DefaultDepthStencilState.SetDefault();
|
|
unsigned int iDefaultDS = FindOrCreateDepthStencilState( m_DefaultDepthStencilState );
|
|
m_DefaultShadowState.desc.depthStencil = m_DefaultDepthStencilState;
|
|
m_DefaultShadowState.m_iDepthStencilState = iDefaultDS;
|
|
|
|
m_DefaultRasterState.SetDefault();
|
|
unsigned int iDefaultRS = FindOrCreateRasterState( m_DefaultRasterState );
|
|
m_DefaultShadowState.desc.rasterizer = m_DefaultRasterState;
|
|
m_DefaultShadowState.m_iRasterState = iDefaultRS;
|
|
|
|
m_DefaultBlendState.SetDefault();
|
|
unsigned int iDefaultBS = FindOrCreateBlendState( m_DefaultBlendState );
|
|
m_DefaultShadowState.desc.blend = m_DefaultBlendState;
|
|
m_DefaultShadowState.m_iBlendState = iDefaultBS;
|
|
}
|
|
|
|
return &m_DefaultShadowState;
|
|
}
|
|
|
|
// Constant buffer setting
|
|
|
|
void CShaderShadowDx11::SetVertexShaderConstantBuffer( int slot, ConstantBufferHandle_t cbuffer )
|
|
{
|
|
m_ShadowState.vsConstantBuffers.m_ppBuffers[slot] = ( (CShaderConstantBufferDx11 *)cbuffer )->GetD3DBuffer();
|
|
if ( slot > m_ShadowState.vsConstantBuffers.m_MaxSlot )
|
|
{
|
|
m_ShadowState.vsConstantBuffers.m_MaxSlot = slot;
|
|
}
|
|
}
|
|
|
|
void CShaderShadowDx11::SetVertexShaderConstantBuffer( int slot, ShaderInternalConstantBuffer_t cbuffer )
|
|
{
|
|
SetVertexShaderConstantBuffer( slot, g_pShaderAPIDx11->GetInternalConstantBuffer( cbuffer ) );
|
|
}
|
|
|
|
void CShaderShadowDx11::SetGeometryShaderConstantBuffer( int slot, ConstantBufferHandle_t cbuffer )
|
|
{
|
|
m_ShadowState.gsConstantBuffers.m_ppBuffers[slot] = ( (CShaderConstantBufferDx11 *)cbuffer )->GetD3DBuffer();
|
|
if ( slot > m_ShadowState.gsConstantBuffers.m_MaxSlot )
|
|
{
|
|
m_ShadowState.gsConstantBuffers.m_MaxSlot = slot;
|
|
}
|
|
}
|
|
|
|
void CShaderShadowDx11::SetGeometryShaderConstantBuffer( int slot, ShaderInternalConstantBuffer_t cbuffer )
|
|
{
|
|
SetGeometryShaderConstantBuffer( slot, g_pShaderAPIDx11->GetInternalConstantBuffer( cbuffer ) );
|
|
}
|
|
|
|
void CShaderShadowDx11::SetPixelShaderConstantBuffer( int slot, ConstantBufferHandle_t cbuffer )
|
|
{
|
|
m_ShadowState.psConstantBuffers.m_ppBuffers[slot] = ( (CShaderConstantBufferDx11 *)cbuffer )->GetD3DBuffer();
|
|
if ( slot > m_ShadowState.psConstantBuffers.m_MaxSlot )
|
|
{
|
|
m_ShadowState.psConstantBuffers.m_MaxSlot = slot;
|
|
}
|
|
}
|
|
|
|
void CShaderShadowDx11::SetPixelShaderConstantBuffer( int slot, ShaderInternalConstantBuffer_t cbuffer )
|
|
{
|
|
SetPixelShaderConstantBuffer( slot, g_pShaderAPIDx11->GetInternalConstantBuffer( cbuffer ) );
|
|
}
|
|
|
|
unsigned int CShaderShadowDx11::FindOrCreateConstantBufferState( StatesDx11::ConstantBufferDesc &desc )
|
|
{
|
|
int i = m_ConstantBufferStates.Find( desc );
|
|
if ( m_ConstantBufferStates.IsValidIndex( i ) )
|
|
{
|
|
return i;
|
|
}
|
|
|
|
// Make a new state
|
|
return m_ConstantBufferStates.AddToTail( desc );
|
|
}
|
|
|
|
unsigned int CShaderShadowDx11::FindOrCreateDepthStencilState( StatesDx11::DepthStencilDesc &desc )
|
|
{
|
|
int i = m_DepthStencilStates.Find( desc );
|
|
if ( m_DepthStencilStates.IsValidIndex( i ) )
|
|
{
|
|
desc.m_pD3DState = m_DepthStencilStates[i].m_pD3DState;
|
|
return i;
|
|
}
|
|
|
|
D3D11Device()->CreateDepthStencilState( &desc, &desc.m_pD3DState );
|
|
Assert( SUCCEEDED( hr ) );
|
|
|
|
i = m_DepthStencilStates.AddToTail( desc );
|
|
return i;
|
|
}
|
|
|
|
unsigned int CShaderShadowDx11::FindOrCreateBlendState( StatesDx11::BlendDesc &desc )
|
|
{
|
|
int i = m_BlendStates.Find( desc );
|
|
if ( m_BlendStates.IsValidIndex( i ) )
|
|
{
|
|
desc.m_pD3DState = m_BlendStates[i].m_pD3DState;
|
|
return i;
|
|
}
|
|
|
|
D3D11Device()->CreateBlendState( &desc, &desc.m_pD3DState );
|
|
Assert( SUCCEEDED( hr ) );
|
|
|
|
i = m_BlendStates.AddToTail( desc );
|
|
return i;
|
|
}
|
|
|
|
unsigned int CShaderShadowDx11::FindOrCreateRasterState( StatesDx11::RasterDesc &desc )
|
|
{
|
|
int i = m_RasterizerStates.Find( desc );
|
|
if ( m_RasterizerStates.IsValidIndex( i ) )
|
|
{
|
|
desc.m_pD3DState = m_RasterizerStates[i].m_pD3DState;
|
|
return i;
|
|
}
|
|
|
|
D3D11Device()->CreateRasterizerState( &desc, &desc.m_pD3DState );
|
|
Assert( SUCCEEDED( hr ) );
|
|
|
|
i = m_RasterizerStates.AddToTail( desc );
|
|
return i;
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
// Below are unsupported by Dx11, only included to
|
|
// not break compatibility with Dx9.
|
|
// ---------------------------------------------------
|
|
|
|
// A simpler method of dealing with alpha modulation
|
|
void CShaderShadowDx11::EnableAlphaPipe( bool bEnable )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::EnableAlphaPipe() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableConstantAlpha( bool bEnable )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::EnableConstantAlpha() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableVertexAlpha( bool bEnable )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::EnableVertexAlpha() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableTextureAlpha( TextureStage_t stage, bool bEnable )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::EnableTextureAlpha() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::SetShadowDepthFiltering( Sampler_t stage )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::SetShadowDepthFiltering() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableCustomPixelPipe( bool bEnable )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::EnableCustomPixelPipe() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::CustomTextureStages( int stageCount )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::CustomTextureStages() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::CustomTextureOperation( TextureStage_t stage, ShaderTexChannel_t channel,
|
|
ShaderTexOp_t op, ShaderTexArg_t arg1, ShaderTexArg_t arg2 )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::CustomTextureOperation() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableSRGBWrite( bool bEnable )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::EnableSRGBWrite() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableSRGBRead( Sampler_t stage, bool bEnable )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::EnableSRGBRead() called\n" );
|
|
}
|
|
void CShaderShadowDx11::SetDiffuseMaterialSource( ShaderMaterialSource_t materialSource )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::SetDiffuseMaterialSource() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableTexGen( TextureStage_t stage, bool bEnable )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::EnableTexGen() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::TexGen( TextureStage_t stage, ShaderTexGenParam_t param )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::TexGen() called\n" );
|
|
}
|
|
|
|
// per texture unit stuff
|
|
void CShaderShadowDx11::OverbrightValue( TextureStage_t stage, float value )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::OverbrightValue() called\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::DisableFogGammaCorrection( bool bDisable )
|
|
{
|
|
m_ShadowState.disableFogGammaCorrection = bDisable;
|
|
}
|
|
|
|
void CShaderShadowDx11::EnableSpecular( bool bEnable )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::EnableSpecular() called!\n" );
|
|
}
|
|
|
|
// indicates what per-vertex data we're providing
|
|
void CShaderShadowDx11::DrawFlags( unsigned int drawFlags )
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::DrawFlags() called!\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::BlendOp(ShaderBlendOp_t blendOp)
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::BlendOp() called!\n" );
|
|
}
|
|
|
|
void CShaderShadowDx11::BlendOpSeparateAlpha(ShaderBlendOp_t blendOp)
|
|
{
|
|
//Warning( "Unsupported CShaderShadowDx11::BlendOpSeparateAlpha() called!\n" );
|
|
}
|