//-----------------------------------------------------------------------------
// Masked environment map
//-----------------------------------------------------------------------------
void CBaseShader::FixedFunctionMaskedEnvmapPass( 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())
{
// Alpha blending
SetDefaultBlendingShadowState( envMapMaskVar, false );
// Disable overbright
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE0, 1.0f );
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE1, 1.0f );
int flags = SetShadowEnvMappingState( envMapMaskVar, envMapTintVar );
s_pShaderShadow->DrawFlags( flags );
Draw();
s_pShaderShadow->EnableCustomPixelPipe( false );
s_pShaderShadow->EnableAlphaPipe( false );
}
else
{
SetDynamicEnvMappingState( envMapVar, envMapMaskVar, baseTextureVar,
envMapFrameVar, envMapMaskFrameVar, frameVar,
maskOffsetVar, maskScaleVar, envMapTintVar );
DefaultFog();
Draw();
}
}
void DrawPass( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI,
IShaderShadow* pShaderShadow, bool hasFlashlight, VertexCompressionType_t vertexCompression )
{
bool bSinglePassFlashlight = false;
bool hasBump = params[BUMPMAP]->IsTexture();
bool hasDiffuseBumpmap = hasBump && (params[NODIFFUSEBUMPLIGHTING]->GetIntValue() == 0);
bool hasBaseTexture = params[BASETEXTURE]->IsTexture();
bool hasDetailTexture = /*!hasBump && */params[DETAIL]->IsTexture();
bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) != 0;
bool bHasDetailAlpha = params[DETAIL_ALPHA_MASK_BASE_TEXTURE]->GetIntValue() != 0;
bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0;
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
bool bSeamlessMapping = params[SEAMLESS_SCALE]->GetFloatValue() != 0.0;
bool bShaderSrgbRead = ( IsX360() && IS_PARAM_DEFINED( SHADERSRGBREAD360 ) && params[SHADERSRGBREAD360]->GetIntValue() );
SHADOW_STATE
{
int nShadowFilterMode = 0;
// Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState
pShaderShadow->EnableAlphaTest( bIsAlphaTested );
if( hasFlashlight )
{
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode(); // Based upon vendor and device dependent formats
}
SetAdditiveBlendingShadowState( BASETEXTURE, true );
pShaderShadow->EnableDepthWrites( false );
// Be sure not to write to dest alpha
pShaderShadow->EnableAlphaWrites( false );
}
else
{
SetDefaultBlendingShadowState( BASETEXTURE, true );
}
unsigned int flags = VERTEX_POSITION;
if( hasBaseTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, !bShaderSrgbRead );
}
// if( hasLightmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );
}
if( hasFlashlight )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER7 );
flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T | VERTEX_NORMAL;
}
if( hasDetailTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
}
if( hasBump )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
}
if( hasVertexColor )
{
flags |= VERTEX_COLOR;
}
// Normalizing cube map
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
// texcoord0 : base texcoord
// texcoord1 : lightmap texcoord
// texcoord2 : lightmap texcoord offset
int numTexCoords = 2;
if( hasBump )
{
numTexCoords = 3;
}
pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, 0 );
// Pre-cache pixel shaders
bool hasSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM );
pShaderShadow->EnableSRGBWrite( true );
int nLightingPreviewMode = IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER0 ) + 2 * IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER1 );
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, false );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, false );
SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, hasFlashlight );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, false );
SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, 0 ); //( bumpmap_variant == 2 )?1:0);
SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); //( bumpmap_variant == 2 )?1:0);
SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, false );
SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode != 0 );
SET_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
}
else
#endif
{
DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, false );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, false );
SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, hasFlashlight );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, false );
SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, 0 ); //( bumpmap_variant == 2 )?1:0);
SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); //( bumpmap_variant == 2 )?1:0);
SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, false );
SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode != 0 );
#ifdef _X360
SET_STATIC_VERTEX_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
#endif
SET_STATIC_VERTEX_SHADER( lightmappedgeneric_vs20 );
}
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_STATIC_PIXEL_SHADER( worldtwotextureblend_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_ALPHA_MASK_BASE_TEXTURE, bHasDetailAlpha );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead );
SET_STATIC_PIXEL_SHADER( worldtwotextureblend_ps30 );
}
else
#endif
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_ALPHA_MASK_BASE_TEXTURE, bHasDetailAlpha );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead );
SET_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, hasVertexColor );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_ALPHA_MASK_BASE_TEXTURE, bHasDetailAlpha );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead );
SET_STATIC_PIXEL_SHADER( worldtwotextureblend_ps20 );
}
// HACK HACK HACK - enable alpha writes all the time so that we have them for
// underwater stuff.
// But only do it if we're not using the alpha already for translucency
pShaderShadow->EnableAlphaWrites( bFullyOpaque );
if( hasFlashlight )
{
FogToBlack();
}
else
{
DefaultFog();
}
PI_BeginCommandBuffer();
PI_SetModulationVertexShaderDynamicState( );
PI_EndCommandBuffer();
}
DYNAMIC_STATE
{
if( hasBaseTexture )
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE );
}
// if( hasLightmap )
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
}
bool bFlashlightShadows = false;
bool bUberlight = false;
if( hasFlashlight )
{
VMatrix worldToTexture;
ITexture *pFlashlightDepthTexture;
FlashlightState_t state = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );
bFlashlightShadows = state.m_bEnableShadows;
bUberlight = state.m_bUberlight;
SetFlashLightColorFromState( state, pShaderAPI, bSinglePassFlashlight );
BindTexture( SHADER_SAMPLER2, state.m_pSpotlightTexture, state.m_nSpotlightTextureFrame );
if( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() )
{
BindTexture( SHADER_SAMPLER7, pFlashlightDepthTexture );
}
}
if( hasDetailTexture )
{
BindTexture( SHADER_SAMPLER3, DETAIL, DETAILFRAME );
}
if( hasBump )
{
if( !g_pConfig->m_bFastNoBump )
{
BindTexture( SHADER_SAMPLER4, BUMPMAP, BUMPFRAME );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALMAP_FLAT );
}
}
pShaderAPI->BindStandardTexture( SHADER_SAMPLER6, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED );
// If we don't have a texture transform, we don't have
// to set vertex shader constants or run vertex shader instructions
// for the texture transform.
bool bHasTextureTransform =
!( params[BASETEXTURETRANSFORM]->MatrixIsIdentity() &&
params[BUMPTRANSFORM]->MatrixIsIdentity() );
bool bVertexShaderFastPath = !bHasTextureTransform;
if( params[DETAIL]->IsTexture() )
{
bVertexShaderFastPath = false;
}
if( pShaderAPI->GetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING) != 0 )
{
bVertexShaderFastPath = false;
}
if( !bVertexShaderFastPath )
{
if ( !bSeamlessMapping )
{
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM );
}
if( hasBump && !bHasDetailAlpha )
{
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BUMPTRANSFORM );
Assert( !hasDetailTexture );
}
}
MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode();
if ( IsPC() )
{
bool bWorldNormal = pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_ENABLE_FIXED_LIGHTING ) == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH;
if ( bWorldNormal )
{
float vEyeDir[4];
pShaderAPI->GetWorldSpaceCameraDirection( vEyeDir );
float flFarZ = pShaderAPI->GetFarZ();
vEyeDir[0] /= flFarZ; // Divide by farZ for SSAO algorithm
vEyeDir[1] /= flFarZ;
vEyeDir[2] /= flFarZ;
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_12, vEyeDir );
}
}
#ifndef _X360
if (g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath );
SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
}
else
#endif
{
DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath );
SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs20 );
}
bool bWriteDepthToAlpha;
bool bWriteWaterFogToAlpha;
if( bFullyOpaque )
{
bWriteDepthToAlpha = pShaderAPI->ShouldWriteDepthToDestAlpha();
bWriteWaterFogToAlpha = (fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z);
AssertMsg( !(bWriteDepthToAlpha && bWriteWaterFogToAlpha), "Can't write two values to alpha at the same time." );
}
else
{
//can't write a special value to dest alpha if we're actually using as-intended alpha
bWriteDepthToAlpha = false;
bWriteWaterFogToAlpha = false;
}
#ifndef _X360
if ( g_pHardwareConfig->HasFastVertexTextures() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps30 );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows );
SET_DYNAMIC_PIXEL_SHADER_COMBO( UBERLIGHT, bUberlight );
SET_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps30 );
}
else
#endif
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20b );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows );
SET_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20 );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, (fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z) &&
(nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !bIsAlphaTested );
SET_DYNAMIC_PIXEL_SHADER( worldtwotextureblend_ps20 );
}
// always set the transform for detail textures since I'm assuming that you'll
// always have a detailscale.
if( hasDetailTexture )
{
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, DETAILSCALE );
Assert( !( hasBump && !bHasDetailAlpha ) );
}
SetPixelShaderConstantGammaToLinear( 7, SELFILLUMTINT );
float eyePos[4];
pShaderAPI->GetWorldSpaceCameraPosition( eyePos );
pShaderAPI->SetPixelShaderConstant( 10, eyePos, 1 );
pShaderAPI->SetPixelShaderFogParams( 11 );
if ( bSeamlessMapping )
{
float map_scale[4]={ params[SEAMLESS_SCALE]->GetFloatValue(),0,0,0};
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, map_scale );
}
if( hasFlashlight )
{
VMatrix worldToTexture;
const FlashlightState_t &flashlightState = pShaderAPI->GetFlashlightState( worldToTexture );
// Set the flashlight attenuation factors
float atten[4];
atten[0] = flashlightState.m_fConstantAtten;
atten[1] = flashlightState.m_fLinearAtten;
atten[2] = flashlightState.m_fQuadraticAtten;
atten[3] = flashlightState.m_FarZAtten;
pShaderAPI->SetPixelShaderConstant( 20, atten, 1 );
// Set the flashlight origin
float pos[4];
pos[0] = flashlightState.m_vecLightOrigin[0];
pos[1] = flashlightState.m_vecLightOrigin[1];
pos[2] = flashlightState.m_vecLightOrigin[2];
pos[3] = flashlightState.m_FarZ; // didn't have this in main. . probably need this?
pShaderAPI->SetPixelShaderConstant( 15, pos, 1 );
pShaderAPI->SetPixelShaderConstant( 16, worldToTexture.Base(), 4 );
if ( IsPC() && g_pHardwareConfig->HasFastVertexTextures() )
{
SetupUberlightFromState( pShaderAPI, flashlightState );
}
}
}
Draw();
}
void DrawUnbumpedUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bBumpedEnvMap )
{
bool hasEnvmap = params[ENVMAP]->IsTexture() && !bBumpedEnvMap;
bool hasBaseTexture = params[BASETEXTURE]->IsTexture();
bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
bool hasEnvmapCameraSpace = IS_FLAG_SET( MATERIAL_VAR_ENVMAPCAMERASPACE );
bool hasEnvmapSphere = IS_FLAG_SET( MATERIAL_VAR_ENVMAPSPHERE );
if ( hasEnvmap || hasBaseTexture || hasVertexColor || !bBumpedEnvMap )
{
SHADOW_STATE
{
// Alpha test
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
if ( params[ALPHATESTREFERENCE]->GetFloatValue() > 0.0f )
{
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[ALPHATESTREFERENCE]->GetFloatValue() );
}
// Base texture on stage 0
if (params[BASETEXTURE]->IsTexture())
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
}
// Lightmap on stage 1
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
int fmt = VERTEX_POSITION;
if ( hasEnvmap )
{
fmt |= VERTEX_NORMAL;
// envmap on stage 2
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
// envmapmask on stage 3
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK ) )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
}
}
if (params[BASETEXTURE]->IsTexture() || bBumpedEnvMap)
{
SetDefaultBlendingShadowState( BASETEXTURE, true );
}
else
{
SetDefaultBlendingShadowState( ENVMAPMASK, false );
}
if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR))
{
fmt |= VERTEX_COLOR;
}
pShaderShadow->VertexShaderVertexFormat( fmt, 2, 0, 0 );
lightmappedgeneric_vs11_Static_Index vshIndex;
vshIndex.SetDETAIL( false );
vshIndex.SetENVMAP( hasEnvmap );
vshIndex.SetENVMAPCAMERASPACE( hasEnvmap && hasEnvmapCameraSpace );
vshIndex.SetENVMAPSPHERE( hasEnvmap && hasEnvmapSphere );
vshIndex.SetVERTEXCOLOR( hasVertexColor );
pShaderShadow->SetVertexShader( "LightmappedGeneric_vs11", vshIndex.GetIndex() );
const char *pshName = GetPixelShaderName( params, bBumpedEnvMap );
pShaderShadow->SetPixelShader( pshName );
DefaultFog();
}
DYNAMIC_STATE
{
if (hasBaseTexture)
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM );
}
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
if ( hasEnvmap )
{
BindTexture( SHADER_SAMPLER2, ENVMAP, ENVMAPFRAME );
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) )
{
if (params[ENVMAPMASK]->IsTexture() )
BindTexture( SHADER_SAMPLER3, ENVMAPMASK, ENVMAPMASKFRAME );
else
BindTexture( SHADER_SAMPLER3, BASETEXTURE, FRAME );
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, ENVMAPMASKSCALE );
}
if (IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) ||
IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE))
{
LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_VIEWMODEL );
}
SetEnvMapTintPixelShaderDynamicState( 2, ENVMAPTINT, -1 );
}
if ( !hasEnvmap || hasBaseTexture || hasVertexColor )
{
SetModulationVertexShaderDynamicState();
}
EnablePixelShaderOverbright( 0, true, true );
SetPixelShaderConstant( 1, SELFILLUMTINT );
lightmappedgeneric_vs11_Dynamic_Index vshIndex;
vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
}
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();
}
//-----------------------------------------------------------------------------
// Fixed function Base * detail pass
//-----------------------------------------------------------------------------
void CBaseShader::FixedFunctionBaseTimesDetailPass( int baseTextureVar,
int frameVar, int baseTextureTransformVar, int detailVar, int detailScaleVar )
{
IMaterialVar** params = s_ppParams;
// We can't do this one one pass if CC and VC are both active...
bool hasDetail = (detailVar != -1) && params[detailVar]->IsDefined();
bool detailInSecondPass = hasDetail && IsColorModulating() &&
(IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR) || IS_FLAG_SET(MATERIAL_VAR_VERTEXALPHA));
if (IsSnapshotting())
{
IMaterialVar** params = s_ppParams;
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, false );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE1, false );
// alpha test
s_pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
// Alpha blending
SetDefaultBlendingShadowState( baseTextureVar, true );
// independently configure alpha and color
s_pShaderShadow->EnableAlphaPipe( true );
// Here's the color states (NOTE: SHADER_DRAW_COLOR == use Vertex Color)
s_pShaderShadow->EnableConstantColor( IsColorModulating() );
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, true );
int flags = SHADER_DRAW_POSITION | SHADER_DRAW_TEXCOORD0;
// Detail texture..
if (hasDetail && (!detailInSecondPass))
{
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE1, true );
// Force mod2x
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE1, 2.0f );
flags |= SHADER_DRAW_TEXCOORD1;
}
// Here's the alpha states
s_pShaderShadow->EnableConstantAlpha( IsAlphaModulating() );
s_pShaderShadow->EnableVertexAlpha( IS_FLAG_SET(MATERIAL_VAR_VERTEXALPHA) );
s_pShaderShadow->EnableTextureAlpha( SHADER_TEXTURE_STAGE0, TextureIsTranslucent(baseTextureVar, true) );
if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR))
flags |= SHADER_DRAW_COLOR;
s_pShaderShadow->DrawFlags( flags );
Draw();
s_pShaderShadow->EnableAlphaPipe( false );
}
else
{
SetFixedFunctionTextureTransform( MATERIAL_TEXTURE0, baseTextureTransformVar );
BindTexture( SHADER_TEXTURE_STAGE0, baseTextureVar, frameVar );
// Detail texture..
if (hasDetail && (!detailInSecondPass))
{
BindTexture( SHADER_TEXTURE_STAGE1, detailVar, frameVar );
SetFixedFunctionTextureScaledTransform( MATERIAL_TEXTURE1, baseTextureTransformVar, detailScaleVar );
}
SetModulationDynamicState();
DefaultFog();
Draw();
}
if (detailInSecondPass)
{
FixedFunctionMultiplyByDetailPass( baseTextureVar, frameVar, baseTextureTransformVar, detailVar, detailScaleVar );
}
}
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();
}