void CBaseShader::DrawElements( IMaterialVar **ppParams, int nModulationFlags,
IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CBasePerMaterialContextData **pContextDataPtr, CBasePerInstanceContextData** pInstanceDataPtr )
{
VPROF("CBaseShader::DrawElements");
// Re-entrancy check
Assert( !s_ppParams );
s_ppParams = ppParams;
s_pShaderAPI = pShaderAPI;
s_pShaderShadow = pShaderShadow;
s_nModulationFlags = nModulationFlags;
s_pInstanceDataPtr = (CPerInstanceContextData**)( pInstanceDataPtr );
s_nPassCount = 0;
if ( IsSnapshotting() )
{
// Set up the shadow state
SetInitialShadowState( );
}
OnDrawElements( ppParams, pShaderShadow, pShaderAPI, vertexCompression, pContextDataPtr );
s_pInstanceDataPtr = NULL;
s_nPassCount = 0;
s_nModulationFlags = 0;
s_ppParams = NULL;
s_pShaderAPI = NULL;
s_pShaderShadow = NULL;
}
void CBaseShader::DrawElements( IMaterialVar **ppParams, int nModulationFlags,
IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI )
{
// Re-entrancy check
Assert( !s_ppParams );
s_ppParams = ppParams;
s_pShaderAPI = pShaderAPI;
s_pShaderShadow = pShaderShadow;
s_nModulationFlags = nModulationFlags;
s_pMeshBuilder = pShaderAPI ? pShaderAPI->GetVertexModifyBuilder() : NULL;
if ( IsSnapshotting() )
{
// Set up the shadow state
SetInitialShadowState( );
}
OnDrawElements( ppParams, pShaderShadow, pShaderAPI );
s_nModulationFlags = 0;
s_ppParams = NULL;
s_pShaderAPI = NULL;
s_pShaderShadow = NULL;
s_pMeshBuilder = NULL;
}
//-----------------------------------------------------------------------------
// Fixed function Self illumination pass
//-----------------------------------------------------------------------------
void CBaseShader::FixedFunctionSelfIlluminationPass( TextureStage_t stage,
int baseTextureVar, int frameVar, int baseTextureTransformVar, int selfIllumTintVar )
{
// IMaterialVar** params = s_ppParams;
if (IsSnapshotting())
{
SetInitialShadowState();
// A little setup for self illum here...
SetModulationShadowState( selfIllumTintVar );
s_pShaderShadow->EnableTexture( stage, true );
// No overbrighting
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE0, 1.0f );
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE1, 1.0f );
// Don't bother with z writes here...
s_pShaderShadow->EnableDepthWrites( false );
// We're always blending
EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
int flags = SHADER_DRAW_POSITION;
if (stage == SHADER_TEXTURE_STAGE0)
flags |= SHADER_DRAW_TEXCOORD0;
else
flags |= SHADER_DRAW_TEXCOORD1;
s_pShaderShadow->DrawFlags( flags );
FogToFogColor();
}
else
{
s_pShaderAPI->SetDefaultState();
SetFixedFunctionTextureTransform(
(stage == SHADER_TEXTURE_STAGE0) ? MATERIAL_TEXTURE0 : MATERIAL_TEXTURE1,
baseTextureTransformVar );
BindTexture( stage, baseTextureVar, frameVar );
// NOTE: Texture + texture offset are set from BaseTimesLightmap
SetModulationDynamicState( selfIllumTintVar );
}
Draw();
}
//-----------------------------------------------------------------------------
// Add masked environment map
//-----------------------------------------------------------------------------
void CBaseShader::FixedFunctionAdditiveMaskedEnvmapPass( int envMapVar, int envMapMaskVar,
int baseTextureVar, int envMapFrameVar, int envMapMaskFrameVar,
int frameVar, int maskOffsetVar, int maskScaleVar, int envMapTintVar )
{
// IMaterialVar** params = ShaderState().m_ppParams;
if (IsSnapshotting())
{
SetInitialShadowState();
// Alpha blending
SetAdditiveBlendingShadowState( envMapMaskVar, false );
// Disable overbright
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE0, 1.0f );
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE1, 1.0f );
// Don't bother with z writes here...
s_pShaderShadow->EnableDepthWrites( false );
int flags = SetShadowEnvMappingState( envMapMaskVar, envMapTintVar );
s_pShaderShadow->DrawFlags( flags );
FogToBlack();
Draw();
s_pShaderShadow->EnableCustomPixelPipe( false );
s_pShaderShadow->EnableAlphaPipe( false );
}
else
{
SetDynamicEnvMappingState( envMapVar, envMapMaskVar, baseTextureVar,
envMapFrameVar, envMapMaskFrameVar, frameVar,
maskOffsetVar, maskScaleVar, envMapTintVar );
Draw();
}
}
inline void DrawPass( IMaterialVar **params, IShaderShadow* pShaderShadow,
IShaderDynamicAPI* pShaderAPI, int nPass, VertexCompressionType_t vertexCompression )
{
bool bIsModel = IS_FLAG_SET( MATERIAL_VAR_MODEL );
bool bHasEnvmap = params[ENVMAP]->IsTexture();
bool bHasFlowmap = params[FLOWMAP]->IsTexture();
bool bHasCoreColorTexture = params[CORECOLORTEXTURE]->IsTexture();
SHADOW_STATE
{
SetInitialShadowState( );
if( nPass == 0 )
{
// Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
}
else
{
pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL );
EnableAlphaBlending( SHADER_BLEND_ONE, SHADER_BLEND_ONE );
}
// If envmap is not specified, the alpha channel is the translucency
// (If envmap *is* specified, alpha channel is the reflection amount)
if ( params[NORMALMAP]->IsTexture() && !bHasEnvmap )
{
SetDefaultBlendingShadowState( NORMALMAP, false );
}
// source render target that contains the image that we are warping.
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
}
// normal map
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
if( bHasEnvmap )
{
// envmap
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
}
}
if( bHasFlowmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
}
if( bHasCoreColorTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
}
if( g_pHardwareConfig->GetHDRType() != HDR_TYPE_NONE )
{
pShaderShadow->EnableSRGBWrite( true );
}
unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
int userDataSize = 0;
int nTexCoordCount = 1;
if( bIsModel )
{
userDataSize = 4;
}
else
{
flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T;
}
// This shader supports compressed vertices, so OR in that flag:
flags |= VERTEX_FORMAT_COMPRESSED;
pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, NULL, userDataSize );
DECLARE_STATIC_VERTEX_SHADER( sdk_core_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bIsModel );
SET_STATIC_VERTEX_SHADER( sdk_core_vs20 );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER( sdk_core_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap && ( nPass == 1 ) );
SET_STATIC_PIXEL_SHADER_COMBO( FLOWMAP, bHasFlowmap );
SET_STATIC_PIXEL_SHADER_COMBO( CORECOLORTEXTURE, bHasCoreColorTexture && ( nPass == 0 ) );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, nPass == 0 );
SET_STATIC_PIXEL_SHADER( sdk_core_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( sdk_core_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap && ( nPass == 1 ) );
SET_STATIC_PIXEL_SHADER_COMBO( FLOWMAP, bHasFlowmap );
SET_STATIC_PIXEL_SHADER_COMBO( CORECOLORTEXTURE, bHasCoreColorTexture && ( nPass == 0 ) );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, nPass == 0 );
SET_STATIC_PIXEL_SHADER( sdk_core_ps20 );
}
DefaultFog();
}
DYNAMIC_STATE
{
pShaderAPI->SetDefaultState();
if ( params[BASETEXTURE]->IsTexture() )
{
BindTexture( SHADER_SAMPLER2, BASETEXTURE, FRAME );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_FRAME_BUFFER_FULL_TEXTURE_0 );
}
BindTexture( SHADER_SAMPLER3, NORMALMAP, BUMPFRAME );
if( bHasEnvmap )
{
BindTexture( SHADER_SAMPLER4, ENVMAP, ENVMAPFRAME );
}
if( bHasFlowmap )
{
BindTexture( SHADER_SAMPLER6, FLOWMAP, FLOWMAPFRAME );
}
if( bHasCoreColorTexture )
{
BindTexture( SHADER_SAMPLER7, CORECOLORTEXTURE, CORECOLORTEXTUREFRAME );
}
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_core_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( sdk_core_vs20 );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_core_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( sdk_core_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_core_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( sdk_core_ps20 );
}
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, BUMPTRANSFORM );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
{
SetPixelShaderConstant( 0, ENVMAPTINT );
SetPixelShaderConstant( 1, REFRACTTINT );
}
else
{
SetPixelShaderConstantGammaToLinear( 0, ENVMAPTINT );
SetPixelShaderConstantGammaToLinear( 1, REFRACTTINT );
}
SetPixelShaderConstant( 2, ENVMAPCONTRAST );
SetPixelShaderConstant( 3, ENVMAPSATURATION );
float c5[4] = { params[REFRACTAMOUNT]->GetFloatValue(),
params[REFRACTAMOUNT]->GetFloatValue(), 0.0f, 0.0f };
pShaderAPI->SetPixelShaderConstant( 5, c5, 1 );
float eyePos[4];
s_pShaderAPI->GetWorldSpaceCameraPosition( eyePos );
s_pShaderAPI->SetPixelShaderConstant( 8, eyePos, 1 );
pShaderAPI->SetPixelShaderFogParams( 11 );
if( bHasFlowmap )
{
float curTime = pShaderAPI->CurrentTime();
float timeVec[4] = { curTime, curTime, curTime, curTime };
pShaderAPI->SetPixelShaderConstant( 6, timeVec, 1 );
SetPixelShaderConstant( 7, FLOWMAPSCROLLRATE );
SetPixelShaderConstant( 9, FLOWMAPTEXCOORDOFFSET );
}
}
Draw();
}
inline void DrawFlora( IMaterialVar **params, IShaderShadow* pShaderShadow,
IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CBasePerMaterialContextData *pContextDataPtr )
{
const bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0;
const bool bHasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
SHADOW_STATE
{
SetInitialShadowState();
// Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState
pShaderShadow->EnableAlphaTest( bIsAlphaTested );
if ( params[ALPHATESTREFERENCE]->GetFloatValue() > 0.0f )
{
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[ALPHATESTREFERENCE]->GetFloatValue() );
}
DefaultFog();
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); // FOW
pShaderShadow->EnableTexture( SHADER_SAMPLER13, true ); // Deferred light 1
pShaderShadow->EnableTexture( SHADER_SAMPLER14, true ); // Deferred light 2
int iVFmtFlags = VERTEX_POSITION;
int iUserDataSize = 0;
// texcoord0 : base texcoord
int pTexCoordDim[3] = { 2, 2, 3 };
int nTexCoordCount = 1;
// This shader supports compressed vertices, so OR in that flag:
iVFmtFlags |= VERTEX_FORMAT_COMPRESSED;
if ( bHasVertexColor )
{
iVFmtFlags |= VERTEX_COLOR;
}
pShaderShadow->VertexShaderVertexFormat( iVFmtFlags, nTexCoordCount, pTexCoordDim, iUserDataSize );
// The vertex shader uses the vertex id stream
if( g_pHardwareConfig->HasFastVertexTextures() )
{
SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID );
SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_TESSELLATION );
}
// Vertex Shader
DECLARE_STATIC_VERTEX_SHADER( flora_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, bHasVertexColor );
SET_STATIC_VERTEX_SHADER( flora_vs30 );
// Pixel Shader
DECLARE_STATIC_PIXEL_SHADER( flora_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, bHasVertexColor );
SET_STATIC_PIXEL_SHADER( flora_ps30 );
// Textures
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
//pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
// Blending
EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
pShaderShadow->EnableAlphaTest( true );
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GREATER, 0.0f );
}
DYNAMIC_STATE
{
// Reset render state
pShaderAPI->SetDefaultState();
BindTexture( SHADER_SAMPLER0, BASETEXTURE ); // Base Map 1
//if ( bHasFoW )
{
BindTexture( SHADER_SAMPLER10, FOW, -1 );
float vFoWSize[ 4 ];
Vector vMins = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GLOBAL_FOW_MINS );
Vector vMaxs = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GLOBAL_FOW_MAXS );
vFoWSize[ 0 ] = vMins.x;
vFoWSize[ 1 ] = vMins.y;
vFoWSize[ 2 ] = vMaxs.x - vMins.x;
vFoWSize[ 3 ] = vMaxs.y - vMins.y;
pShaderAPI->SetVertexShaderConstant( 26, vFoWSize );
}
BindTexture( SHADER_SAMPLER13, GetDeferredExt()->GetTexture_LightAccum() );
BindTexture( SHADER_SAMPLER14, GetDeferredExt()->GetTexture_LightAccum2() );
int x, y, w, t;
pShaderAPI->GetCurrentViewport( x, y, w, t );
float fl1[4] = { 1.0f / w, 1.0f / t, 0, 0 };
pShaderAPI->SetPixelShaderConstant( 3, fl1 );
// Set Vertex Shader Combos
DECLARE_DYNAMIC_VERTEX_SHADER( flora_vs30 );
SET_DYNAMIC_VERTEX_SHADER( flora_vs30 );
// Set Pixel Shader Combos
DECLARE_DYNAMIC_PIXEL_SHADER( flora_ps30 );
SET_DYNAMIC_PIXEL_SHADER( flora_ps30 );
}
Draw();
}
void CBaseVSShader::DrawFlashlight_dx90( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI,
IShaderShadow* pShaderShadow, DrawFlashlight_dx90_Vars_t &vars )
{
// FLASHLIGHTFIXME: hack . . need to fix the vertex shader so that it can deal with and without bumps for vertexlitgeneric
if( !vars.m_bLightmappedGeneric )
{
vars.m_bBump = false;
}
bool bBump2 = vars.m_bWorldVertexTransition && vars.m_bBump && vars.m_nBumpmap2Var != -1 && params[vars.m_nBumpmap2Var]->IsTexture();
bool bSeamless = vars.m_fSeamlessScale != 0.0;
bool bDetail = vars.m_bLightmappedGeneric && (vars.m_nDetailVar != -1) && params[vars.m_nDetailVar]->IsDefined() && (vars.m_nDetailScale != -1);
int nDetailBlendMode = 0;
if ( bDetail )
{
nDetailBlendMode = GetIntParam( vars.m_nDetailTextureCombineMode, params );
ITexture *pDetailTexture = params[vars.m_nDetailVar]->GetTextureValue();
if ( pDetailTexture->GetFlags() & TEXTUREFLAGS_SSBUMP )
{
if ( vars.m_bBump )
nDetailBlendMode = 10; // ssbump
else
nDetailBlendMode = 11; // ssbump_nobump
}
}
if( pShaderShadow )
{
SetInitialShadowState();
pShaderShadow->EnableDepthWrites( false );
pShaderShadow->EnableAlphaWrites( false );
// Alpha blend
SetAdditiveBlendingShadowState( BASETEXTURE, true );
// Alpha test
pShaderShadow->EnableAlphaTest( IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) );
if ( vars.m_nAlphaTestReference != -1 && params[vars.m_nAlphaTestReference]->GetFloatValue() > 0.0f )
{
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[vars.m_nAlphaTestReference]->GetFloatValue() );
}
// Spot sampler
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
// Base sampler
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );
// Normalizing cubemap sampler
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
// Normalizing cubemap sampler2 or normal map sampler
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
// RandomRotation sampler
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
// Flashlight depth sampler
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER7 );
if( vars.m_bWorldVertexTransition )
{
// $basetexture2
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
}
if( bBump2 )
{
// Normalmap2 sampler
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
}
if( bDetail )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); // detail sampler
if ( nDetailBlendMode == 1 )
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, true );
}
pShaderShadow->EnableSRGBWrite( true );
if( vars.m_bLightmappedGeneric )
{
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( WORLDVERTEXTRANSITION, vars.m_bWorldVertexTransition );
SET_STATIC_VERTEX_SHADER_COMBO( NORMALMAP, vars.m_bBump );
SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamless );
SET_STATIC_VERTEX_SHADER_COMBO( DETAIL, bDetail );
SET_STATIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs30 );
}
else
#endif
{
DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( WORLDVERTEXTRANSITION, vars.m_bWorldVertexTransition );
SET_STATIC_VERTEX_SHADER_COMBO( NORMALMAP, vars.m_bBump );
SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamless );
SET_STATIC_VERTEX_SHADER_COMBO( DETAIL, bDetail );
SET_STATIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs20 );
}
unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
if( vars.m_bBump )
{
flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T;
}
int numTexCoords = 1;
if( vars.m_bWorldVertexTransition )
{
flags |= VERTEX_COLOR;
numTexCoords = 2; // need lightmap texcoords to get alpha.
}
pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, 0 );
}
else
{
// Need a 3.0 vs here?
DECLARE_STATIC_VERTEX_SHADER( vertexlitgeneric_flashlight_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( TEETH, vars.m_bTeeth );
SET_STATIC_VERTEX_SHADER( vertexlitgeneric_flashlight_vs20 );
unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
int numTexCoords = 1;
pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, vars.m_bBump ? 4 : 0 );
}
int nBumpMapVariant = 0;
if ( vars.m_bBump )
{
nBumpMapVariant = ( vars.m_bSSBump ) ? 2 : 1;
}
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
int nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode();
DECLARE_STATIC_PIXEL_SHADER( flashlight_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAP, nBumpMapVariant );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAP2, bBump2 );
SET_STATIC_PIXEL_SHADER_COMBO( WORLDVERTEXTRANSITION, vars.m_bWorldVertexTransition );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamless );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, bDetail );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
SET_STATIC_PIXEL_SHADER( flashlight_ps30 );
}
else
#endif
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
int nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode();
DECLARE_STATIC_PIXEL_SHADER( flashlight_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAP, nBumpMapVariant );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAP2, bBump2 );
SET_STATIC_PIXEL_SHADER_COMBO( WORLDVERTEXTRANSITION, vars.m_bWorldVertexTransition );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamless );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, bDetail );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
SET_STATIC_PIXEL_SHADER( flashlight_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( flashlight_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAP, nBumpMapVariant );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAP2, bBump2 );
SET_STATIC_PIXEL_SHADER_COMBO( WORLDVERTEXTRANSITION, vars.m_bWorldVertexTransition );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamless );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, bDetail );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode );
SET_STATIC_PIXEL_SHADER( flashlight_ps20 );
}
FogToBlack();
PI_BeginCommandBuffer();
PI_SetModulationPixelShaderDynamicState( PSREG_DIFFUSE_MODULATION );
PI_EndCommandBuffer();
}
else
{
VMatrix worldToTexture;
ITexture *pFlashlightDepthTexture;
FlashlightState_t flashlightState = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );
SetFlashLightColorFromState( flashlightState, pShaderAPI, false );
BindTexture( SHADER_SAMPLER0, flashlightState.m_pSpotlightTexture, flashlightState.m_nSpotlightTextureFrame );
pShaderAPI->BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SHADOW_NOISE_2D );
if( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() && flashlightState.m_bEnableShadows )
{
BindTexture( SHADER_SAMPLER7, pFlashlightDepthTexture, 0 );
// Tweaks associated with a given flashlight
float tweaks[4];
tweaks[0] = ShadowFilterFromState( flashlightState );
tweaks[1] = ShadowAttenFromState( flashlightState );
HashShadow2DJitter( flashlightState.m_flShadowJitterSeed, &tweaks[2], &tweaks[3] );
pShaderAPI->SetPixelShaderConstant( PSREG_ENVMAP_TINT__SHADOW_TWEAKS, tweaks, 1 );
// Dimensions of screen, used for screen-space noise map sampling
float vScreenScale[4] = {1280.0f / 32.0f, 720.0f / 32.0f, 0, 0};
int nWidth, nHeight;
pShaderAPI->GetBackBufferDimensions( nWidth, nHeight );
int nTexWidth, nTexHeight;
pShaderAPI->GetStandardTextureDimensions( &nTexWidth, &nTexHeight, TEXTURE_SHADOW_NOISE_2D );
vScreenScale[0] = (float) nWidth / nTexWidth;
vScreenScale[1] = (float) nHeight / nTexHeight;
pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_SCREEN_SCALE, vScreenScale, 1 );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER7, TEXTURE_WHITE );
}
if( params[BASETEXTURE]->IsTexture() && mat_fullbright.GetInt() != 2 )
{
BindTexture( SHADER_SAMPLER1, BASETEXTURE, FRAME );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );
}
if( vars.m_bWorldVertexTransition )
{
Assert( vars.m_nBaseTexture2Var >= 0 && vars.m_nBaseTexture2FrameVar >= 0 );
BindTexture( SHADER_SAMPLER4, vars.m_nBaseTexture2Var, vars.m_nBaseTexture2FrameVar );
}
pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_NORMALIZATION_CUBEMAP );
if( vars.m_bBump )
{
BindTexture( SHADER_SAMPLER3, vars.m_nBumpmapVar, vars.m_nBumpmapFrame );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALIZATION_CUBEMAP );
}
if( bDetail )
{
BindTexture( SHADER_SAMPLER8, vars.m_nDetailVar );
}
if( vars.m_bWorldVertexTransition )
{
if( bBump2 )
{
BindTexture( SHADER_SAMPLER6, vars.m_nBumpmap2Var, vars.m_nBumpmap2Frame );
}
}
if( vars.m_bLightmappedGeneric )
{
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs30 );
SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs30 );
}
else
#endif
{
DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs20 );
SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs20 );
}
if ( bSeamless )
{
float const0[4]={ vars.m_fSeamlessScale,0,0,0};
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, const0 );
}
if ( bDetail )
{
float vDetailConstants[4] = {1,1,1,1};
if ( vars.m_nDetailTint != -1 )
{
params[vars.m_nDetailTint]->GetVecValue( vDetailConstants, 3 );
}
if ( vars.m_nDetailTextureBlendFactor != -1 )
{
vDetailConstants[3] = params[vars.m_nDetailTextureBlendFactor]->GetFloatValue();
}
pShaderAPI->SetPixelShaderConstant( 0, vDetailConstants, 1 );
}
}
else
{
DECLARE_DYNAMIC_VERTEX_SHADER( vertexlitgeneric_flashlight_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER( vertexlitgeneric_flashlight_vs20 );
if( vars.m_bTeeth )
{
Assert( vars.m_nTeethForwardVar >= 0 );
Assert( vars.m_nTeethIllumFactorVar >= 0 );
Vector4D lighting;
params[vars.m_nTeethForwardVar]->GetVecValue( lighting.Base(), 3 );
lighting[3] = params[vars.m_nTeethIllumFactorVar]->GetFloatValue();
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, lighting.Base() );
}
}
pShaderAPI->SetPixelShaderFogParams( PSREG_FOG_PARAMS );
float vEyePos_SpecExponent[4];
pShaderAPI->GetWorldSpaceCameraPosition( vEyePos_SpecExponent );
vEyePos_SpecExponent[3] = 0.0f;
pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vEyePos_SpecExponent, 1 );
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( flashlight_ps30 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, flashlightState.m_bEnableShadows );
SET_DYNAMIC_PIXEL_SHADER_COMBO( UBERLIGHT, flashlightState.m_bUberlight );
SET_DYNAMIC_PIXEL_SHADER( flashlight_ps30 );
SetupUberlightFromState( pShaderAPI, flashlightState );
}
else
#endif
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( flashlight_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, flashlightState.m_bEnableShadows );
SET_DYNAMIC_PIXEL_SHADER( flashlight_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( flashlight_ps20 );
SET_DYNAMIC_PIXEL_SHADER( flashlight_ps20 );
}
float atten[4]; // Set the flashlight attenuation factors
atten[0] = flashlightState.m_fConstantAtten;
atten[1] = flashlightState.m_fLinearAtten;
atten[2] = flashlightState.m_fQuadraticAtten;
atten[3] = flashlightState.m_FarZAtten;
s_pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, atten, 1 );
float pos[4]; // Set the flashlight origin
pos[0] = flashlightState.m_vecLightOrigin[0];
pos[1] = flashlightState.m_vecLightOrigin[1];
pos[2] = flashlightState.m_vecLightOrigin[2];
pos[3] = flashlightState.m_FarZ;
pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_POSITION_RIM_BOOST, pos, 1 ); // rim boost not really used here
SetFlashlightVertexShaderConstants( vars.m_bBump, vars.m_nBumpTransform, bDetail, vars.m_nDetailScale, bSeamless ? false : true );
}
Draw();
}
inline void DrawReflectionRefraction( IMaterialVar **params, IShaderShadow* pShaderShadow,
IShaderDynamicAPI* pShaderAPI, bool bReflection, bool bRefraction )
{
BlendType_t nBlendType = EvaluateBlendRequirements( BASETEXTURE, true );
bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !IS_FLAG_SET(MATERIAL_VAR_ALPHATEST); //dest alpha is free for special use
SHADOW_STATE
{
SetInitialShadowState( );
if( bRefraction )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
}
}
if( bReflection )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
}
}
if( params[BASETEXTURE]->IsTexture() )
{
// BASETEXTURE
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
// LIGHTMAP
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
if ( params[ENVMAPMASK]->IsTexture() )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
}
}
// normal map
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
int fmt = VERTEX_POSITION | VERTEX_NORMAL | VERTEX_TANGENT_S | VERTEX_TANGENT_T;
// texcoord0 : base texcoord
// texcoord1 : lightmap texcoord
// texcoord2 : lightmap texcoord offset
int numTexCoords = 1;
if( params[BASETEXTURE]->IsTexture() )
{
numTexCoords = 3;
}
pShaderShadow->VertexShaderVertexFormat( fmt, numTexCoords, 0, 0 );
if ( IS_FLAG_SET(MATERIAL_VAR_TRANSLUCENT ) )
{
EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
}
DECLARE_STATIC_VERTEX_SHADER( sdk_lightmappedreflective_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( BASETEXTURE, params[BASETEXTURE]->IsTexture() );
SET_STATIC_VERTEX_SHADER( sdk_lightmappedreflective_vs20 );
// "REFLECT" "0..1"
// "REFRACT" "0..1"
if( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( REFLECT, bReflection );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, bRefraction );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, params[BASETEXTURE]->IsTexture() );
SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, params[ENVMAPMASK]->IsTexture() && params[BASETEXTURE]->IsTexture() );
SET_STATIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( REFLECT, bReflection );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, bRefraction );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, params[BASETEXTURE]->IsTexture() );
SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, params[ENVMAPMASK]->IsTexture() && params[BASETEXTURE]->IsTexture() );
SET_STATIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20 );
}
FogToFogColor();
if( g_pHardwareConfig->GetHDRType() != HDR_TYPE_NONE )
{
// we are writing linear values from this shader.
pShaderShadow->EnableSRGBWrite( true );
}
pShaderShadow->EnableAlphaWrites( bFullyOpaque );
}
DYNAMIC_STATE
{
if( bRefraction )
{
// HDRFIXME: add comment about binding.. Specify the number of MRTs in the enable
BindTexture( SHADER_SAMPLER0, REFRACTTEXTURE, -1 );
}
if( bReflection )
{
BindTexture( SHADER_SAMPLER2, REFLECTTEXTURE, -1 );
}
BindTexture( SHADER_SAMPLER4, NORMALMAP, BUMPFRAME );
if( params[BASETEXTURE]->IsTexture() )
{
BindTexture( SHADER_SAMPLER1, BASETEXTURE, FRAME );
pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_LIGHTMAP );
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_3, BASETEXTURETRANSFORM );
if ( params[ENVMAPMASK]->IsTexture() )
{
BindTexture( SHADER_SAMPLER6, ENVMAPMASK, ENVMAPMASKFRAME );
}
}
// Refraction tint
if( bRefraction )
{
SetPixelShaderConstantGammaToLinear( 1, REFRACTTINT );
}
// Reflection tint
if( bReflection )
{
SetPixelShaderConstantGammaToLinear( 4, REFLECTTINT );
}
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, BUMPTRANSFORM );
float c0[4] = { 1.0f / 3.0f, 1.0f / 3.0f, 1.0f / 3.0f, 0.0f };
pShaderAPI->SetPixelShaderConstant( 0, c0, 1 );
float c2[4] = { 0.5f, 0.5f, 0.5f, 0.5f };
pShaderAPI->SetPixelShaderConstant( 2, c2, 1 );
// fresnel constants
float flFresnelFactor = params[MAXREFLECTIVITY]->GetFloatValue() - params[MINREFLECTIVITY]->GetFloatValue();
float c3[4] = { flFresnelFactor, params[FRESNELPOWER]->GetFloatValue(), params[MINREFLECTIVITY]->GetFloatValue(), 0.0f };
pShaderAPI->SetPixelShaderConstant( 3, c3, 1 );
float c5[4] = { params[REFLECTAMOUNT]->GetFloatValue(), params[REFLECTAMOUNT]->GetFloatValue(),
params[REFRACTAMOUNT]->GetFloatValue(), params[REFRACTAMOUNT]->GetFloatValue() };
pShaderAPI->SetPixelShaderConstant( 5, c5, 1 );
pShaderAPI->SetPixelShaderFogParams( 8 );
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_lightmappedreflective_vs20 );
SET_DYNAMIC_VERTEX_SHADER( sdk_lightmappedreflective_vs20 );
if( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20 );
}
}
Draw();
}
//-----------------------------------------------------------------------------
// Fixed function multiply by detail texture pass
//-----------------------------------------------------------------------------
void CBaseShader::FixedFunctionMultiplyByDetailPass( int baseTextureVar, int frameVar,
int textureTransformVar, int detailVar, int detailScaleVar )
{
IMaterialVar** params = s_ppParams;
if (!params[detailVar]->IsDefined())
return;
if (IsSnapshotting())
{
SetInitialShadowState();
s_pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
bool translucentTexture = TextureIsTranslucent( baseTextureVar, true ) ||
IS_FLAG_SET(MATERIAL_VAR_ALPHATEST);
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, true );
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE1, true );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, false );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE1, false );
// Mod 2x blend here
EnableAlphaBlending( SHADER_BLEND_DST_COLOR, SHADER_BLEND_SRC_COLOR );
s_pShaderShadow->EnableCustomPixelPipe( true );
s_pShaderShadow->CustomTextureStages( 2 );
// We need to blend towards grey based on alpha...
// We can never get the perfect alpha (vertex alpha * cc alpha * texture alpha)
// so we'll just choose to use cc alpha * texture alpha
int flags = SHADER_DRAW_POSITION | SHADER_DRAW_TEXCOORD1;
// Compute alpha, stage 0 is used, stage 1 isn't.
if ( translucentTexture )
{
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_ALPHA, SHADER_TEXOP_MODULATE,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
flags |= SHADER_DRAW_TEXCOORD0;
}
else
{
bool hasVertexAlpha = (CurrentMaterialVarFlags() & MATERIAL_VAR_VERTEXALPHA) != 0;
if (hasVertexAlpha)
{
flags |= SHADER_DRAW_COLOR;
}
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_ALPHA, hasVertexAlpha ? SHADER_TEXOP_MODULATE : SHADER_TEXOP_SELECTARG1,
SHADER_TEXARG_CONSTANTCOLOR, SHADER_TEXARG_VERTEXCOLOR );
}
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_ALPHA, SHADER_TEXOP_SELECTARG1,
SHADER_TEXARG_PREVIOUSSTAGE, SHADER_TEXARG_NONE );
// This here will perform color = vertex light * alpha + 0.5f * (1 - alpha)
// Stage 0 really doesn't do anything
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_COLOR, SHADER_TEXOP_SELECTARG1,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_COLOR, SHADER_TEXOP_BLEND_PREVIOUSSTAGEALPHA,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
s_pShaderShadow->DrawFlags( flags );
FogToGrey();
Draw( );
s_pShaderShadow->EnableCustomPixelPipe( false );
DisableAlphaBlending();
}
else
{
if (TextureIsTranslucent( baseTextureVar, true ) )
{
SetFixedFunctionTextureTransform( MATERIAL_TEXTURE0, textureTransformVar );
BindTexture( SHADER_TEXTURE_STAGE0, baseTextureVar, frameVar );
}
else
{
// Unnecessary... but we get strange colors if we don't put something on stage 0
BindTexture( SHADER_TEXTURE_STAGE0, detailVar, frameVar );
}
BindTexture( SHADER_TEXTURE_STAGE1, detailVar, frameVar );
SetFixedFunctionTextureScaledTransform( MATERIAL_TEXTURE1, textureTransformVar, detailScaleVar );
float alpha = GetAlpha();
s_pShaderAPI->Color4ub( 128, 128, 128, 255 * alpha );
Draw( );
}
}
//-----------------------------------------------------------------------------
// Multiply by lightmap pass
//-----------------------------------------------------------------------------
void CBaseShader::FixedFunctionMultiplyByLightmapPass( int baseTextureVar,
int frameVar, int baseTextureTransformVar, float alphaOverride )
{
if (IsSnapshotting())
{
SetInitialShadowState();
s_pShaderShadow->EnableAlphaTest( false );
s_pShaderShadow->EnableBlending( true );
SingleTextureLightmapBlendMode();
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, true );
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE1, true );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, false );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE1, false );
s_pShaderShadow->EnableCustomPixelPipe( true );
s_pShaderShadow->CustomTextureStages( 2 );
// Stage zero color is not used, this op doesn't matter
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_COLOR, SHADER_TEXOP_SELECTARG1,
SHADER_TEXARG_CONSTANTCOLOR, SHADER_TEXARG_CONSTANTCOLOR );
// This here will perform color = lightmap * (cc alpha) + 1 * (1- cc alpha)
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_COLOR, SHADER_TEXOP_BLEND_PREVIOUSSTAGEALPHA,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
int flags = SHADER_DRAW_POSITION | SHADER_DRAW_LIGHTMAP_TEXCOORD1;
// Multiply the constant alpha by the texture alpha for total alpha
if (TextureIsTranslucent(baseTextureVar, true))
{
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_ALPHA, SHADER_TEXOP_MODULATE,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
flags |= SHADER_DRAW_TEXCOORD0;
}
else
{
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, false );
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_ALPHA, SHADER_TEXOP_SELECTARG2,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
}
// Alpha isn't used, it doesn't matter what we set it to.
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_ALPHA, SHADER_TEXOP_SELECTARG1,
SHADER_TEXARG_PREVIOUSSTAGE, SHADER_TEXARG_NONE );
s_pShaderShadow->DrawFlags( flags );
FogToOOOverbright();
Draw();
s_pShaderShadow->EnableCustomPixelPipe( false );
}
else
{
s_pShaderAPI->SetDefaultState();
// Put the alpha in the color channel to modulate the color down....
float alpha = (alphaOverride < 0) ? GetAlpha() : alphaOverride;
// NOTE: 128 is a more exact OO_OVERBRIGHT; it prevents some artifacts
// s_pShaderAPI->Color4f( OO_OVERBRIGHT, OO_OVERBRIGHT, OO_OVERBRIGHT, alpha );
s_pShaderAPI->Color4ub( 128, 128, 128, (int)(alpha * 255));
if (TextureIsTranslucent(baseTextureVar, true))
{
SetFixedFunctionTextureTransform( MATERIAL_TEXTURE0, baseTextureTransformVar );
BindTexture( SHADER_TEXTURE_STAGE0, baseTextureVar, frameVar );
}
LoadIdentity( MATERIAL_TEXTURE1 );
s_pShaderAPI->BindLightmap( SHADER_TEXTURE_STAGE1 );
Draw();
}
}
