void DrawLightmappedGeneric_DX9_Internal(CBaseVSShader *pShader, IMaterialVar** params, bool hasFlashlight,
IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow,
LightmappedGeneric_DX9_Vars_t &info,
CBasePerMaterialContextData **pContextDataPtr
)
{
CLightmappedGeneric_DX9_Context *pContextData = reinterpret_cast< CLightmappedGeneric_DX9_Context *> ( *pContextDataPtr );
if ( pShaderShadow || ( ! pContextData ) || pContextData->m_bMaterialVarsChanged || hasFlashlight )
{
bool hasBaseTexture = params[info.m_nBaseTexture]->IsTexture();
int nAlphaChannelTextureVar = hasBaseTexture ? (int)info.m_nBaseTexture : (int)info.m_nEnvmapMask;
BlendType_t nBlendType = pShader->EvaluateBlendRequirements( nAlphaChannelTextureVar, hasBaseTexture );
bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0;
bool bFullyOpaqueWithoutAlphaTest = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && (!hasFlashlight || IsX360()); //dest alpha is free for special use
bool bFullyOpaque = bFullyOpaqueWithoutAlphaTest && !bIsAlphaTested;
bool bNeedRegenStaticCmds = (! pContextData ) || pShaderShadow;
if ( ! pContextData ) // make sure allocated
{
pContextData = new CLightmappedGeneric_DX9_Context;
*pContextDataPtr = pContextData;
}
bool hasBump = ( params[info.m_nBumpmap]->IsTexture() ) && ( !g_pHardwareConfig->PreferReducedFillrate() );
bool hasSSBump = hasBump && (info.m_nSelfShadowedBumpFlag != -1) && ( params[info.m_nSelfShadowedBumpFlag]->GetIntValue() );
bool hasBaseTexture2 = hasBaseTexture && params[info.m_nBaseTexture2]->IsTexture();
bool hasLightWarpTexture = params[info.m_nLightWarpTexture]->IsTexture();
bool hasBump2 = hasBump && params[info.m_nBumpmap2]->IsTexture();
bool hasDetailTexture = params[info.m_nDetail]->IsTexture();
bool hasSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM );
bool hasBumpMask = hasBump && hasBump2 && params[info.m_nBumpMask]->IsTexture() && !hasSelfIllum &&
!hasDetailTexture && !hasBaseTexture2 && (params[info.m_nBaseTextureNoEnvmap]->GetIntValue() == 0);
bool bHasBlendModulateTexture =
(info.m_nBlendModulateTexture != -1) &&
(params[info.m_nBlendModulateTexture]->IsTexture() );
bool hasNormalMapAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK );
// Parallax cubemaps
bool hasParallaxCorrection = params[info.m_nEnvmapParallaxObb1]->IsDefined();
if ( hasFlashlight && !IsX360() )
{
// !!speed!! do this in the caller so we don't build struct every time
CBaseVSShader::DrawFlashlight_dx90_Vars_t vars;
vars.m_bBump = hasBump;
vars.m_nBumpmapVar = info.m_nBumpmap;
vars.m_nBumpmapFrame = info.m_nBumpFrame;
vars.m_nBumpTransform = info.m_nBumpTransform;
vars.m_nFlashlightTextureVar = info.m_nFlashlightTexture;
vars.m_nFlashlightTextureFrameVar = info.m_nFlashlightTextureFrame;
vars.m_bLightmappedGeneric = true;
vars.m_bWorldVertexTransition = hasBaseTexture2;
vars.m_nBaseTexture2Var = info.m_nBaseTexture2;
vars.m_nBaseTexture2FrameVar = info.m_nBaseTexture2Frame;
vars.m_nBumpmap2Var = info.m_nBumpmap2;
vars.m_nBumpmap2Frame = info.m_nBumpFrame2;
vars.m_nBump2Transform = info.m_nBumpTransform2;
vars.m_nAlphaTestReference = info.m_nAlphaTestReference;
vars.m_bSSBump = hasSSBump;
vars.m_nDetailVar = info.m_nDetail;
vars.m_nDetailScale = info.m_nDetailScale;
vars.m_nDetailTextureCombineMode = info.m_nDetailTextureCombineMode;
vars.m_nDetailTextureBlendFactor = info.m_nDetailTextureBlendFactor;
vars.m_nDetailTint = info.m_nDetailTint;
if ( ( info.m_nSeamlessMappingScale != -1 ) )
vars.m_fSeamlessScale = params[info.m_nSeamlessMappingScale]->GetFloatValue();
else
vars.m_fSeamlessScale = 0.0;
pShader->DrawFlashlight_dx90( params, pShaderAPI, pShaderShadow, vars );
return;
}
pContextData->m_bFullyOpaque = bFullyOpaque;
pContextData->m_bFullyOpaqueWithoutAlphaTest = bFullyOpaqueWithoutAlphaTest;
NormalDecodeMode_t nNormalDecodeMode = NORMAL_DECODE_NONE;
if ( hasBump && g_pHardwareConfig->SupportsNormalMapCompression() && g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
ITexture *pBumpTex = params[info.m_nBumpmap]->GetTextureValue();
if ( pBumpTex )
{
nNormalDecodeMode = pBumpTex->GetNormalDecodeMode();
if ( hasBump2 ) // Check encoding of secondary normal if there is oneg
{
ITexture *pBumpTex2 = params[info.m_nBumpmap]->GetTextureValue();
if ( pBumpTex2 && ( pBumpTex2->GetNormalDecodeMode() != nNormalDecodeMode ) )
{
DevMsg("LightmappedGeneric: Primary and Secondary normal map compression formats don't match. This is unsupported!\n");
Assert(0);
}
}
}
}
int nNormalMaskDecodeMode = 0;
if ( hasBumpMask && g_pHardwareConfig->SupportsNormalMapCompression() && g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
ITexture *pBumpMaskTex = params[info.m_nBumpMask]->GetTextureValue();
if ( pBumpMaskTex )
{
nNormalMaskDecodeMode = pBumpMaskTex->GetNormalDecodeMode();
}
}
bool bHasOutline = IsBoolSet( info.m_nOutline, params );
pContextData->m_bPixelShaderForceFastPathBecauseOutline = bHasOutline;
bool bHasSoftEdges = IsBoolSet( info.m_nSoftEdges, params );
bool hasEnvmapMask = params[info.m_nEnvmapMask]->IsTexture();
float fDetailBlendFactor = GetFloatParam( info.m_nDetailTextureBlendFactor, params, 1.0 );
if ( pShaderShadow || bNeedRegenStaticCmds )
{
bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
bool hasDiffuseBumpmap = hasBump && (params[info.m_nNoDiffuseBumpLighting]->GetIntValue() == 0);
bool hasEnvmap = params[info.m_nEnvmap]->IsTexture();
bool bSeamlessMapping = ( ( info.m_nSeamlessMappingScale != -1 ) &&
( params[info.m_nSeamlessMappingScale]->GetFloatValue() != 0.0 ) );
if ( bNeedRegenStaticCmds )
{
pContextData->ResetStaticCmds();
CCommandBufferBuilder< CFixedCommandStorageBuffer< 5000 > > staticCmdsBuf;
if( !hasBaseTexture )
{
if( hasEnvmap )
{
// if we only have an envmap (no basetexture), then we want the albedo to be black.
staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_BLACK );
}
else
{
staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE );
}
}
staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
if ( bSeamlessMapping )
{
staticCmdsBuf.SetVertexShaderConstant4(
VERTEX_SHADER_SHADER_SPECIFIC_CONST_0,
params[info.m_nSeamlessMappingScale]->GetFloatValue(),0,0,0 );
}
staticCmdsBuf.StoreEyePosInPixelShaderConstant( 10 );
staticCmdsBuf.SetPixelShaderFogParams( 11 );
staticCmdsBuf.End();
// now, copy buf
pContextData->m_pStaticCmds = new uint8[staticCmdsBuf.Size()];
memcpy( pContextData->m_pStaticCmds, staticCmdsBuf.Base(), staticCmdsBuf.Size() );
}
if ( pShaderShadow )
{
// Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState
pShaderShadow->EnableAlphaTest( bIsAlphaTested );
if ( info.m_nAlphaTestReference != -1 && params[info.m_nAlphaTestReference]->GetFloatValue() > 0.0f )
{
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[info.m_nAlphaTestReference]->GetFloatValue() );
}
pShader->SetDefaultBlendingShadowState( nAlphaChannelTextureVar, hasBaseTexture );
unsigned int flags = VERTEX_POSITION;
// base texture
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
if ( hasLightWarpTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER6, false );
}
if ( bHasBlendModulateTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, false );
}
if ( hasBaseTexture2 )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER7, true );
}
// if( hasLightmap )
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );
}
else
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false );
}
if( hasEnvmap || ( IsX360() && hasFlashlight ) )
{
if( hasEnvmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
}
}
flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T | VERTEX_NORMAL;
}
int nDetailBlendMode = 0;
if ( hasDetailTexture )
{
nDetailBlendMode = GetIntParam( info.m_nDetailTextureCombineMode, params );
ITexture *pDetailTexture = params[info.m_nDetail]->GetTextureValue();
if ( pDetailTexture->GetFlags() & TEXTUREFLAGS_SSBUMP )
{
if ( hasBump )
nDetailBlendMode = 10; // ssbump
else
nDetailBlendMode = 11; // ssbump_nobump
}
}
if( hasDetailTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER12, true );
bool bSRGBState = ( nDetailBlendMode == 1 );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER12, bSRGBState );
}
if( hasBump || hasNormalMapAlphaEnvmapMask )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
if ( nNormalDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); // Normal map alpha, in the compressed normal case
}
}
if( hasBump2 )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
if ( nNormalDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); // Secondary normal alpha, in the compressed normal case
}
}
if( hasBumpMask )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER8, true );
if ( nNormalMaskDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER11, true ); // Normal mask alpha, in the compressed normal case
}
}
if( hasEnvmapMask )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
}
if( hasFlashlight && IsX360() )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER13, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER14, true );
pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER14 );
pShaderShadow->EnableTexture( SHADER_SAMPLER15, true );
}
if( hasVertexColor || hasBaseTexture2 || hasBump2 )
{
flags |= VERTEX_COLOR;
}
// 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 hasBaseAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_BASEALPHAENVMAPMASK );
int bumpmap_variant=(hasSSBump) ? 2 : hasBump;
bool bMaskedBlending=( (info.m_nMaskedBlending != -1) &&
(params[info.m_nMaskedBlending]->GetIntValue() != 0) );
DECLARE_STATIC_VERTEX_SHADER( sdk_lightmappedgeneric_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, hasEnvmapMask );
SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, params[info.m_nEnvmap]->IsTexture() );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, hasBaseTexture2 || hasBump2 );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, hasBumpMask );
bool bReliefMapping = false; //( bumpmap_variant == 2 ) && ( ! bSeamlessMapping );
SET_STATIC_VERTEX_SHADER_COMBO( RELIEF_MAPPING, false );//bReliefMapping );
SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
#ifdef _X360
SET_STATIC_VERTEX_SHADER_COMBO( FLASHLIGHT, hasFlashlight);
#endif
SET_STATIC_VERTEX_SHADER(sdk_lightmappedgeneric_vs20);
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER(sdk_lightmappedgeneric_ps20b);
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, hasBaseTexture2 );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, bumpmap_variant );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP2, hasBump2 );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMASK, hasBumpMask );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, hasEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, hasEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( BASEALPHAENVMAPMASK, hasBaseAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURENOENVMAP, params[info.m_nBaseTextureNoEnvmap]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2NOENVMAP, params[info.m_nBaseTexture2NoEnvmap]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( WARPLIGHTING, hasLightWarpTexture );
SET_STATIC_PIXEL_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture );
SET_STATIC_PIXEL_SHADER_COMBO( MASKEDBLENDING, bMaskedBlending);
SET_STATIC_PIXEL_SHADER_COMBO( RELIEF_MAPPING, bReliefMapping );
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( OUTLINE, bHasOutline );
SET_STATIC_PIXEL_SHADER_COMBO( SOFTEDGES, bHasSoftEdges );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode );
SET_STATIC_PIXEL_SHADER_COMBO( NORMAL_DECODE_MODE, (int) nNormalDecodeMode );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMASK_DECODE_MODE, (int) nNormalMaskDecodeMode );
// Parallax cubemaps enabled for 2_0b and onwards
SET_STATIC_PIXEL_SHADER_COMBO( PARALLAXCORRECT, hasParallaxCorrection );
#ifdef _X360
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight);
#endif
SET_STATIC_PIXEL_SHADER(sdk_lightmappedgeneric_ps20b);
}
else
{
DECLARE_STATIC_PIXEL_SHADER(sdk_lightmappedgeneric_ps20);
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, hasBaseTexture2 );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, bumpmap_variant );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP2, hasBump2 );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMASK, hasBumpMask );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, hasEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, hasEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( BASEALPHAENVMAPMASK, hasBaseAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURENOENVMAP, params[info.m_nBaseTextureNoEnvmap]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2NOENVMAP, params[info.m_nBaseTexture2NoEnvmap]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( WARPLIGHTING, hasLightWarpTexture );
SET_STATIC_PIXEL_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture );
SET_STATIC_PIXEL_SHADER_COMBO( MASKEDBLENDING, bMaskedBlending);
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( OUTLINE, bHasOutline );
SET_STATIC_PIXEL_SHADER_COMBO( SOFTEDGES, bHasSoftEdges );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode );
SET_STATIC_PIXEL_SHADER_COMBO( NORMAL_DECODE_MODE, 0 ); // No normal compression with ps_2_0 (yikes!)
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMASK_DECODE_MODE, 0 ); // No normal compression with ps_2_0
// Parallax cubemaps
SET_STATIC_PIXEL_SHADER_COMBO(PARALLAXCORRECT, 0); // No parallax cubemaps with ps_2_0
SET_STATIC_PIXEL_SHADER(sdk_lightmappedgeneric_ps20);
}
// HACK HACK HACK - enable alpha writes all the time so that we have them for
// underwater stuff and writing depth to dest alpha
// But only do it if we're not using the alpha already for translucency
pShaderShadow->EnableAlphaWrites( bFullyOpaque );
pShaderShadow->EnableSRGBWrite( true );
pShader->DefaultFog();
} // end shadow state
} // end shadow || regen display list
if ( pShaderAPI && pContextData->m_bMaterialVarsChanged )
{
// need to regenerate the semistatic cmds
pContextData->m_SemiStaticCmdsOut.Reset();
pContextData->m_bMaterialVarsChanged = false;
bool bHasBlendMaskTransform= (
(info.m_nBlendMaskTransform != -1) &&
(info.m_nMaskedBlending != -1) &&
(params[info.m_nMaskedBlending]->GetIntValue() ) &&
( ! (params[info.m_nBumpTransform]->MatrixIsIdentity() ) ) );
// 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[info.m_nBaseTextureTransform]->MatrixIsIdentity() &&
params[info.m_nBumpTransform]->MatrixIsIdentity() &&
params[info.m_nBumpTransform2]->MatrixIsIdentity() &&
params[info.m_nEnvmapMaskTransform]->MatrixIsIdentity() );
bHasTextureTransform |= bHasBlendMaskTransform;
pContextData->m_bVertexShaderFastPath = !bHasTextureTransform;
if( params[info.m_nDetail]->IsTexture() )
{
pContextData->m_bVertexShaderFastPath = false;
}
if (bHasBlendMaskTransform)
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform(
VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, info.m_nBlendMaskTransform );
}
if ( ! pContextData->m_bVertexShaderFastPath )
{
bool bSeamlessMapping = ( ( info.m_nSeamlessMappingScale != -1 ) &&
( params[info.m_nSeamlessMappingScale]->GetFloatValue() != 0.0 ) );
bool hasEnvmapMask = params[info.m_nEnvmapMask]->IsTexture();
if (!bSeamlessMapping )
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nBaseTextureTransform );
// If we have a detail texture, then the bump texcoords are the same as the base texcoords.
if( hasBump && !hasDetailTexture )
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBumpTransform );
}
if( hasEnvmapMask )
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nEnvmapMaskTransform );
}
else if ( hasBump2 )
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nBumpTransform2 );
}
}
pContextData->m_SemiStaticCmdsOut.SetEnvMapTintPixelShaderDynamicState( 0, info.m_nEnvmapTint );
// set up shader modulation color
float color[4] = { 1.0, 1.0, 1.0, 1.0 };
pShader->ComputeModulationColor( color );
float flLScale = pShaderAPI->GetLightMapScaleFactor();
color[0] *= flLScale;
color[1] *= flLScale;
color[2] *= flLScale;
pContextData->m_SemiStaticCmdsOut.SetVertexShaderConstant( VERTEX_SHADER_MODULATION_COLOR, color );
color[3] *= ( IS_PARAM_DEFINED( info.m_nAlpha2 ) && params[ info.m_nAlpha2 ]->GetFloatValue() > 0.0f ) ? params[ info.m_nAlpha2 ]->GetFloatValue() : 1.0f;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 12, color );
if ( hasDetailTexture )
{
float detailTintAndBlend[4] = {1, 1, 1, 1};
if ( info.m_nDetailTint != -1 )
{
params[info.m_nDetailTint]->GetVecValue( detailTintAndBlend, 3 );
}
detailTintAndBlend[3] = fDetailBlendFactor;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 8, detailTintAndBlend );
}
float envmapTintVal[4];
float selfIllumTintVal[4];
params[info.m_nEnvmapTint]->GetVecValue( envmapTintVal, 3 );
params[info.m_nSelfIllumTint]->GetVecValue( selfIllumTintVal, 3 );
float envmapContrast = params[info.m_nEnvmapContrast]->GetFloatValue();
float envmapSaturation = params[info.m_nEnvmapSaturation]->GetFloatValue();
float fresnelReflection = params[info.m_nFresnelReflection]->GetFloatValue();
bool hasEnvmap = params[info.m_nEnvmap]->IsTexture();
pContextData->m_bPixelShaderFastPath = true;
bool bUsingContrast = hasEnvmap && ( (envmapContrast != 0.0f) && (envmapContrast != 1.0f) ) && (envmapSaturation != 1.0f);
bool bUsingFresnel = hasEnvmap && (fresnelReflection != 1.0f);
bool bUsingSelfIllumTint = IS_FLAG_SET(MATERIAL_VAR_SELFILLUM) && (selfIllumTintVal[0] != 1.0f || selfIllumTintVal[1] != 1.0f || selfIllumTintVal[2] != 1.0f);
if ( bUsingContrast || bUsingFresnel || bUsingSelfIllumTint || !g_pConfig->bShowSpecular )
{
pContextData->m_bPixelShaderFastPath = false;
}
if( !pContextData->m_bPixelShaderFastPath )
{
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstants( 2, 3 );
pContextData->m_SemiStaticCmdsOut.OutputConstantData( params[info.m_nEnvmapContrast]->GetVecValue() );
pContextData->m_SemiStaticCmdsOut.OutputConstantData( params[info.m_nEnvmapSaturation]->GetVecValue() );
float flFresnel = params[info.m_nFresnelReflection]->GetFloatValue();
// [ 0, 0, 1-R(0), R(0) ]
pContextData->m_SemiStaticCmdsOut.OutputConstantData4( 0., 0., 1.0 - flFresnel, flFresnel );
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 7, params[info.m_nSelfIllumTint]->GetVecValue() );
}
else
{
if ( bHasOutline )
{
float flOutlineParms[8] = { GetFloatParam( info.m_nOutlineStart0, params ),
GetFloatParam( info.m_nOutlineStart1, params ),
GetFloatParam( info.m_nOutlineEnd0, params ),
GetFloatParam( info.m_nOutlineEnd1, params ),
0,0,0,
GetFloatParam( info.m_nOutlineAlpha, params ) };
if ( info.m_nOutlineColor != -1 )
{
params[info.m_nOutlineColor]->GetVecValue( flOutlineParms + 4, 3 );
}
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 2, flOutlineParms, 2 );
}
if ( bHasSoftEdges )
{
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant4(
4, GetFloatParam( info.m_nEdgeSoftnessStart, params ),
GetFloatParam( info.m_nEdgeSoftnessEnd, params ),
0,0 );
}
}
// texture binds
if( hasBaseTexture )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER0, info.m_nBaseTexture, info.m_nBaseTextureFrame );
}
// handle mat_fullbright 2
bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE );
if( bLightingOnly )
{
// BASE TEXTURE
if( hasSelfIllum )
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY_ALPHA_ZERO );
}
else
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY );
}
// BASE TEXTURE 2
if( hasBaseTexture2 )
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_GREY );
}
// DETAIL TEXTURE
if( hasDetailTexture )
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER12, TEXTURE_GREY );
}
// disable color modulation
float color[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
pContextData->m_SemiStaticCmdsOut.SetVertexShaderConstant( VERTEX_SHADER_MODULATION_COLOR, color );
// turn off environment mapping
envmapTintVal[0] = 0.0f;
envmapTintVal[1] = 0.0f;
envmapTintVal[2] = 0.0f;
}
// always set the transform for detail textures since I'm assuming that you'll
// always have a detailscale.
if( hasDetailTexture )
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBaseTextureTransform, info.m_nDetailScale );
}
if( hasBaseTexture2 )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER7, info.m_nBaseTexture2, info.m_nBaseTexture2Frame );
}
if( hasDetailTexture )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nDetail, info.m_nDetailFrame );
}
if( hasBump || hasNormalMapAlphaEnvmapMask )
{
if( !g_pConfig->m_bFastNoBump )
{
if ( nNormalDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
pContextData->m_SemiStaticCmdsOut.BindMultiTexture( pShader, SHADER_SAMPLER4, SHADER_SAMPLER9, info.m_nBumpmap, info.m_nBumpFrame );
}
else
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER4, info.m_nBumpmap, info.m_nBumpFrame );
}
}
else
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALMAP_FLAT );
}
}
if( hasBump2 )
{
if( !g_pConfig->m_bFastNoBump )
{
if ( nNormalDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
pContextData->m_SemiStaticCmdsOut.BindMultiTexture( pShader, SHADER_SAMPLER5, SHADER_SAMPLER10, info.m_nBumpmap2, info.m_nBumpFrame2 );
}
else
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER5, info.m_nBumpmap2, info.m_nBumpFrame2 );
}
}
else
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALMAP_FLAT );
}
}
if( hasBumpMask )
{
if( !g_pConfig->m_bFastNoBump )
{
if ( nNormalMaskDecodeMode == NORMAL_DECODE_ATI2N_ALPHA )
{
Assert(0);
//pContextData->m_SemiStaticCmdsOut.BindTexture( SHADER_SAMPLER8, SHADER_SAMPLER11, info.m_nBumpMask );
}
else
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER8, info.m_nBumpMask, -1 );
}
}
else
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER8, TEXTURE_NORMALMAP_FLAT );
}
}
if( hasEnvmapMask )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER5, info.m_nEnvmapMask, info.m_nEnvmapMaskFrame );
}
if ( hasLightWarpTexture )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER6, info.m_nLightWarpTexture, -1 );
}
if ( bHasBlendModulateTexture )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER3, info.m_nBlendModulateTexture, -1 );
}
// Parallax cubemaps
if (hasParallaxCorrection)
{
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant(21, params[info.m_nEnvmapOrigin]->GetVecValue());
float* vecs[3];
vecs[0] = const_cast<float*>(params[info.m_nEnvmapParallaxObb1]->GetVecValue());
vecs[1] = const_cast<float*>(params[info.m_nEnvmapParallaxObb2]->GetVecValue());
vecs[2] = const_cast<float*>(params[info.m_nEnvmapParallaxObb3]->GetVecValue());
float matrix[4][4];
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
matrix[i][j] = vecs[i][j];
}
}
matrix[3][0] = matrix[3][1] = matrix[3][2] = 0;
matrix[3][3] = 1;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant(22, &matrix[0][0], 4);
}
pContextData->m_SemiStaticCmdsOut.End();
}
}
DYNAMIC_STATE
{
CCommandBufferBuilder< CFixedCommandStorageBuffer< 1000 > > DynamicCmdsOut;
DynamicCmdsOut.Call( pContextData->m_pStaticCmds );
DynamicCmdsOut.Call( pContextData->m_SemiStaticCmdsOut.Base() );
bool hasEnvmap = params[info.m_nEnvmap]->IsTexture();
if( hasEnvmap )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER2, info.m_nEnvmap, info.m_nEnvmapFrame );
}
int nFixedLightingMode = pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_ENABLE_FIXED_LIGHTING );
bool bVertexShaderFastPath = pContextData->m_bVertexShaderFastPath;
if( nFixedLightingMode != 0 )
{
if ( pContextData->m_bPixelShaderForceFastPathBecauseOutline )
nFixedLightingMode = 0;
else
bVertexShaderFastPath = false;
}
MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode();
DECLARE_DYNAMIC_VERTEX_SHADER(sdk_lightmappedgeneric_vs20);
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath );
SET_DYNAMIC_VERTEX_SHADER_COMBO(
LIGHTING_PREVIEW,
(nFixedLightingMode)?1:0
);
SET_DYNAMIC_VERTEX_SHADER_CMD(DynamicCmdsOut, sdk_lightmappedgeneric_vs20);
bool bPixelShaderFastPath = pContextData->m_bPixelShaderFastPath;
if( nFixedLightingMode !=0 )
{
bPixelShaderFastPath = false;
}
bool bWriteDepthToAlpha;
bool bWriteWaterFogToAlpha;
if( pContextData->m_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;
}
float envmapContrast = params[info.m_nEnvmapContrast]->GetFloatValue();
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER(sdk_lightmappedgeneric_ps20b);
SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATH, bPixelShaderFastPath || pContextData->m_bPixelShaderForceFastPathBecauseOutline );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATHENVMAPCONTRAST, bPixelShaderFastPath && envmapContrast == 1.0f );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( LIGHTING_PREVIEW, nFixedLightingMode );
SET_DYNAMIC_PIXEL_SHADER_CMD(DynamicCmdsOut, sdk_lightmappedgeneric_ps20b);
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER(sdk_lightmappedgeneric_ps20);
SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATH, bPixelShaderFastPath );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATHENVMAPCONTRAST, bPixelShaderFastPath && envmapContrast == 1.0f );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( LIGHTING_PREVIEW, nFixedLightingMode );
SET_DYNAMIC_PIXEL_SHADER_CMD(DynamicCmdsOut, sdk_lightmappedgeneric_ps20);
}
if( hasFlashlight && IsX360() )
{
VMatrix worldToTexture;
ITexture *pFlashlightDepthTexture;
FlashlightState_t flashlightState = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );
DynamicCmdsOut.SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, worldToTexture.Base(), 4 );
SetFlashLightColorFromState( flashlightState, pShaderAPI );
float atten[4], pos[4];
atten[0] = flashlightState.m_fConstantAtten; // Set the flashlight attenuation factors
atten[1] = flashlightState.m_fLinearAtten;
atten[2] = flashlightState.m_fQuadraticAtten;
atten[3] = flashlightState.m_FarZ;
DynamicCmdsOut.SetPixelShaderConstant( 13, atten, 1 );
pos[0] = flashlightState.m_vecLightOrigin[0]; // Set the flashlight origin
pos[1] = flashlightState.m_vecLightOrigin[1];
pos[2] = flashlightState.m_vecLightOrigin[2];
DynamicCmdsOut.SetPixelShaderConstant( 14, pos, 1 );
pShader->BindTexture( SHADER_SAMPLER13, flashlightState.m_pSpotlightTexture, flashlightState.m_nSpotlightTextureFrame );
if( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() && flashlightState.m_bEnableShadows )
{
pShader->BindTexture( SHADER_SAMPLER14, pFlashlightDepthTexture, 0 );
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER15, TEXTURE_SHADOW_NOISE_2D );
// Tweaks associated with a given flashlight
float tweaks[4];
tweaks[0] = ShadowFilterFromState( flashlightState );
tweaks[1] = ShadowAttenFromState( flashlightState );
pShader->HashShadow2DJitter( flashlightState.m_flShadowJitterSeed, &tweaks[2], &tweaks[3] );
DynamicCmdsOut.SetPixelShaderConstant( 19, 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 );
vScreenScale[0] = (float) nWidth / 32.0f;
vScreenScale[1] = (float) nHeight / 32.0f;
DynamicCmdsOut.SetPixelShaderConstant( 31, vScreenScale, 1 );
}
}
DynamicCmdsOut.End();
pShaderAPI->ExecuteCommandBuffer( DynamicCmdsOut.Base() );
}
pShader->Draw();
if( IsPC() && (IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0) && pContextData->m_bFullyOpaqueWithoutAlphaTest )
{
//Alpha testing makes it so we can't write to dest alpha
//Writing to depth makes it so later polygons can't write to dest alpha either
//This leads to situations with garbage in dest alpha.
//Fix it now by converting depth to dest alpha for any pixels that just wrote.
pShader->DrawEqualDepthToDestAlpha();
}
}
void DrawPassComposite( const defParms_composite &info, CBaseVSShader *pShader, IMaterialVar **params,
IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI,
VertexCompressionType_t vertexCompression, CDeferredPerMaterialContextData *pDeferredContext )
{
const bool bModel = info.bModel;
const bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL );
const bool bFastVTex = g_pHardwareConfig->HasFastVertexTextures();
const bool bAlbedo = PARM_TEX( info.iAlbedo );
const bool bAlbedo2 = !bModel && bAlbedo && PARM_TEX( info.iAlbedo2 );
const bool bAlbedo3 = !bModel && bAlbedo && PARM_TEX( info.iAlbedo3 );
const bool bAlbedo4 = !bModel && bAlbedo && PARM_TEX( info.iAlbedo4 );
const bool bAlphatest = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) && bAlbedo;
const bool bTranslucent = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ) && bAlbedo && !bAlphatest;
const bool bNoCull = IS_FLAG_SET( MATERIAL_VAR_NOCULL );
const bool bUseSRGB = DEFCFG_USE_SRGB_CONVERSION != 0;
const bool bPhongFresnel = PARM_SET( info.iPhongFresnel );
const bool bEnvmap = PARM_TEX( info.iEnvmap );
const bool bEnvmapMask = bEnvmap && PARM_TEX( info.iEnvmapMask );
const bool bEnvmapMask2 = bEnvmapMask && PARM_TEX( info.iEnvmapMask2 );
const bool bEnvmapFresnel = bEnvmap && PARM_SET( info.iEnvmapFresnel );
const bool bRimLight = PARM_SET( info.iRimlightEnable );
const bool bRimLightModLight = bRimLight && PARM_SET( info.iRimlightModLight );
const bool bBlendmodulate = bAlbedo2 && PARM_TEX( info.iBlendmodulate );
const bool bBlendmodulate2 = bBlendmodulate && PARM_TEX( info.iBlendmodulate2 );
const bool bBlendmodulate3 = bBlendmodulate && PARM_TEX( info.iBlendmodulate3 );
const bool bSelfIllum = !bAlbedo2 && IS_FLAG_SET( MATERIAL_VAR_SELFILLUM );
const bool bSelfIllumMaskInEnvmapMask = bSelfIllum && bEnvmapMask && PARM_SET( info.iSelfIllumMaskInEnvmapAlpha );
const bool bSelfIllumMask = bSelfIllum && !bSelfIllumMaskInEnvmapMask && !bEnvmapMask && PARM_TEX( info.iSelfIllumMask );
const bool bMultiBlend = PARM_SET( info.iMultiblend )
&& bAlbedo && bAlbedo2 && bAlbedo3 && !bEnvmapMask && !bSelfIllumMask;
const bool bNeedsFresnel = bPhongFresnel || bEnvmapFresnel;
const bool bGBufferNormal = bEnvmap || bRimLight || bNeedsFresnel;
const bool bWorldEyeVec = bGBufferNormal;
AssertMsgOnce( !(bTranslucent || bAlphatest) || !bAlbedo2,
"blended albedo not supported by gbuffer pass!" );
AssertMsgOnce( IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ) == false,
"Normal map sampling should stay out of composition pass." );
AssertMsgOnce( !PARM_TEX( info.iSelfIllumMask ) || !bEnvmapMask,
"Can't use separate selfillum mask with envmap mask - use SELFILLUM_ENVMAPMASK_ALPHA instead." );
AssertMsgOnce( PARM_SET( info.iMultiblend ) == bMultiBlend,
"Multiblend forced off due to invalid usage! May cause vertexformat mis-matches between passes." );
SHADOW_STATE
{
pShaderShadow->SetDefaultState();
pShaderShadow->EnableSRGBWrite( bUseSRGB );
if ( bNoCull )
{
pShaderShadow->EnableCulling( false );
}
int iVFmtFlags = VERTEX_POSITION;
int iUserDataSize = 0;
int *pTexCoordDim;
int iTexCoordNum;
GetTexcoordSettings( ( bModel && bIsDecal && bFastVTex ), bMultiBlend,
iTexCoordNum, &pTexCoordDim );
if ( bModel )
{
iVFmtFlags |= VERTEX_NORMAL;
iVFmtFlags |= VERTEX_FORMAT_COMPRESSED;
}
else
{
if ( bAlbedo2 )
iVFmtFlags |= VERTEX_COLOR;
}
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, bUseSRGB );
if ( bGBufferNormal )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false );
}
if ( bTranslucent )
{
pShader->EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
}
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, false );
if ( bEnvmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, true );
if ( bEnvmapMask )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
if ( bAlbedo2 )
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
}
}
else if ( bSelfIllumMask )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
}
if ( bAlbedo2 )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER5, bUseSRGB );
if ( bBlendmodulate )
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
}
if ( bMultiBlend )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER7, bUseSRGB );
if ( bAlbedo4 )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER8, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, bUseSRGB );
}
if ( bBlendmodulate )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER9, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER10, true );
}
}
pShaderShadow->EnableAlphaWrites( false );
pShaderShadow->EnableDepthWrites( !bTranslucent );
pShader->DefaultFog();
pShaderShadow->VertexShaderVertexFormat( iVFmtFlags, iTexCoordNum, pTexCoordDim, iUserDataSize );
DECLARE_STATIC_VERTEX_SHADER( composite_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bModel );
SET_STATIC_VERTEX_SHADER_COMBO( MORPHING_VTEX, bModel && bFastVTex );
SET_STATIC_VERTEX_SHADER_COMBO( DECAL, bModel && bIsDecal );
SET_STATIC_VERTEX_SHADER_COMBO( EYEVEC, bWorldEyeVec );
SET_STATIC_VERTEX_SHADER_COMBO( BASETEXTURE2, bAlbedo2 && !bMultiBlend );
SET_STATIC_VERTEX_SHADER_COMBO( BLENDMODULATE, bBlendmodulate );
SET_STATIC_VERTEX_SHADER_COMBO( MULTIBLEND, bMultiBlend );
SET_STATIC_VERTEX_SHADER( composite_vs30 );
DECLARE_STATIC_PIXEL_SHADER( composite_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( ALPHATEST, bAlphatest );
SET_STATIC_PIXEL_SHADER_COMBO( TRANSLUCENT, bTranslucent );
SET_STATIC_PIXEL_SHADER_COMBO( READNORMAL, bGBufferNormal );
SET_STATIC_PIXEL_SHADER_COMBO( NOCULL, bNoCull );
SET_STATIC_PIXEL_SHADER_COMBO( ENVMAP, bEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, bEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPFRESNEL, bEnvmapFresnel );
SET_STATIC_PIXEL_SHADER_COMBO( PHONGFRESNEL, bPhongFresnel );
SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHT, bRimLight );
SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHTMODULATELIGHT, bRimLightModLight );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, bAlbedo2 && !bMultiBlend );
SET_STATIC_PIXEL_SHADER_COMBO( BLENDMODULATE, bBlendmodulate );
SET_STATIC_PIXEL_SHADER_COMBO( MULTIBLEND, bMultiBlend );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM_MASK, bSelfIllumMask );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM_ENVMAP_ALPHA, bSelfIllumMaskInEnvmapMask );
SET_STATIC_PIXEL_SHADER( composite_ps30 );
}
DYNAMIC_STATE
{
Assert( pDeferredContext != NULL );
if ( pDeferredContext->m_bMaterialVarsChanged || !pDeferredContext->HasCommands( CDeferredPerMaterialContextData::DEFSTAGE_COMPOSITE )
|| building_cubemaps.GetBool() )
{
tmpBuf.Reset();
if ( bAlphatest )
{
PARM_VALIDATE( info.iAlphatestRef );
tmpBuf.SetPixelShaderConstant1( 0, PARM_FLOAT( info.iAlphatestRef ) );
}
if ( bAlbedo )
tmpBuf.BindTexture( pShader, SHADER_SAMPLER0, info.iAlbedo );
else
tmpBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY );
if ( bEnvmap )
{
if ( building_cubemaps.GetBool() )
tmpBuf.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_BLACK );
else
{
if ( PARM_TEX( info.iEnvmap ) && !bModel )
tmpBuf.BindTexture( pShader, SHADER_SAMPLER3, info.iEnvmap );
else
tmpBuf.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_LOCAL_ENV_CUBEMAP );
}
if ( bEnvmapMask )
tmpBuf.BindTexture( pShader, SHADER_SAMPLER4, info.iEnvmapMask );
if ( bAlbedo2 )
{
if ( bEnvmapMask2 )
tmpBuf.BindTexture( pShader, SHADER_SAMPLER7, info.iEnvmapMask2 );
else
tmpBuf.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_WHITE );
}
tmpBuf.SetPixelShaderConstant( 5, info.iEnvmapTint );
float fl6[4] = { 0 };
fl6[0] = PARM_FLOAT( info.iEnvmapSaturation );
fl6[1] = PARM_FLOAT( info.iEnvmapContrast );
tmpBuf.SetPixelShaderConstant( 6, fl6 );
}
if ( bNeedsFresnel )
{
tmpBuf.SetPixelShaderConstant( 7, info.iFresnelRanges );
}
if ( bRimLight )
{
float fl9[4] = { 0 };
fl9[0] = PARM_FLOAT( info.iRimlightExponent );
fl9[1] = PARM_FLOAT( info.iRimlightAlbedoScale );
tmpBuf.SetPixelShaderConstant( 9, fl9 );
}
if ( bAlbedo2 )
{
tmpBuf.BindTexture( pShader, SHADER_SAMPLER5, info.iAlbedo2 );
if ( bBlendmodulate )
{
tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, info.iBlendmodulateTransform );
tmpBuf.BindTexture( pShader, SHADER_SAMPLER6, info.iBlendmodulate );
}
}
if ( bMultiBlend )
{
tmpBuf.BindTexture( pShader, SHADER_SAMPLER7, info.iAlbedo3 );
if ( bAlbedo4 )
tmpBuf.BindTexture( pShader, SHADER_SAMPLER8, info.iAlbedo4 );
else
tmpBuf.BindStandardTexture( SHADER_SAMPLER8, TEXTURE_WHITE );
if ( bBlendmodulate )
{
tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_3, info.iBlendmodulateTransform2 );
tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, info.iBlendmodulateTransform3 );
if ( bBlendmodulate2 )
tmpBuf.BindTexture( pShader, SHADER_SAMPLER9, info.iBlendmodulate2 );
else
tmpBuf.BindStandardTexture( SHADER_SAMPLER9, TEXTURE_BLACK );
if ( bBlendmodulate3 )
tmpBuf.BindTexture( pShader, SHADER_SAMPLER10, info.iBlendmodulate3 );
else
tmpBuf.BindStandardTexture( SHADER_SAMPLER10, TEXTURE_BLACK );
}
}
if ( bSelfIllum && bSelfIllumMask )
{
tmpBuf.BindTexture( pShader, SHADER_SAMPLER4, info.iSelfIllumMask );
}
int x, y, w, t;
pShaderAPI->GetCurrentViewport( x, y, w, t );
float fl1[4] = { 1.0f / w, 1.0f / t, 0, 0 };
tmpBuf.SetPixelShaderConstant( 1, fl1 );
tmpBuf.SetPixelShaderFogParams( 2 );
float fl4 = { PARM_FLOAT( info.iPhongScale ) };
tmpBuf.SetPixelShaderConstant1( 4, fl4 );
tmpBuf.End();
pDeferredContext->SetCommands( CDeferredPerMaterialContextData::DEFSTAGE_COMPOSITE, tmpBuf.Copy() );
}
pShaderAPI->SetDefaultState();
if ( bModel && bFastVTex )
pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, VERTEX_SHADER_SHADER_SPECIFIC_CONST_11, SHADER_VERTEXTEXTURE_SAMPLER0 );
DECLARE_DYNAMIC_VERTEX_SHADER( composite_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (bModel && (int)vertexCompression) ? 1 : 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, (bModel && pShaderAPI->GetCurrentNumBones() > 0) ? 1 : 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, (bModel && pShaderAPI->IsHWMorphingEnabled()) ? 1 : 0 );
SET_DYNAMIC_VERTEX_SHADER( composite_vs30 );
DECLARE_DYNAMIC_PIXEL_SHADER( composite_ps30 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( composite_ps30 );
if ( bModel && bFastVTex )
{
bool bUnusedTexCoords[3] = { false, true, !pShaderAPI->IsHWMorphingEnabled() || !bIsDecal };
pShaderAPI->MarkUnusedVertexFields( 0, 3, bUnusedTexCoords );
}
pShaderAPI->ExecuteCommandBuffer( pDeferredContext->GetCommands( CDeferredPerMaterialContextData::DEFSTAGE_COMPOSITE ) );
if ( bGBufferNormal )
pShader->BindTexture( SHADER_SAMPLER1, GetDeferredExt()->GetTexture_Normals() );
pShader->BindTexture( SHADER_SAMPLER2, GetDeferredExt()->GetTexture_LightAccum() );
CommitBaseDeferredConstants_Origin( pShaderAPI, 3 );
if ( bWorldEyeVec )
{
float vEyepos[4] = {0,0,0,0};
pShaderAPI->GetWorldSpaceCameraPosition( vEyepos );
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, vEyepos );
}
if ( bRimLight )
{
pShaderAPI->SetPixelShaderConstant( 8, params[ info.iRimlightTint ]->GetVecValue() );
}
if ( bSelfIllum )
{
pShaderAPI->SetPixelShaderConstant( 10, params[ info.iSelfIllumTint ]->GetVecValue() );
}
}
pShader->Draw();
}
void DrawLightmappedGeneric_DX9( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow,
LightmappedGeneric_DX9_Vars_t &info, CBasePerMaterialContextData **pContextDataPtr, bool bDeferredActive )
{
//bool bDeferredActive = GetDeferredExt()->IsDeferredLightingEnabled();
bool bSinglePassFlashlight = true;
bool hasFlashlight = !bDeferredActive && pShader->UsingFlashlight( params );
CLightmappedGeneric_DX9_Context *pContextData = reinterpret_cast< CLightmappedGeneric_DX9_Context *> ( *pContextDataPtr );
bool bShaderSrgbRead = ( IsX360() && IS_PARAM_DEFINED( info.m_nShaderSrgbRead360 ) && params[info.m_nShaderSrgbRead360]->GetIntValue() );
const bool bHasFoW = true; //( ( info.m_nFoW != -1 ) && ( params[ info.m_nFoW ]->IsTexture() != 0 ) );
if ( pShaderShadow || ( ! pContextData )|| pContextData->m_bMaterialVarsChanged || pContextData->m_bNeedsCmdRegen || ( hasFlashlight && !IsX360() ) )
{
bool hasBaseTexture = params[info.m_nBaseTexture]->IsTexture();
int nAlphaChannelTextureVar = hasBaseTexture ? (int)info.m_nBaseTexture : (int)info.m_nEnvmapMask;
BlendType_t nBlendType = pShader->EvaluateBlendRequirements( nAlphaChannelTextureVar, hasBaseTexture );
bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0;
bool bFullyOpaqueWithoutAlphaTest = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && (!hasFlashlight || IsX360()); //dest alpha is free for special use
bool bFullyOpaque = bFullyOpaqueWithoutAlphaTest && !bIsAlphaTested;
bool bNeedRegenStaticCmds = (! pContextData ) || pShaderShadow || pContextData->m_bNeedsCmdRegen;
if ( ! pContextData ) // make sure allocated
{
pContextData = new CLightmappedGeneric_DX9_Context;
*pContextDataPtr = pContextData;
}
bool hasBump = ( params[info.m_nBumpmap]->IsTexture() ) && g_pConfig->UseBumpmapping();
bool hasSSBump = hasBump && (info.m_nSelfShadowedBumpFlag != -1) && ( params[info.m_nSelfShadowedBumpFlag]->GetIntValue() );
bool hasBaseTexture2 = hasBaseTexture && params[info.m_nBaseTexture2]->IsTexture();
bool hasLightWarpTexture = params[info.m_nLightWarpTexture]->IsTexture();
bool hasBump2 = hasBump && params[info.m_nBumpmap2]->IsTexture();
bool hasDetailTexture = params[info.m_nDetail]->IsTexture();
bool hasSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM );
bool hasBumpMask = hasBump && hasBump2 && params[info.m_nBumpMask]->IsTexture() && !hasSelfIllum &&
!hasDetailTexture && !hasBaseTexture2 && (params[info.m_nBaseTextureNoEnvmap]->GetIntValue() == 0);
bool bHasBlendModulateTexture =
(info.m_nBlendModulateTexture != -1) &&
(params[info.m_nBlendModulateTexture]->IsTexture() );
bool hasNormalMapAlphaEnvmapMask = g_pConfig->UseSpecular() && IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK );
if( g_pConfig->bEditMode )
{
hasBump = false;
hasBump2 = false;
}
bool bParallaxMapping = false;
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
bParallaxMapping = ( info.m_nParallaxMap != -1 ) && ( params[info.m_nParallaxMap]->GetIntValue() != 0 );
if ( hasFlashlight && !IsX360() )
{
// !!speed!! do this in the caller so we don't build struct every time
CBaseVSShader::DrawFlashlight_dx90_Vars_t vars;
vars.m_bBump = hasBump;
vars.m_nBumpmapVar = info.m_nBumpmap;
vars.m_nBumpmapFrame = info.m_nBumpFrame;
vars.m_nBumpTransform = info.m_nBumpTransform;
vars.m_nFlashlightTextureVar = info.m_nFlashlightTexture;
vars.m_nFlashlightTextureFrameVar = info.m_nFlashlightTextureFrame;
vars.m_bLightmappedGeneric = true;
vars.m_bWorldVertexTransition = hasBaseTexture2;
vars.m_nBaseTexture2Var = info.m_nBaseTexture2;
vars.m_nBaseTexture2FrameVar = info.m_nBaseTexture2Frame;
vars.m_nBumpmap2Var = info.m_nBumpmap2;
vars.m_nBumpmap2Frame = info.m_nBumpFrame2;
vars.m_nBump2Transform = info.m_nBumpTransform2;
vars.m_nAlphaTestReference = info.m_nAlphaTestReference;
vars.m_bSSBump = hasSSBump;
vars.m_nDetailVar = info.m_nDetail;
vars.m_nDetailScale = info.m_nDetailScale;
vars.m_nDetailTextureCombineMode = info.m_nDetailTextureCombineMode;
vars.m_nDetailTextureBlendFactor = info.m_nDetailTextureBlendFactor;
vars.m_nDetailTint = info.m_nDetailTint;
if ( ( info.m_nSeamlessMappingScale != -1 ) )
vars.m_fSeamlessScale = params[info.m_nSeamlessMappingScale]->GetFloatValue();
else
vars.m_fSeamlessScale = 0.0;
pShader->DrawFlashlight_dx90( params, pShaderAPI, pShaderShadow, vars );
return;
}
pContextData->m_bFullyOpaque = bFullyOpaque;
pContextData->m_bFullyOpaqueWithoutAlphaTest = bFullyOpaqueWithoutAlphaTest;
bool bHasOutline = IsBoolSet( info.m_nOutline, params );
pContextData->m_bPixelShaderForceFastPathBecauseOutline = bHasOutline;
bool bHasSoftEdges = IsBoolSet( info.m_nSoftEdges, params );
bool hasEnvmapMask = params[info.m_nEnvmapMask]->IsTexture() && !bHasFoW;
float fDetailBlendFactor = GetFloatParam( info.m_nDetailTextureBlendFactor, params, 1.0 );
if ( pShaderShadow || bNeedRegenStaticCmds )
{
bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
bool hasDiffuseBumpmap = hasBump && (params[info.m_nNoDiffuseBumpLighting]->GetIntValue() == 0);
bool hasEnvmap = params[info.m_nEnvmap]->IsTexture();
int envmap_variant; //0 = no envmap, 1 = regular, 2 = darken in shadow mode
if( hasEnvmap )
{
//only enabled darkened cubemap mode when the scale calls for it. And not supported in ps20 when also using a 2nd bumpmap
envmap_variant = ((GetFloatParam( info.m_nEnvMapLightScale, params ) > 0.0f) && (g_pHardwareConfig->SupportsPixelShaders_2_b() || !hasBump2)) ? 2 : 1;
}
else
{
envmap_variant = 0;
}
bool bSeamlessMapping = ( ( info.m_nSeamlessMappingScale != -1 ) &&
( params[info.m_nSeamlessMappingScale]->GetFloatValue() != 0.0 ) );
if ( bNeedRegenStaticCmds )
{
pContextData->m_bNeedsCmdRegen = false;
pContextData->ResetStaticCmds();
CCommandBufferBuilder< CFixedCommandStorageBuffer< 5000 > > staticCmdsBuf;
int nLightingPreviewMode = !bHasFoW ? IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER0 ) + 2 * IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER1 ) : 0;
if ( ( nLightingPreviewMode == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH ) && IsPC() )
{
staticCmdsBuf.SetVertexShaderNearAndFarZ( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6 ); // Needed for SSAO
}
if( !hasBaseTexture )
{
if( hasEnvmap )
{
// if we only have an envmap (no basetexture), then we want the albedo to be black.
staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_BLACK );
}
else
{
staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE );
}
}
staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
if ( g_pConfig->m_bPaintInGame && !r_twopasspaint.GetBool() )
{
staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER9, TEXTURE_PAINT );
}
if ( bSeamlessMapping )
{
staticCmdsBuf.SetVertexShaderConstant4(
VERTEX_SHADER_SHADER_SPECIFIC_CONST_0,
params[info.m_nSeamlessMappingScale]->GetFloatValue(),0,0,0 );
}
staticCmdsBuf.StoreEyePosInPixelShaderConstant( 10 );
staticCmdsBuf.SetPixelShaderFogParams( 11 );
staticCmdsBuf.End();
// now, copy buf
pContextData->m_pStaticCmds = new uint8[staticCmdsBuf.Size()];
memcpy( pContextData->m_pStaticCmds, staticCmdsBuf.Base(), staticCmdsBuf.Size() );
}
if ( pShaderShadow )
{
// Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState
pShaderShadow->EnableAlphaTest( bIsAlphaTested );
if ( info.m_nAlphaTestReference != -1 && params[info.m_nAlphaTestReference]->GetFloatValue() > 0.0f )
{
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[info.m_nAlphaTestReference]->GetFloatValue() );
}
pShader->SetDefaultBlendingShadowState( nAlphaChannelTextureVar, hasBaseTexture );
unsigned int flags = VERTEX_POSITION;
// base texture
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, !bShaderSrgbRead );
if ( g_pConfig->m_bPaintInGame && !r_twopasspaint.GetBool() )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER9, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER9, !bShaderSrgbRead );
}
if ( hasLightWarpTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER6, false );
}
if ( bHasBlendModulateTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, false );
}
if ( hasBaseTexture2 )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER7, !bShaderSrgbRead );
}
// if( hasLightmap )
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );
}
else
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false );
}
if( hasEnvmap || ( IsX360() && hasFlashlight ) )
{
if( hasEnvmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
}
}
flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T | VERTEX_NORMAL;
}
#define TCOMBINE_NONE 12 // there is no detail texture
int nDetailBlendMode = TCOMBINE_NONE;
if ( hasDetailTexture )
{
nDetailBlendMode = GetIntParam( info.m_nDetailTextureCombineMode, params );
ITexture *pDetailTexture = params[info.m_nDetail]->GetTextureValue();
if ( pDetailTexture->GetFlags() & TEXTUREFLAGS_SSBUMP )
{
if ( hasBump )
nDetailBlendMode = 10; // ssbump
else
nDetailBlendMode = 11; // ssbump_nobump
}
pShaderShadow->EnableTexture( SHADER_SAMPLER12, true );
bool bSRGBState = ( nDetailBlendMode == 1 );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER12, bSRGBState );
}
// Hijack detail blend mode 9 for paint (this blend mode was previously skipped/unused in lightmappedgeneric)
if ( g_pConfig->m_bPaintInGame && !r_twopasspaint.GetBool() )
{
nDetailBlendMode = 9;
}
if( hasBump || hasNormalMapAlphaEnvmapMask )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
}
if( hasBump2 )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
}
if( hasBumpMask )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER8, true );
}
if( hasEnvmapMask )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
}
if( bHasFoW )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER13, true );
}
if( bDeferredActive )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER14, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER15, true );
}
if( hasFlashlight && IsX360() )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER13, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER14, true );
pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER14 );
pShaderShadow->EnableTexture( SHADER_SAMPLER15, true );
}
if( hasVertexColor || hasBaseTexture2 || hasBump2 )
{
flags |= VERTEX_COLOR;
}
// texcoord0 : base texcoord
// texcoord1 : lightmap texcoord
// texcoord2 : lightmap texcoord offset
int numTexCoords;
// if ( pShaderAPI->InEditorMode() )
// if ( pShader->CanUseEditorMaterials() )
// {
// numTexCoords = 1;
// }
// else
{
numTexCoords = 2;
if( hasBump )
{
numTexCoords = 3;
}
}
int nLightingPreviewMode = !bHasFoW ? IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER0 ) + 2 * IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER1 ) : 0;
pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, 0 );
// Pre-cache pixel shaders
bool hasBaseAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_BASEALPHAENVMAPMASK );
int bumpmap_variant=(hasSSBump) ? 2 : hasBump;
bool bMaskedBlending=( (info.m_nMaskedBlending != -1) &&
(params[info.m_nMaskedBlending]->GetIntValue() != 0) );
if( bDeferredActive )
{
DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_deferred_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, hasEnvmapMask );
SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, params[info.m_nEnvmap]->IsTexture() );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, hasBaseTexture2 || hasBump2 );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, hasBumpMask );
SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode );
SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, bParallaxMapping );
SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture );
SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_VERTEX_SHADER_COMBO( FOW, bHasFoW );
SET_STATIC_VERTEX_SHADER( lightmappedgeneric_deferred_vs30 );
DECLARE_STATIC_PIXEL_SHADER( lightmappedgeneric_deferred_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, hasBaseTexture2 );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, bumpmap_variant );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP2, hasBump2 );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMASK, hasBumpMask );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, envmap_variant );
SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, hasEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( BASEALPHAENVMAPMASK, hasBaseAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURENOENVMAP, params[info.m_nBaseTextureNoEnvmap]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2NOENVMAP, params[info.m_nBaseTexture2NoEnvmap]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( WARPLIGHTING, hasLightWarpTexture );
SET_STATIC_PIXEL_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture );
SET_STATIC_PIXEL_SHADER_COMBO( MASKEDBLENDING, bMaskedBlending);
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( OUTLINE, bHasOutline );
SET_STATIC_PIXEL_SHADER_COMBO( SOFTEDGES, bHasSoftEdges );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode );
SET_STATIC_PIXEL_SHADER_COMBO( PARALLAX_MAPPING, bParallaxMapping );
SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead );
SET_STATIC_PIXEL_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode );
SET_STATIC_PIXEL_SHADER( lightmappedgeneric_deferred_ps30 );
}
else
{
DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, hasEnvmapMask );
SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, params[info.m_nEnvmap]->IsTexture() );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump );
SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) );
SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, hasBaseTexture2 || hasBump2 );
SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, hasBumpMask );
SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode );
SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, bParallaxMapping );
SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture );
SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_VERTEX_SHADER_COMBO( FOW, bHasFoW );
SET_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
DECLARE_STATIC_PIXEL_SHADER( lightmappedgeneric_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, hasBaseTexture2 );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, bumpmap_variant );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP2, hasBump2 );
SET_STATIC_PIXEL_SHADER_COMBO( BUMPMASK, hasBumpMask );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, envmap_variant );
SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, hasEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( BASEALPHAENVMAPMASK, hasBaseAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURENOENVMAP, params[info.m_nBaseTextureNoEnvmap]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2NOENVMAP, params[info.m_nBaseTexture2NoEnvmap]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( WARPLIGHTING, hasLightWarpTexture );
SET_STATIC_PIXEL_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture );
SET_STATIC_PIXEL_SHADER_COMBO( MASKEDBLENDING, bMaskedBlending);
SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping );
SET_STATIC_PIXEL_SHADER_COMBO( OUTLINE, bHasOutline );
SET_STATIC_PIXEL_SHADER_COMBO( SOFTEDGES, bHasSoftEdges );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode );
SET_STATIC_PIXEL_SHADER_COMBO( PARALLAX_MAPPING, bParallaxMapping );
SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead );
SET_STATIC_PIXEL_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode );
SET_STATIC_PIXEL_SHADER( lightmappedgeneric_ps30 );
}
// HACK HACK HACK - enable alpha writes all the time so that we have them for
// underwater stuff and writing depth to dest alpha
// But only do it if we're not using the alpha already for translucency
pShaderShadow->EnableAlphaWrites( bFullyOpaque );
pShaderShadow->EnableSRGBWrite( true );
pShader->DefaultFog();
// NOTE: This isn't optimal. If $color2 is ever changed by a material
// proxy, this code won't get re-run, but too bad. No time to make this work
// Also note that if the lightmap scale factor changes
// all shadow state blocks will be re-run, so that's ok
float flLScale = pShaderShadow->GetLightMapScaleFactor();
pShader->PI_BeginCommandBuffer();
pShader->PI_SetModulationPixelShaderDynamicState( 21 );
// MAINTOL4DMERGEFIXME
// Need to reflect this change which is from this rel changelist since this constant set was moved from the dynamic block to here:
// Change 578692 by Alex@alexv_rel on 2008/06/04 18:07:31
//
// Fix for portalareawindows in ep2 being rendered black. The color variable was being multipurposed for both the vs and ps differently where the ps doesn't care about alpha, but the vs does. Only applying the alpha2 DoD hack to the pixel shader constant where the alpha was never used in the first place and leaving alpha as is for the vs.
// color[3] *= ( IS_PARAM_DEFINED( info.m_nAlpha2 ) && params[ info.m_nAlpha2 ]->GetFloatValue() > 0.0f ) ? params[ info.m_nAlpha2 ]->GetFloatValue() : 1.0f;
// pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 12, color );
pShader->PI_SetModulationPixelShaderDynamicState_LinearScale_ScaleInW( 12, flLScale );
pShader->PI_SetModulationVertexShaderDynamicState_LinearScale( flLScale );
pShader->PI_EndCommandBuffer();
} // end shadow state
} // end shadow || regen display list
if ( pShaderAPI && ( pContextData->m_bMaterialVarsChanged ) )
{
// need to regenerate the semistatic cmds
pContextData->m_SemiStaticCmdsOut.Reset();
pContextData->m_bMaterialVarsChanged = false;
bool bHasBlendMaskTransform= (
(info.m_nBlendMaskTransform != -1) &&
(info.m_nMaskedBlending != -1) &&
(params[info.m_nMaskedBlending]->GetIntValue() ) &&
( ! (params[info.m_nBumpTransform]->MatrixIsIdentity() ) ) );
// 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[info.m_nBaseTextureTransform]->MatrixIsIdentity() &&
params[info.m_nBumpTransform]->MatrixIsIdentity() &&
params[info.m_nBumpTransform2]->MatrixIsIdentity() &&
params[info.m_nEnvmapMaskTransform]->MatrixIsIdentity() );
bHasTextureTransform |= bHasBlendMaskTransform;
pContextData->m_bVertexShaderFastPath = !bHasTextureTransform;
if( params[info.m_nDetail]->IsTexture() )
{
pContextData->m_bVertexShaderFastPath = false;
}
int nTransformToLoad = info.m_nBlendMaskTransform;
if( ( hasBump || hasSSBump ) && hasDetailTexture && !hasSelfIllum && !bHasBlendModulateTexture )
{
nTransformToLoad = info.m_nBumpTransform;
}
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform(
VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, nTransformToLoad );
if ( ! pContextData->m_bVertexShaderFastPath )
{
bool bSeamlessMapping = ( ( info.m_nSeamlessMappingScale != -1 ) &&
( params[info.m_nSeamlessMappingScale]->GetFloatValue() != 0.0 ) );
bool hasEnvmapMask = params[info.m_nEnvmapMask]->IsTexture() && !bHasFoW;
if (!bSeamlessMapping )
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nBaseTextureTransform );
// If we have a detail texture, then the bump texcoords are the same as the base texcoords.
if( hasBump && !hasDetailTexture )
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBumpTransform );
}
if( hasEnvmapMask )
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nEnvmapMaskTransform );
}
else if ( hasBump2 )
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nBumpTransform2 );
}
}
pContextData->m_SemiStaticCmdsOut.SetEnvMapTintPixelShaderDynamicState( 0, info.m_nEnvmapTint );
if ( hasDetailTexture )
{
float detailTintAndBlend[4] = {1, 1, 1, 1};
if ( info.m_nDetailTint != -1 )
{
params[info.m_nDetailTint]->GetVecValue( detailTintAndBlend, 3 );
}
detailTintAndBlend[3] = fDetailBlendFactor;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 8, detailTintAndBlend );
}
float envmapTintVal[4];
float selfIllumTintVal[4];
params[info.m_nEnvmapTint]->GetVecValue( envmapTintVal, 3 );
params[info.m_nSelfIllumTint]->GetVecValue( selfIllumTintVal, 3 );
float envmapContrast = params[info.m_nEnvmapContrast]->GetFloatValue();
float envmapSaturation = params[info.m_nEnvmapSaturation]->GetFloatValue();
float fresnelReflection = params[info.m_nFresnelReflection]->GetFloatValue();
bool hasEnvmap = params[info.m_nEnvmap]->IsTexture();
int envmap_variant; //0 = no envmap, 1 = regular, 2 = darken in shadow mode
if( hasEnvmap )
{
//only enabled darkened cubemap mode when the scale calls for it. And not supported in ps20 when also using a 2nd bumpmap
envmap_variant = ((GetFloatParam( info.m_nEnvMapLightScale, params ) > 0.0f) && (g_pHardwareConfig->SupportsPixelShaders_2_b() || !hasBump2)) ? 2 : 1;
}
else
{
envmap_variant = 0;
}
pContextData->m_bPixelShaderFastPath = true;
bool bUsingContrastOrSaturation = hasEnvmap && ( ( (envmapContrast != 0.0f) && (envmapContrast != 1.0f) ) || (envmapSaturation != 1.0f) );
bool bUsingFresnel = hasEnvmap && (fresnelReflection != 1.0f);
bool bUsingSelfIllumTint = IS_FLAG_SET(MATERIAL_VAR_SELFILLUM) && (selfIllumTintVal[0] != 1.0f || selfIllumTintVal[1] != 1.0f || selfIllumTintVal[2] != 1.0f);
if ( bUsingContrastOrSaturation || bUsingFresnel || bUsingSelfIllumTint || !g_pConfig->bShowSpecular )
{
pContextData->m_bPixelShaderFastPath = false;
}
if( !pContextData->m_bPixelShaderFastPath )
{
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstants( 2, 3 );
pContextData->m_SemiStaticCmdsOut.OutputConstantData( params[info.m_nEnvmapContrast]->GetVecValue() );
pContextData->m_SemiStaticCmdsOut.OutputConstantData( params[info.m_nEnvmapSaturation]->GetVecValue() );
float flFresnel = params[info.m_nFresnelReflection]->GetFloatValue();
// [ 0, 0, 1-R(0), R(0) ]
pContextData->m_SemiStaticCmdsOut.OutputConstantData4( 0., 0., 1.0 - flFresnel, flFresnel );
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 7, params[info.m_nSelfIllumTint]->GetVecValue() );
}
else
{
if ( bHasOutline )
{
float flOutlineParms[8] = { GetFloatParam( info.m_nOutlineStart0, params ),
GetFloatParam( info.m_nOutlineStart1, params ),
GetFloatParam( info.m_nOutlineEnd0, params ),
GetFloatParam( info.m_nOutlineEnd1, params ),
0,0,0,
GetFloatParam( info.m_nOutlineAlpha, params ) };
if ( info.m_nOutlineColor != -1 )
{
params[info.m_nOutlineColor]->GetVecValue( flOutlineParms + 4, 3 );
}
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 2, flOutlineParms, 2 );
}
if ( bHasSoftEdges )
{
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant4(
4, GetFloatParam( info.m_nEdgeSoftnessStart, params ),
GetFloatParam( info.m_nEdgeSoftnessEnd, params ),
0,0 );
}
}
// parallax and cubemap light scale mapping parms (c20)
if ( bParallaxMapping || (envmap_variant == 2) )
{
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant4( 20, GetFloatParam( info.m_nHeightScale, params), GetFloatParam( info.m_nEnvMapLightScale, params), 0, 0 );
}
// texture binds
if( hasBaseTexture )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER0, info.m_nBaseTexture, info.m_nBaseTextureFrame );
}
// handle mat_fullbright 2
bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE );
if( bLightingOnly )
{
// BASE TEXTURE
if( hasSelfIllum )
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY_ALPHA_ZERO );
}
else
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY );
}
// BASE TEXTURE 2
if( hasBaseTexture2 )
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_GREY );
}
// DETAIL TEXTURE
if( hasDetailTexture )
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER12, TEXTURE_GREY );
}
// disable color modulation
float color[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
pContextData->m_SemiStaticCmdsOut.SetVertexShaderConstant( VERTEX_SHADER_MODULATION_COLOR, color );
// turn off environment mapping
envmapTintVal[0] = 0.0f;
envmapTintVal[1] = 0.0f;
envmapTintVal[2] = 0.0f;
}
// always set the transform for detail textures since I'm assuming that you'll
// always have a detailscale.
if( hasDetailTexture )
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBaseTextureTransform, info.m_nDetailScale );
}
if( hasBaseTexture2 )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER7, info.m_nBaseTexture2, info.m_nBaseTexture2Frame );
}
if( hasDetailTexture )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nDetail, info.m_nDetailFrame );
}
if( hasBump || hasNormalMapAlphaEnvmapMask )
{
if( !g_pConfig->m_bFastNoBump )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER4, info.m_nBumpmap, info.m_nBumpFrame );
}
else
{
if( hasSSBump )
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER4, TEXTURE_SSBUMP_FLAT );
}
else
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALMAP_FLAT );
}
}
}
if( hasBump2 )
{
if( !g_pConfig->m_bFastNoBump )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER5, info.m_nBumpmap2, info.m_nBumpFrame2 );
}
else
{
if( hasSSBump )
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALMAP_FLAT );
}
else
{
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SSBUMP_FLAT );
}
}
}
if( hasBumpMask )
{
if( !g_pConfig->m_bFastNoBump )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER8, info.m_nBumpMask, -1 );
}
else
{
// this doesn't make sense
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER8, TEXTURE_NORMALMAP_FLAT );
}
}
if( hasEnvmapMask )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER5, info.m_nEnvmapMask, info.m_nEnvmapMaskFrame );
}
if ( hasLightWarpTexture )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER6, info.m_nLightWarpTexture, -1 );
}
if ( bHasBlendModulateTexture )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER3, info.m_nBlendModulateTexture, -1 );
}
if ( hasFlashlight && IsX360() )
{
pContextData->m_SemiStaticCmdsOut.SetVertexShaderFlashlightState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6 );
CBCmdSetPixelShaderFlashlightState_t state;
state.m_LightSampler = SHADER_SAMPLER13;
state.m_DepthSampler = SHADER_SAMPLER14;
state.m_ShadowNoiseSampler = SHADER_SAMPLER15;
state.m_nColorConstant = 28;
state.m_nAttenConstant = 13;
state.m_nOriginConstant = 14;
state.m_nDepthTweakConstant = 19;
state.m_nScreenScaleConstant = 31;
state.m_nWorldToTextureConstant = -1;
state.m_bFlashlightNoLambert = false;
state.m_bSinglePassFlashlight = bSinglePassFlashlight;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderFlashlightState( state );
}
pContextData->m_SemiStaticCmdsOut.End();
}
}
DYNAMIC_STATE
{
CCommandBufferBuilder< CFixedCommandStorageBuffer< 1000 > > DynamicCmdsOut;
DynamicCmdsOut.Call( pContextData->m_pStaticCmds );
DynamicCmdsOut.Call( pContextData->m_SemiStaticCmdsOut.Base() );
bool hasEnvmap = params[info.m_nEnvmap]->IsTexture();
if( hasEnvmap )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER2, info.m_nEnvmap, info.m_nEnvmapFrame );
}
bool bVertexShaderFastPath = pContextData->m_bVertexShaderFastPath;
int nFixedLightingMode = pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_ENABLE_FIXED_LIGHTING );
if( nFixedLightingMode != ENABLE_FIXED_LIGHTING_NONE )
{
if ( pContextData->m_bPixelShaderForceFastPathBecauseOutline )
{
nFixedLightingMode = ENABLE_FIXED_LIGHTING_NONE;
}
else
{
bVertexShaderFastPath = false;
}
}
bool bWorldNormal = ( nFixedLightingMode == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH );
if ( bWorldNormal && IsPC() )
{
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;
DynamicCmdsOut.SetVertexShaderConstant4( 12, vEyeDir[0], vEyeDir[1], vEyeDir[2], 1.0f );
}
MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode();
if( bDeferredActive )
{
DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_deferred_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath );
SET_DYNAMIC_VERTEX_SHADER_CMD( DynamicCmdsOut, lightmappedgeneric_deferred_vs30 );
}
else
{
DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath );
SET_DYNAMIC_VERTEX_SHADER_CMD( DynamicCmdsOut, lightmappedgeneric_vs30 );
}
bool bPixelShaderFastPath = pContextData->m_bPixelShaderFastPath;
if ( nFixedLightingMode != ENABLE_FIXED_LIGHTING_NONE )
{
bPixelShaderFastPath = false;
}
bool bWriteDepthToAlpha;
bool bWriteWaterFogToAlpha;
if( pContextData->m_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;
}
if( bHasFoW )
{
if( ( info.m_nFoW != -1 ) && ( params[ info.m_nFoW ]->IsTexture() != 0 ) )
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER13, info.m_nFoW, -1 );
else
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER13, TEXTURE_WHITE );
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;
DynamicCmdsOut.SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_12, vFoWSize );
}
if( bDeferredActive )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER14, GetDeferredExt()->GetTexture_LightAccum(), 0 );
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER15, GetDeferredExt()->GetTexture_LightAccum2(), 0 );
//DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER14, TEXTURE_WHITE );
int x, y, w, t;
pShaderAPI->GetCurrentViewport( x, y, w, t );
float fl1[4] = { 1.0f / w, 1.0f / t, 0, 0 };
DynamicCmdsOut.SetPixelShaderConstant( PSREG_UBERLIGHT_SMOOTH_EDGE_0, fl1 );
}
bool bFlashlightShadows = false;
bool bUberlight = false;
if( hasFlashlight && IsX360() )
{
pShaderAPI->GetFlashlightShaderInfo( &bFlashlightShadows, &bUberlight );
}
else
{
// only do ambient light when not using flashlight
static ConVarRef mat_ambient_light_r_forced( "mat_ambient_light_r_forced" );
static ConVarRef mat_ambient_light_g_forced( "mat_ambient_light_g_forced" );
static ConVarRef mat_ambient_light_b_forced( "mat_ambient_light_b_forced" );
float vAmbientColor[4] = { mat_ambient_light_r_forced.GetFloat() != -1.0f ? mat_ambient_light_r_forced.GetFloat() : mat_ambient_light_r.GetFloat(),
mat_ambient_light_g_forced.GetFloat() != -1.0f ? mat_ambient_light_g_forced.GetFloat() : mat_ambient_light_g.GetFloat(),
mat_ambient_light_b_forced.GetFloat() != -1.0f ? mat_ambient_light_b_forced.GetFloat() : mat_ambient_light_b.GetFloat(),
0.0f };
if ( mat_fullbright.GetInt() == 1 )
{
vAmbientColor[0] = vAmbientColor[1] = vAmbientColor[2] = 0.0f;
}
DynamicCmdsOut.SetPixelShaderConstant( 31, vAmbientColor, 1 );
}
float envmapContrast = params[info.m_nEnvmapContrast]->GetFloatValue();
if( bDeferredActive )
{
DECLARE_DYNAMIC_PIXEL_SHADER( lightmappedgeneric_deferred_ps30);
SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATH, bPixelShaderFastPath || pContextData->m_bPixelShaderForceFastPathBecauseOutline );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATHENVMAPCONTRAST, bPixelShaderFastPath && envmapContrast == 1.0f );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, /*bFlashlightShadows*/ 0 );
SET_DYNAMIC_PIXEL_SHADER_CMD( DynamicCmdsOut, lightmappedgeneric_deferred_ps30 );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( lightmappedgeneric_ps30 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATH, bPixelShaderFastPath || pContextData->m_bPixelShaderForceFastPathBecauseOutline );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATHENVMAPCONTRAST, bPixelShaderFastPath && envmapContrast == 1.0f );
// Don't write fog to alpha if we're using translucency
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows );
SET_DYNAMIC_PIXEL_SHADER_CMD( DynamicCmdsOut, lightmappedgeneric_ps30 );
}
DynamicCmdsOut.End();
pShaderAPI->ExecuteCommandBuffer( DynamicCmdsOut.Base() );
}
pShader->Draw();
if( !bDeferredActive && IsPC() && (IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0) && pContextData->m_bFullyOpaqueWithoutAlphaTest )
{
//Alpha testing makes it so we can't write to dest alpha
//Writing to depth makes it so later polygons can't write to dest alpha either
//This leads to situations with garbage in dest alpha.
//Fix it now by converting depth to dest alpha for any pixels that just wrote.
pShader->DrawEqualDepthToDestAlpha();
}
}
//-----------------------------------------------------------------------------
// Draws the shader
//-----------------------------------------------------------------------------
void DrawSkin_DX9_Internal( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow,
bool bHasFlashlight, VertexLitGeneric_DX9_Vars_t &info, VertexCompressionType_t vertexCompression,
CBasePerMaterialContextData **pContextDataPtr )
{
bool bHasBaseTexture = (info.m_nBaseTexture != -1) && params[info.m_nBaseTexture]->IsTexture();
bool bHasBump = (info.m_nBumpmap != -1) && params[info.m_nBumpmap]->IsTexture();
bool bHasBaseTextureWrinkle = bHasBaseTexture &&
(info.m_nWrinkle != -1) && params[info.m_nWrinkle]->IsTexture() &&
(info.m_nStretch != -1) && params[info.m_nStretch]->IsTexture();
bool bHasBumpWrinkle = bHasBump &&
(info.m_nNormalWrinkle != -1) && params[info.m_nNormalWrinkle]->IsTexture() &&
(info.m_nNormalStretch != -1) && params[info.m_nNormalStretch]->IsTexture();
bool bHasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
bool bHasVertexAlpha = IS_FLAG_SET( MATERIAL_VAR_VERTEXALPHA );
bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0;
bool bHasSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ) != 0;
bool bHasSelfIllumFresnel = ( bHasSelfIllum ) && ( info.m_nSelfIllumFresnel != -1 ) && ( params[info.m_nSelfIllumFresnel]->GetIntValue() != 0 );
bool bHasSelfIllumMask = ( bHasSelfIllum ) && (info.m_nSelfIllumMask != -1) && params[info.m_nSelfIllumMask]->IsTexture();
// Tie these to specular
bool bHasPhong = (info.m_nPhong != -1) && ( params[info.m_nPhong]->GetIntValue() != 0 );
bool bHasSpecularExponentTexture = (info.m_nPhongExponentTexture != -1) && params[info.m_nPhongExponentTexture]->IsTexture();
bool bHasPhongTintMap = bHasSpecularExponentTexture && (info.m_nPhongAlbedoTint != -1) && ( params[info.m_nPhongAlbedoTint]->GetIntValue() != 0 );
bool bHasDiffuseWarp = (info.m_nDiffuseWarpTexture != -1) && params[info.m_nDiffuseWarpTexture]->IsTexture();
bool bHasPhongWarp = (info.m_nPhongWarpTexture != -1) && params[info.m_nPhongWarpTexture]->IsTexture();
bool bHasNormalMapAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK );
#if !defined( _X360 )
bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL );
#endif
// Rimlight must be set to non-zero to trigger rim light combo (also requires Phong)
bool bHasRimLight = r_rimlight.GetBool() && bHasPhong && (info.m_nRimLight != -1) && ( params[info.m_nRimLight]->GetIntValue() != 0 );
bool bHasRimMaskMap = bHasSpecularExponentTexture && bHasRimLight && (info.m_nRimMask != -1) && ( params[info.m_nRimMask]->GetIntValue() != 0 );
int nDetailBlendMode = ( info.m_nDetailTextureCombineMode == -1 ) ? 0 : params[info.m_nDetailTextureCombineMode]->GetIntValue();
float fBlendFactor=( info.m_nDetailTextureBlendFactor == -1 )? 1 : params[info.m_nDetailTextureBlendFactor]->GetFloatValue();
BlendType_t nBlendType = pShader->EvaluateBlendRequirements( info.m_nBaseTexture, true );
bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !bIsAlphaTested && !bHasFlashlight; //dest alpha is free for special use
bool hasDetailTexture = ( info.m_nDetail != -1 ) && params[info.m_nDetail]->IsTexture();
CSkin_DX9_Context *pContextData = reinterpret_cast< CSkin_DX9_Context *> ( *pContextDataPtr );
if ( ! pContextData )
{
pContextData = new CSkin_DX9_Context;
*pContextDataPtr = pContextData;
}
if( pShader->IsSnapshotting() )
{
// look at color and alphamod stuff.
// Unlit generic never uses the flashlight
bool bHasEnvmap = !bHasFlashlight && params[info.m_nEnvmap]->IsTexture();
bool bHasNormal = params[info.m_nBumpmap]->IsTexture();
bool bCanUseBaseAlphaPhongMaskFastPath = (info.m_nBaseMapAlphaPhongMask != -1) && ( params[info.m_nBaseMapAlphaPhongMask]->GetIntValue() != 0 );
if ( ! ( params[info.m_nBaseTexture]->GetTextureValue()->IsTranslucent() ) )
bCanUseBaseAlphaPhongMaskFastPath = true;
pContextData->m_bFastPath =
(! bHasBump ) &&
(! bHasSpecularExponentTexture ) &&
(! bHasPhongTintMap ) &&
(! bHasPhongWarp ) &&
(! bHasRimLight ) &&
(! hasDetailTexture ) &&
bCanUseBaseAlphaPhongMaskFastPath &&
(! bHasSelfIllum );
// Alpha test: FIXME: shouldn't this be handled in CBaseVSShader::SetInitialShadowState
pShaderShadow->EnableAlphaTest( bIsAlphaTested );
if( info.m_nAlphaTestReference != -1 && params[info.m_nAlphaTestReference]->GetFloatValue() > 0.0f )
{
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[info.m_nAlphaTestReference]->GetFloatValue() );
}
const int nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode();
if( bHasFlashlight )
{
if (params[info.m_nBaseTexture]->IsTexture())
{
pShader->SetAdditiveBlendingShadowState( info.m_nBaseTexture, true );
}
if( bIsAlphaTested )
{
// disable alpha test and use the zfunc zequals since alpha isn't guaranteed to
// be the same on both the regular pass and the flashlight pass.
pShaderShadow->EnableAlphaTest( false );
pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL );
}
pShaderShadow->EnableBlending( true );
pShaderShadow->EnableDepthWrites( false );
// Be sure not to write to dest alpha
pShaderShadow->EnableAlphaWrites( false );
//nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode(); // Based upon vendor and device dependent formats
}
else // not flashlight pass
{
if (params[info.m_nBaseTexture]->IsTexture())
{
pShader->SetDefaultBlendingShadowState( info.m_nBaseTexture, true );
}
if ( bHasEnvmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); // Cubic environment map
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, true );
}
}
}
unsigned int flags = VERTEX_POSITION;
if( bHasNormal )
{
flags |= VERTEX_NORMAL;
}
int userDataSize = 0;
// Always enable...will bind white if nothing specified...
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); // Base (albedo) map
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
if ( bHasBaseTextureWrinkle || bHasBumpWrinkle )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); // Base (albedo) compression map
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER9, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); // Base (albedo) expansion map
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER10, true );
}
if( bHasDiffuseWarp )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); // Diffuse warp texture
}
if( bHasPhongWarp )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); // Specular warp texture
}
// Specular exponent map or dummy
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); // Specular exponent map
if( bHasFlashlight )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); // Shadow depth map
pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER4 );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, false );
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); // Flashlight cookie
userDataSize = 4; // tangent S
}
else
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); // Shadow depth map
pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER4 );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, false );
}
// Always enable, since flat normal will be bound
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); // Normal map
userDataSize = 4; // tangent S
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); // Normalizing cube map
if ( bHasBaseTextureWrinkle || bHasBumpWrinkle )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER11, true ); // Normal compression map
pShaderShadow->EnableTexture( SHADER_SAMPLER12, true ); // Normal expansion map
}
if ( hasDetailTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER13, true );
if ( nDetailBlendMode != 0 ) //Not Mod2X
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER13, true );
}
if ( bHasSelfIllum )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER14, true );
}
if( bHasVertexColor || bHasVertexAlpha )
{
flags |= VERTEX_COLOR;
}
pShaderShadow->EnableSRGBWrite( true );
// texcoord0 : base texcoord, texcoord2 : decal hw morph delta
int pTexCoordDim[3] = { 2, 0, 3 };
int nTexCoordCount = 1;
#ifndef _X360
// Special morphed decal information
if ( bIsDecal && g_pHardwareConfig->HasFastVertexTextures() )
{
nTexCoordCount = 3;
}
#endif
// This shader supports compressed vertices, so OR in that flag:
flags |= VERTEX_FORMAT_COMPRESSED;
pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, pTexCoordDim, userDataSize );
#ifndef _X360
if ( !g_pHardwareConfig->SupportsShaderModel_3_0() )
#endif
{
DECLARE_STATIC_VERTEX_SHADER( sdk_skin_vs20 );
SET_STATIC_VERTEX_SHADER( sdk_skin_vs20 );
// Assume we're only going to get in here if we support 2b
DECLARE_STATIC_PIXEL_SHADER( sdk_skin_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bHasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bHasSelfIllum && !bHasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUMFRESNEL, bHasSelfIllumFresnel && !bHasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( LIGHTWARPTEXTURE, bHasDiffuseWarp && bHasPhong );
SET_STATIC_PIXEL_SHADER_COMBO( PHONGWARPTEXTURE, bHasPhongWarp && bHasPhong );
SET_STATIC_PIXEL_SHADER_COMBO( WRINKLEMAP, bHasBaseTextureWrinkle || bHasBumpWrinkle );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode );
SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHT, bHasRimLight );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
SET_STATIC_PIXEL_SHADER_COMBO( CONVERT_TO_SRGB, 0 );
SET_STATIC_PIXEL_SHADER_COMBO( FASTPATH_NOBUMP, pContextData->m_bFastPath );
SET_STATIC_PIXEL_SHADER( sdk_skin_ps20b );
}
#ifndef _X360
else
{
const bool bFastVertexTextures = g_pHardwareConfig->HasFastVertexTextures();
// The vertex shader uses the vertex id stream
if ( bFastVertexTextures )
SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID );
DECLARE_STATIC_VERTEX_SHADER( sdk_skin_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( DECAL, bIsDecal && bFastVertexTextures );
SET_STATIC_VERTEX_SHADER( sdk_skin_vs30 );
DECLARE_STATIC_PIXEL_SHADER( sdk_skin_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bHasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bHasSelfIllum && !bHasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUMFRESNEL, bHasSelfIllumFresnel && !bHasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( LIGHTWARPTEXTURE, bHasDiffuseWarp && bHasPhong );
SET_STATIC_PIXEL_SHADER_COMBO( PHONGWARPTEXTURE, bHasPhongWarp && bHasPhong );
SET_STATIC_PIXEL_SHADER_COMBO( WRINKLEMAP, bHasBaseTextureWrinkle || bHasBumpWrinkle );
SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode );
SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHT, bHasRimLight );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
SET_STATIC_PIXEL_SHADER_COMBO( CONVERT_TO_SRGB, 0 );
SET_STATIC_PIXEL_SHADER_COMBO( FASTPATH_NOBUMP, pContextData->m_bFastPath );
SET_STATIC_PIXEL_SHADER( sdk_skin_ps30 );
}
#endif
if( bHasFlashlight )
{
pShader->FogToBlack();
}
else
{
pShader->DefaultFog();
}
// HACK HACK HACK - enable alpha writes all the time so that we have them for underwater stuff
pShaderShadow->EnableAlphaWrites( bFullyOpaque );
}
else // not snapshotting -- begin dynamic state
{
static CCommandBufferBuilder< CFixedCommandStorageBuffer< 2000 > > DynamicCmdsOut;
DynamicCmdsOut.Reset();
bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE );
bool bHasEnvmap = !bHasFlashlight && params[info.m_nEnvmap]->IsTexture();
if ( bHasBaseTexture )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER0, info.m_nBaseTexture, info.m_nBaseTextureFrame );
}
else
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE );
}
if ( bHasBaseTextureWrinkle )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER9, info.m_nWrinkle, info.m_nBaseTextureFrame );
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER10, info.m_nStretch, info.m_nBaseTextureFrame );
}
else if ( bHasBumpWrinkle )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER9, info.m_nBaseTexture, info.m_nBaseTextureFrame );
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER10, info.m_nBaseTexture, info.m_nBaseTextureFrame );
}
if( bHasDiffuseWarp && bHasPhong )
{
if ( r_lightwarpidentity.GetBool() )
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER2, TEXTURE_IDENTITY_LIGHTWARP );
}
else
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER2, info.m_nDiffuseWarpTexture, -1 );
}
}
if( bHasPhongWarp )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER1, info.m_nPhongWarpTexture, -1 );
}
if( bHasSpecularExponentTexture && bHasPhong )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER7, info.m_nPhongExponentTexture, -1 );
}
else
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_WHITE );
}
if( !g_pConfig->m_bFastNoBump )
{
if( bHasBump )
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER3, info.m_nBumpmap, info.m_nBumpFrame );
else
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT );
if ( bHasBumpWrinkle )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER11, info.m_nNormalWrinkle, info.m_nBumpFrame );
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nNormalStretch, info.m_nBumpFrame );
}
else if ( bHasBaseTextureWrinkle )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER11, info.m_nBumpmap, info.m_nBumpFrame );
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nBumpmap, info.m_nBumpFrame );
}
}
else
{
if( bHasBump )
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT );
}
if ( bHasBaseTextureWrinkle || bHasBumpWrinkle )
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER11, TEXTURE_NORMALMAP_FLAT );
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER12, TEXTURE_NORMALMAP_FLAT );
}
}
if ( hasDetailTexture )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER13, info.m_nDetail, info.m_nDetailFrame );
}
if ( bHasSelfIllum )
{
if ( bHasSelfIllumMask ) // Separate texture for self illum?
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER14, info.m_nSelfIllumMask, -1 ); // Bind it
}
else // else
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER14, TEXTURE_BLACK ); // Bind dummy
}
}
float vRimBoost[4] = {1, 1, 1, 1};
ITexture *pCascadedDepthTexture = NULL;
LightState_t lightState = { 0, false, false };
bool bFlashlightShadows = false;
if ( bHasFlashlight )
{
Assert( info.m_nFlashlightTexture >= 0 && info.m_nFlashlightTextureFrame >= 0 );
//DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER6, info.m_nFlashlightTexture, info.m_nFlashlightTextureFrame );
VMatrix worldToTexture;
ITexture *pFlashlightDepthTexture;
const FlashlightState_t &flashlightState = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );
bFlashlightShadows = flashlightState.m_bEnableShadows;
if ( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() && flashlightState.m_bEnableShadows )
{
pShader->BindTexture( SHADER_SAMPLER4, pFlashlightDepthTexture );
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SHADOW_NOISE_2D );
}
float atten[4], pos[4], tweaks[4];
SetFlashLightColorFromState( flashlightState, pShaderAPI, PSREG_FLASHLIGHT_COLOR );
//DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER6, info.m_nFlashlightTexture, info.m_nFlashlightTextureFrame );
pShader->BindTexture( SHADER_SAMPLER6, flashlightState.m_pSpotlightTexture, flashlightState.m_nSpotlightTextureFrame );
atten[0] = flashlightState.m_fConstantAtten; // Set the flashlight attenuation factors
atten[1] = flashlightState.m_fLinearAtten;
atten[2] = flashlightState.m_fQuadraticAtten;
atten[3] = flashlightState.m_FarZ;
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, atten, 1 );
pos[0] = flashlightState.m_vecLightOrigin[0]; // Set the flashlight origin
pos[1] = flashlightState.m_vecLightOrigin[1];
pos[2] = flashlightState.m_vecLightOrigin[2];
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_POSITION_RIM_BOOST, pos, 1 ); // steps on rim boost
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_TO_WORLD_TEXTURE, worldToTexture.Base(), 4 );
// Tweaks associated with a given flashlight
tweaks[0] = ShadowFilterFromState( flashlightState );
tweaks[1] = ShadowAttenFromState( flashlightState );
pShader->HashShadow2DJitter( flashlightState.m_flShadowJitterSeed, &tweaks[2], &tweaks[3] );
DynamicCmdsOut.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 );
vScreenScale[0] = (float) nWidth / 32.0f;
vScreenScale[1] = (float) nHeight / 32.0f;
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_SCREEN_SCALE, vScreenScale, 1 );
if ( IsX360() )
{
pShaderAPI->SetBooleanPixelShaderConstant( 0, &flashlightState.m_nShadowQuality, 1 );
}
}
else // no flashlight
{
if ( bHasEnvmap )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER8, info.m_nEnvmap, info.m_nEnvmapFrame );
}
// GSTRINGMIGRATION
pShaderAPI->GetDX9LightState( &lightState );
pCascadedDepthTexture = (ITexture*)pShaderAPI->GetIntRenderingParameter( INT_CASCADED_DEPTHTEXTURE );
if ( pCascadedDepthTexture != NULL )
{
pShader->BindTexture( SHADER_SAMPLER4, pCascadedDepthTexture );
VMatrix *worldToTexture0 = (VMatrix*)pShaderAPI->GetIntRenderingParameter( INT_CASCADED_MATRIX_ADDRESS_0 );
DynamicCmdsOut.SetVertexShaderConstant( 240, worldToTexture0->Base(), 4 );
const Vector vecCascadedFwd = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GSTRING_CASCADED_FORWARD );
vRimBoost[0] = vecCascadedFwd.x;
vRimBoost[1] = vecCascadedFwd.y;
vRimBoost[2] = vecCascadedFwd.z;
float vScreenScale[4] = {1280.0f / 32.0f, 720.0f / 32.0f, 0, 0};
int nWidth, nHeight;
pShaderAPI->GetBackBufferDimensions( nWidth, nHeight );
vScreenScale[0] = (float) nWidth / 32.0f;
vScreenScale[1] = (float) nHeight / 32.0f;
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_SCREEN_SCALE, vScreenScale, 1 );
// We have to rebuild the lighting state by hand. Fading static lights are out of order!
float vDirectionalLights[4] = { 0.0f };
SetCustomPixelLightingState( DynamicCmdsOut, lightState, pShaderAPI, PSREG_LIGHT_INFO_ARRAY );
SetCustomVertexLightingState( DynamicCmdsOut, lightState, pShaderAPI, 27, vDirectionalLights );
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_COLOR, vDirectionalLights );
const Vector vecCascadedStep = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GSTRING_CASCADED_STEP );
float vCascadedStep[4] = { XYZ( vecCascadedStep ) };
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_TO_WORLD_TEXTURE, vCascadedStep, 1 );
}
}
if ( pCascadedDepthTexture == NULL )
{
DynamicCmdsOut.CommitPixelShaderLighting( PSREG_LIGHT_INFO_ARRAY );
}
// END GSTRINGMIGRATION
MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode();
int fogIndex = ( fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ) ? 1 : 0;
int numBones = pShaderAPI->GetCurrentNumBones();
bool bWriteDepthToAlpha = false;
bool bWriteWaterFogToAlpha = false;
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." );
}
#ifndef _X360
if ( !g_pHardwareConfig->SupportsShaderModel_3_0() )
#endif
{
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_skin_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, numBones > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, pShaderAPI->GetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING)!=0);
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( sdk_skin_vs20 );
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_skin_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows );
SET_DYNAMIC_PIXEL_SHADER( sdk_skin_ps20b );
}
#ifndef _X360
else
{
const bool bFastVertexTextures = g_pHardwareConfig->HasFastVertexTextures();
const int iCascadedShadowCombo = ( pCascadedDepthTexture != NULL ) ? 1 : 0;
if ( bFastVertexTextures )
pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, SHADER_VERTEXTEXTURE_SAMPLER0 );
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_skin_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, numBones > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, pShaderAPI->GetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING)!=0);
SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, pShaderAPI->IsHWMorphingEnabled() && bFastVertexTextures );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER_COMBO( CASCADED_SHADOW, iCascadedShadowCombo );
SET_DYNAMIC_VERTEX_SHADER( sdk_skin_vs30 );
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_skin_ps30 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows );
SET_DYNAMIC_PIXEL_SHADER_COMBO( CASCADED_SHADOW, iCascadedShadowCombo );
SET_DYNAMIC_PIXEL_SHADER( sdk_skin_ps30 );
if ( bFastVertexTextures )
{
bool bUnusedTexCoords[3] = { false, false, !pShaderAPI->IsHWMorphingEnabled() || !bIsDecal };
pShaderAPI->MarkUnusedVertexFields( 0, 3, bUnusedTexCoords );
}
}
#endif
DynamicCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nBaseTextureTransform );
if( bHasBump )
{
DynamicCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBumpTransform );
}
if ( hasDetailTexture )
{
if ( IS_PARAM_DEFINED( info.m_nDetailTextureTransform ) )
DynamicCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4,
info.m_nDetailTextureTransform,
info.m_nDetailScale );
else
DynamicCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4,
info.m_nBaseTextureTransform,
info.m_nDetailScale );
}
pShader->SetModulationPixelShaderDynamicState_LinearColorSpace( 1 );
DynamicCmdsOut.SetPixelShaderConstant_W( PSREG_SELFILLUMTINT, info.m_nSelfIllumTint, fBlendFactor );
bool bInvertPhongMask = ( info.m_nInvertPhongMask != -1 ) && ( params[info.m_nInvertPhongMask]->GetIntValue() != 0 );
float fInvertPhongMask = bInvertPhongMask ? 1 : 0;
bool bHasBaseAlphaPhongMask = (info.m_nBaseMapAlphaPhongMask != -1) && ( params[info.m_nBaseMapAlphaPhongMask]->GetIntValue() != 0 );
float fHasBaseAlphaPhongMask = bHasBaseAlphaPhongMask ? 1 : 0;
// Controls for lerp-style paths through shader code
const float flMinLighting = pShaderAPI->GetFloatRenderingParameter( FLOAT_RENDERPARM_MINIMUMLIGHTING ); // GSTRINGMIGRATION
float vShaderControls[4] = { fHasBaseAlphaPhongMask, flMinLighting, 0.0f, fInvertPhongMask }; // GSTRINGMIGRATION
DynamicCmdsOut.SetPixelShaderConstant( PSREG_CONSTANT_27, vShaderControls, 1 );
if ( hasDetailTexture )
{
#if 0 // needs constant change
if ( info.m_nDetailTint != -1 )
pShader->SetPixelShaderConstantGammaToLinear( 10, info.m_nDetailTint );
else
{
float boring_tint[4]={1,1,1,1};
pShaderAPI->SetPixelShaderConstant( 10, boring_tint, 1 );
}
#endif
}
if ( bHasSelfIllumFresnel && !bHasFlashlight )
{
float vConstScaleBiasExp[4] = { 1.0f, 0.0f, 1.0f, 0.0f };
float flMin = IS_PARAM_DEFINED( info.m_nSelfIllumFresnelMinMaxExp ) ? params[info.m_nSelfIllumFresnelMinMaxExp]->GetVecValue()[0] : 0.0f;
float flMax = IS_PARAM_DEFINED( info.m_nSelfIllumFresnelMinMaxExp ) ? params[info.m_nSelfIllumFresnelMinMaxExp]->GetVecValue()[1] : 1.0f;
float flExp = IS_PARAM_DEFINED( info.m_nSelfIllumFresnelMinMaxExp ) ? params[info.m_nSelfIllumFresnelMinMaxExp]->GetVecValue()[2] : 1.0f;
vConstScaleBiasExp[1] = ( flMax != 0.0f ) ? ( flMin / flMax ) : 0.0f; // Bias
vConstScaleBiasExp[0] = 1.0f - vConstScaleBiasExp[1]; // Scale
vConstScaleBiasExp[2] = flExp; // Exp
vConstScaleBiasExp[3] = flMax; // Brightness
DynamicCmdsOut.SetPixelShaderConstant( PSREG_SELFILLUM_SCALE_BIAS_EXP, vConstScaleBiasExp, 1 );
}
DynamicCmdsOut.SetAmbientCubeDynamicStateVertexShader();
if( !bHasFlashlight )
{
if ( g_pHardwareConfig->SupportsShaderModel_3_0() )
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SHADOW_NOISE_2D );
}
else
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED );
}
// Setting .x to 1 means to apply Fresnel to env map. Setting w to 1 means use separate selfillummask
float vEnvMapFresnel_SelfIllumMask[4] = {0.0f, 0.0f, 0.0f, 0.0f};
vEnvMapFresnel_SelfIllumMask[3] = bHasSelfIllumMask ? 1.0f : 0.0f;
if( bHasEnvmap )
{
float vEnvMapTint_MaskControl[4] = {1.0f, 1.0f, 1.0f, 0.0f};
// If we have a tint, grab it
if ( (info.m_nEnvmapTint != -1) && params[info.m_nEnvmapTint]->IsDefined() )
params[info.m_nEnvmapTint]->GetVecValue(vEnvMapTint_MaskControl, 3);
// Set control for source of env map mask (normal alpha or base alpha)
vEnvMapTint_MaskControl[3] = bHasNormalMapAlphaEnvmapMask ? 1.0f : 0.0f;
if ( (info.m_nEnvmapFresnel != -1) && params[info.m_nEnvmapFresnel]->IsDefined() )
vEnvMapFresnel_SelfIllumMask[0] = params[info.m_nEnvmapFresnel]->GetFloatValue();
// Handle mat_fullbright 2 (diffuse lighting only with 50% gamma space basetexture)
if( bLightingOnly )
{
vEnvMapTint_MaskControl[0] = vEnvMapTint_MaskControl[1] = vEnvMapTint_MaskControl[2] = 0.0f;
}
DynamicCmdsOut.SetPixelShaderConstant( PSREG_ENVMAP_TINT__SHADOW_TWEAKS, vEnvMapTint_MaskControl, 1 );
}
DynamicCmdsOut.SetPixelShaderConstant( PSREG_ENVMAP_FRESNEL__SELFILLUMMASK, vEnvMapFresnel_SelfIllumMask, 1 );
}
DynamicCmdsOut.SetPixelShaderStateAmbientLightCube( PSREG_AMBIENT_CUBE );
//pShaderAPI->SetPixelShaderStateAmbientLightCube( PSREG_AMBIENT_CUBE, !lightState.m_bAmbientLight ); // Force to black if not bAmbientLight
// Pack Phong exponent in with the eye position
float vEyePos_SpecExponent[4], vFresnelRanges_SpecBoost[4] = {0, 0.5, 1, 1};
float vSpecularTint[4] = {1, 1, 1, 4};
pShaderAPI->GetWorldSpaceCameraPosition( vEyePos_SpecExponent );
if ( (info.m_nPhongExponent != -1) && params[info.m_nPhongExponent]->IsDefined() )
vEyePos_SpecExponent[3] = params[info.m_nPhongExponent]->GetFloatValue(); // This overrides the channel in the map
else
vEyePos_SpecExponent[3] = 0; // Use the alpha channel of the normal map for the exponent
// Get the tint parameter
if ( (info.m_nPhongTint != -1) && params[info.m_nPhongTint]->IsDefined() )
{
params[info.m_nPhongTint]->GetVecValue(vSpecularTint, 3);
}
// Get the rim light power (goes in w of Phong tint)
if ( bHasRimLight && (info.m_nRimLightPower != -1) && params[info.m_nRimLightPower]->IsDefined() )
{
vSpecularTint[3] = params[info.m_nRimLightPower]->GetFloatValue();
vSpecularTint[3] = max(vSpecularTint[3], 1.0f); // Make sure this is at least 1
}
// Get the rim boost (goes in w of flashlight position)
if ( bHasRimLight && (info.m_nRimLightBoost != -1) && params[info.m_nRimLightBoost]->IsDefined() )
{
vRimBoost[3] = params[info.m_nRimLightBoost]->GetFloatValue();
}
if ( !bHasFlashlight )
{
float vRimMaskControl[4] = {0, 0, 0, 0}; // Only x is relevant in shader code
vRimMaskControl[0] = bHasRimMaskMap ? params[info.m_nRimMask]->GetFloatValue() : 0.0f;
// Rim mask...if this is true, use alpha channel of spec exponent texture to mask the rim term
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, vRimMaskControl, 1 );
}
// If it's all zeros, there was no constant tint in the vmt
if ( (vSpecularTint[0] == 0.0f) && (vSpecularTint[1] == 0.0f) && (vSpecularTint[2] == 0.0f) )
{
if ( bHasPhongTintMap ) // If we have a map to use, tell the shader
{
vSpecularTint[0] = -1;
}
else // Otherwise, just tint with white
{
vSpecularTint[0] = 1.0f;
vSpecularTint[1] = 1.0f;
vSpecularTint[2] = 1.0f;
}
}
// handle mat_fullbright 2 (diffuse lighting only)
if( bLightingOnly )
{
// BASETEXTURE
if( bHasSelfIllum && !bHasFlashlight )
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY_ALPHA_ZERO );
}
else
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY );
}
// DETAILTEXTURE
if ( hasDetailTexture )
{
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER13, TEXTURE_GREY );
}
// turn off specularity
vSpecularTint[0] = vSpecularTint[1] = vSpecularTint[2] = 0.0f;
}
if ( (info.m_nPhongFresnelRanges != -1) && params[info.m_nPhongFresnelRanges]->IsDefined() )
params[info.m_nPhongFresnelRanges]->GetVecValue( vFresnelRanges_SpecBoost, 3 ); // Grab optional Fresnel range parameters
if ( (info.m_nPhongBoost != -1 ) && params[info.m_nPhongBoost]->IsDefined()) // Grab optional Phong boost param
vFresnelRanges_SpecBoost[3] = params[info.m_nPhongBoost]->GetFloatValue();
else
vFresnelRanges_SpecBoost[3] = 1.0f;
DynamicCmdsOut.SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vEyePos_SpecExponent, 1 );
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FRESNEL_SPEC_PARAMS, vFresnelRanges_SpecBoost, 1 );
if ( !bHasFlashlight )
{
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_POSITION_RIM_BOOST, vRimBoost, 1 ); // Rim boost in w on non-flashlight pass
}
DynamicCmdsOut.SetPixelShaderConstant( PSREG_SPEC_RIM_PARAMS, vSpecularTint, 1 );
DynamicCmdsOut.SetPixelShaderFogParams( PSREG_FOG_PARAMS );
DynamicCmdsOut.End();
pShaderAPI->ExecuteCommandBuffer( DynamicCmdsOut.Base() );
}
pShader->Draw();
}
void DrawFlesh( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI,
IShaderShadow* pShaderShadow, FleshVars_t &info, VertexCompressionType_t vertexCompression,
CBasePerMaterialContextData **pContextDataPtr )
{
CFlesh_DX9_Context *pContextData = reinterpret_cast< CFlesh_DX9_Context *> ( *pContextDataPtr );
bool bHasFlashlight = pShader->UsingFlashlight( params );
bool bAlphaBlend = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT );
bool bDetail = ( info.m_nDetailTexture != -1 ) && ( params[info.m_nDetailTexture]->IsTexture() );
if ( pShader->IsSnapshotting() || (! pContextData ) || ( pContextData->m_bMaterialVarsChanged ) )
{
bool bTransMatMasks = (info.m_nTransMatMasksTexture != -1) && params[info.m_nTransMatMasksTexture]->IsTexture();
bool bEffectMasks = (info.m_nEffectMasksTexture != -1) && params[info.m_nEffectMasksTexture]->IsTexture();
bool bIridescentWarp = (info.m_nIridescentWarpTexture != -1) && params[info.m_nIridescentWarpTexture]->IsTexture();
bool bFresnelColorWarp = (info.m_nFresnelColorWarpTexture != -1) && params[info.m_nFresnelColorWarpTexture]->IsTexture();
bool bColorWarp = (info.m_nColorWarpTexture != -1) && params[info.m_nColorWarpTexture]->IsTexture();
bool bOpacityTexture = (info.m_nOpacityTexture != -1) && params[info.m_nOpacityTexture]->IsTexture();
bool bInteriorLayer = (info.m_nInteriorEnable != -1) && ( params[info.m_nInteriorEnable]->GetIntValue() > 0 );
bool bBackScatter = ( info.m_nBackScatter != -1 ) && ( params[info.m_nBackScatter]->GetFloatValue() > 0 );
bool bForwardScatter = ( info.m_nForwardScatter != -1) && ( params[info.m_nForwardScatter]->GetFloatValue() > 0 );
bool bNormal2 = ( info.m_nNormal2Softness != -1 ) && ( params[info.m_nNormal2Softness]->GetFloatValue() > 0 );
if ( pShader->IsSnapshotting() )
{
// Set stream format (note that this shader supports compression)
unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL | VERTEX_FORMAT_COMPRESSED;
int nTexCoordCount = 1;
int userDataSize = 4;
int texCoordDims[4] = { 2, 2, 2, 2 };
pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, texCoordDims, userDataSize );
int nShadowFilterMode = 0;
if ( bHasFlashlight )
{
nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode(); // Based upon vendor and device dependent formats
}
DECLARE_STATIC_VERTEX_SHADER( flesh_vs30 );
SET_STATIC_VERTEX_SHADER( flesh_vs30 );
// Pixel Shader
if( /* g_pHardwareConfig->SupportsPixelShaders_3_0() */ true )
{
DECLARE_STATIC_PIXEL_SHADER( flesh_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( ALPHABLEND, bAlphaBlend );
SET_STATIC_PIXEL_SHADER_COMBO( TRANSMAT, bTransMatMasks );
SET_STATIC_PIXEL_SHADER_COMBO( FRESNEL_WARP, bFresnelColorWarp );
SET_STATIC_PIXEL_SHADER_COMBO( EFFECTS, bEffectMasks );
SET_STATIC_PIXEL_SHADER_COMBO( TINTING, bColorWarp );
SET_STATIC_PIXEL_SHADER_COMBO( IRIDESCENCE, bIridescentWarp );
SET_STATIC_PIXEL_SHADER_COMBO( OPACITY_TEXTURE, bOpacityTexture );
SET_STATIC_PIXEL_SHADER_COMBO( DETAIL, bDetail );
SET_STATIC_PIXEL_SHADER_COMBO( NORMAL2SOFT, bNormal2 );
SET_STATIC_PIXEL_SHADER_COMBO( INTERIOR_LAYER, bInteriorLayer );
SET_STATIC_PIXEL_SHADER_COMBO( BACK_SCATTER, bBackScatter );
SET_STATIC_PIXEL_SHADER_COMBO( FORWARD_SCATTER, bForwardScatter );
SET_STATIC_PIXEL_SHADER_COMBO( HIGH_PRECISION_DEPTH, (g_pHardwareConfig->GetHDRType() == HDR_TYPE_FLOAT) ? true : false );
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
SET_STATIC_PIXEL_SHADER( flesh_ps30 );
}
else
{
Assert( !"No ps_3_0" );
}
// Textures
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); // [sRGB] Base
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); // Bump
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false );
if( bInteriorLayer )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); // [sRGB] Backbuffer
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
}
if( bTransMatMasks )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); // Trans mat masks
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, false );
}
if( bColorWarp )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); // [sRGB] Color Warp
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
}
if( bFresnelColorWarp )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); // [sRGB] Fresnel color warp (should be sRGB?)
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER5, true );
}
if( bOpacityTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); // Opacity
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER6, false );
}
if( bEffectMasks )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); // Effect masks
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER10, false );
}
if( bIridescentWarp )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER11, true ); // [sRGB] Iridescent warp
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER11, true );
}
if( bDetail )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER12, true ); // [sRGB] Detail
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER12, true );
}
if ( bHasFlashlight )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); // Shadow depth map
pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER7 );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER7, false );
pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); // Noise map
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, false );
pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); //[sRGB] Flashlight cookie
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER9, true );
// Flashlight passes - additive blending
pShader->EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE );
pShaderShadow->EnableAlphaWrites( false );
pShaderShadow->EnableDepthWrites( false );
}
else if ( bAlphaBlend )
{
// Base pass - alpha blending (regular translucency)
pShader->EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
pShaderShadow->EnableAlphaWrites( false ); // TODO: write alpha for fog or not?
pShaderShadow->EnableDepthWrites( true ); // Rely on depth-sorting
}
else
{
// Base pass - opaque blending (solid flesh or refractive translucency)
pShader->DisableAlphaBlending();
pShaderShadow->EnableAlphaWrites( true );
pShaderShadow->EnableDepthWrites( true );
}
pShaderShadow->EnableSRGBWrite( true );
// Per-instance state
pShader->PI_BeginCommandBuffer();
pShader->PI_SetVertexShaderAmbientLightCube();
pShader->PI_SetPixelShaderAmbientLightCube( PSREG_AMBIENT_CUBE );
pShader->PI_SetPixelShaderLocalLighting( PSREG_LIGHT_INFO_ARRAY );
pShader->PI_EndCommandBuffer();
}
if ( pShaderAPI && ( (! pContextData ) || ( pContextData->m_bMaterialVarsChanged ) ) )
{
if ( !pContextData ) // make sure allocated
{
pContextData = new CFlesh_DX9_Context;
*pContextDataPtr = pContextData;
}
pContextData->m_bMaterialVarsChanged = false;
pContextData->m_SemiStaticCmdsOut.Reset();
///////////////////////////
// Semi-static block
///////////////////////////
float flConsts[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
flConsts[0] = IS_PARAM_DEFINED( info.m_nBumpStrength ) ? params[info.m_nBumpStrength]->GetFloatValue() : kDefaultBumpStrength;
flConsts[1] = (g_pHardwareConfig->GetHDRType() == HDR_TYPE_FLOAT) ? 8192.0f : 192.0f; // destalpha dest scale factor. TODO: put this in its own const and call shaderAPI method to set
flConsts[2] = IS_PARAM_DEFINED( info.m_nInteriorFogStrength ) ? params[info.m_nInteriorFogStrength]->GetFloatValue() : kDefaultInteriorFogStrength;
flConsts[3] = IS_PARAM_DEFINED( info.m_nInteriorRefractStrength ) ? params[info.m_nInteriorRefractStrength]->GetFloatValue() : kDefaultInteriorRefractStrength;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 0, flConsts, 1 );
Assert( IS_PARAM_DEFINED( info.m_nFresnelParams ) );
if ( IS_PARAM_DEFINED( info.m_nFresnelParams ) )
params[info.m_nFresnelParams]->GetVecValue( flConsts, 3 );
else
memcpy( flConsts, kDefaultFresnelParams, sizeof( kDefaultFresnelParams ) );
flConsts[3] = params[info.m_nInteriorBackgroundBoost]->GetFloatValue();
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 1, flConsts, 1 );
flConsts[0] = IS_PARAM_DEFINED( info.m_nRimLightExp ) ? params[info.m_nRimLightExp]->GetFloatValue() : kDefaultRimLightExp;
flConsts[1] = IS_PARAM_DEFINED( info.m_nRimLightScale ) ? params[info.m_nRimLightScale]->GetFloatValue() : kDefaultRimLightScale;
flConsts[2] = IS_PARAM_DEFINED( info.m_nSpecScale ) ? params[info.m_nSpecScale]->GetFloatValue() : kDefaultSpecScale;
flConsts[3] = IS_PARAM_DEFINED( info.m_nSpecExp2 ) ? params[info.m_nSpecExp2]->GetFloatValue() : kDefaultSpecExp;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 3, flConsts, 1 );
flConsts[0] = IS_PARAM_DEFINED( info.m_nSpecScale2 ) ? params[info.m_nSpecScale2]->GetFloatValue() : kDefaultSpecScale;
flConsts[1] = IS_PARAM_DEFINED( info.m_nFresnelBumpStrength ) ? params[info.m_nFresnelBumpStrength]->GetFloatValue() : kDefaultFresnelBumpStrength;
flConsts[2] = IS_PARAM_DEFINED( info.m_nDiffuseSoftNormal ) ? params[info.m_nDiffuseSoftNormal]->GetFloatValue() : kDefaultDiffuseSoftNormal;
flConsts[3] = IS_PARAM_DEFINED( info.m_nInteriorAmbientScale ) ? params[info.m_nInteriorAmbientScale]->GetFloatValue() : kDefaultInteriorAmbientScale;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 10, flConsts, 1 );
// Depth alpha [ TODO: support fog ]
bool bWriteDepthToAlpha = pShaderAPI->ShouldWriteDepthToDestAlpha() && !bAlphaBlend;
if ( IS_PARAM_DEFINED( info.m_nSpecFresnel ) )
params[info.m_nSpecFresnel]->GetVecValue( flConsts, 3 );
else
memcpy( flConsts, kDefaultSpecFresnel, sizeof( kDefaultSpecFresnel ) );
flConsts[3] = bWriteDepthToAlpha ? 1.0f : 0.0f;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 12, flConsts, 1 );
if ( IS_PARAM_DEFINED( info.m_nPhongColorTint ) )
params[info.m_nPhongColorTint]->GetVecValue( flConsts, 3 );
else
memcpy( flConsts, kDefaultPhongColorTint, sizeof( kDefaultPhongColorTint ) );
flConsts[3] = IS_PARAM_DEFINED( info.m_nInteriorBackLightScale ) ? params[info.m_nInteriorBackLightScale]->GetFloatValue() : kDefaultInteriorBackLightScale;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 19, flConsts, 1 );
if( bIridescentWarp || bFresnelColorWarp )
{
flConsts[0] = ( IS_PARAM_DEFINED( info.m_nIridescenceBoost ) ) ? params[info.m_nIridescenceBoost]->GetFloatValue(): kDefaultIridescenceBoost;
flConsts[1] = ( IS_PARAM_DEFINED( info.m_nIridescenceExponent ) ) ? params[info.m_nIridescenceExponent]->GetFloatValue(): kDefaultIridescenceExponent;
flConsts[2] = ( IS_PARAM_DEFINED( info.m_nHueShiftIntensity ) ) ? params[info.m_nHueShiftIntensity]->GetFloatValue(): kDefaultHueShiftIntensity;
flConsts[3] = ( IS_PARAM_DEFINED( info.m_nHueShiftFresnelExponent ) ) ? params[info.m_nHueShiftFresnelExponent]->GetFloatValue(): kDefaultHueShiftFresnelExponent;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 26, flConsts, 1 );
}
if ( IS_PARAM_DEFINED( info.m_nSelfIllumTint ) )
params[info.m_nSelfIllumTint]->GetVecValue( flConsts, 3 );
else
memcpy( flConsts, kDefaultSelfIllumTint, sizeof( kDefaultSelfIllumTint ) );
float flDiffuseExp = IS_PARAM_DEFINED( info.m_nDiffuseExponent ) ? params[info.m_nDiffuseExponent]->GetFloatValue() : kDefaultDiffuseExponent;
flConsts[3] = pow( 0.5f, flDiffuseExp );
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 27, flConsts, 1 );
if ( IS_PARAM_DEFINED( info.m_nInteriorColor ) )
params[info.m_nInteriorColor]->GetVecValue( flConsts, 3 );
else
memcpy( flConsts, kDefaultInteriorColor, sizeof( kDefaultInteriorColor ) );
flConsts[3] = params[info.m_nInteriorRefractBlur]->GetFloatValue();
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 32, flConsts, 1 );
if ( IS_PARAM_DEFINED( info.m_nSpecFresnel2 ) )
params[info.m_nSpecFresnel2]->GetVecValue( flConsts, 3 );
else
memcpy( flConsts, kDefaultSpecFresnel2, sizeof( kDefaultSpecFresnel2 ) );
flConsts[3] = IS_PARAM_DEFINED( info.m_nPhong2Softness ) ? params[info.m_nPhong2Softness]->GetFloatValue() : kDefaultPhong2Softness;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 42, flConsts, 1 );
flConsts[0] = flDiffuseExp;
flConsts[1] = IS_PARAM_DEFINED( info.m_nNormal2Softness ) ? params[info.m_nNormal2Softness]->GetFloatValue() : kDefaultNormal2Softness;
flConsts[2] = IS_PARAM_DEFINED( info.m_nAmbientBoost ) ? params[info.m_nAmbientBoost]->GetFloatValue() : kDefaultAmbientBoost;
flConsts[3] = IS_PARAM_DEFINED( info.m_nAmbientBoostMaskMode ) ? params[info.m_nAmbientBoostMaskMode]->GetIntValue() : kDefaultAmbientBoostMaskMode;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 43, flConsts, 1 );
if ( bForwardScatter || bBackScatter )
{
flConsts[0] = IS_PARAM_DEFINED( info.m_nForwardScatter ) ? params[info.m_nForwardScatter]->GetFloatValue() : kDefaultForwardScatter;
flConsts[1] = IS_PARAM_DEFINED( info.m_nBackScatter ) ? params[info.m_nBackScatter]->GetFloatValue() : kDefaultBackScatter;
flConsts[2] = IS_PARAM_DEFINED( info.m_nSSDepth ) ? params[info.m_nSSDepth]->GetFloatValue() : kDefaultSSDepth;
flConsts[3] = IS_PARAM_DEFINED( info.m_nSSBentNormalIntensity ) ? params[info.m_nSSBentNormalIntensity]->GetFloatValue() : kDefaultSSBentNormalIntensity;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 44, flConsts, 1 );
if( IS_PARAM_DEFINED( info.m_nSSColorTint ) )
params[info.m_nSSColorTint]->GetVecValue( flConsts, 3 );
else
memcpy( flConsts, kDefaultSSColorTint, sizeof( kDefaultSSColorTint ) );
flConsts[3] = IS_PARAM_DEFINED( info.m_nSSTintByAlbedo ) ? params[info.m_nSSTintByAlbedo]->GetFloatValue() : kDefaultSSTintByAlbedo;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 45, flConsts, 1 );
}
flConsts[0] = 0.0f;
flConsts[1] = 0.0f;
if ( bDetail )
{
flConsts[0] = IS_PARAM_DEFINED( info.m_nDetailBlendMode ) ? params[info.m_nDetailBlendMode]->GetIntValue() : kDefaultDetailBlendMode;
flConsts[1] = IS_PARAM_DEFINED( info.m_nDetailBlendFactor) ? params[info.m_nDetailBlendFactor]->GetFloatValue() : kDefaultDetailBlendFactor;
flConsts[2] = 0.0f;
}
flConsts[3] = IS_PARAM_DEFINED( info.m_nSpecExp ) ? params[info.m_nSpecExp]->GetFloatValue() : kDefaultSpecExp;
pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 46, flConsts, 1 );
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER0, BASETEXTURE, -1 );
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER1, info.m_nNormalMap, -1 );
pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER2, TEXTURE_FRAME_BUFFER_FULL_TEXTURE_0 ); // Refraction Map
if ( bTransMatMasks )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER3, info.m_nTransMatMasksTexture, -1 );
}
if ( bColorWarp )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER4, info.m_nColorWarpTexture, -1 );
}
if ( bFresnelColorWarp )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER5, info.m_nFresnelColorWarpTexture, -1 );
}
if ( bOpacityTexture )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER6, info.m_nOpacityTexture, -1 );
}
if ( bEffectMasks )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER10, info.m_nEffectMasksTexture, -1 );
}
if ( bIridescentWarp )
{
pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER11, info.m_nIridescentWarpTexture, -1 );
}
// VS consts
flConsts[0] = IS_PARAM_DEFINED( info.m_nUVScale ) ? params[info.m_nUVScale]->GetFloatValue() : kDefaultUVScale;
pContextData->m_SemiStaticCmdsOut.SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, flConsts, 1 );
flConsts[0] = IS_PARAM_DEFINED( info.m_nDetailScale ) ? params[info.m_nDetailScale]->GetFloatValue() : kDefaultDetailScale;
pContextData->m_SemiStaticCmdsOut.SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, flConsts, 1 );
if ( IS_PARAM_DEFINED( info.m_nDetailTextureTransform ) )
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nDetailTextureTransform, info.m_nDetailScale );
else
pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBaseTextureTransform, info.m_nDetailScale );
pContextData->m_SemiStaticCmdsOut.End();
// end semi-static block
}
}
if ( pShaderAPI ) //DYNAMIC_STATE
{
CCommandBufferBuilder< CFixedCommandStorageBuffer< 400 > > DynamicCmdsOut;
DynamicCmdsOut.Call( pContextData->m_SemiStaticCmdsOut.Base() );
///////////////////////////
// dynamic block
///////////////////////////
float camPos[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
pShaderAPI->GetWorldSpaceCameraPosition( camPos );
DynamicCmdsOut.SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, camPos );
if ( bDetail )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nDetailTexture, info.m_nDetailFrame );
}
float mView[16];
pShaderAPI->GetMatrix( MATERIAL_VIEW, mView );
DynamicCmdsOut.SetPixelShaderConstant( 33, mView, 3 );
DynamicCmdsOut.SetPixelShaderFogParams( 36 );
LightState_t lightState = { 0, false, false };
pShaderAPI->GetDX9LightState( &lightState );
// flashlightfixme: put this in common code.
bool bFlashlightShadows = false;
if ( bHasFlashlight )
{
Assert( info.m_nFlashlightTexture >= 0 && info.m_nFlashlightTextureFrame >= 0 );
VMatrix worldToTexture;
ITexture *pFlashlightDepthTexture;
FlashlightState_t state = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER9, state.m_pSpotlightTexture, state.m_nSpotlightTextureFrame );
bFlashlightShadows = state.m_bEnableShadows;
SetFlashLightColorFromState( state, pShaderAPI, PSREG_FLASHLIGHT_COLOR );
if( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() && state.m_bEnableShadows )
{
DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER7, pFlashlightDepthTexture, -1 );
DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER8, TEXTURE_SHADOW_NOISE_2D );
}
float atten[4], pos[4], tweaks[4];
atten[0] = state.m_fConstantAtten; // Set the flashlight attenuation factors
atten[1] = state.m_fLinearAtten;
atten[2] = state.m_fQuadraticAtten;
atten[3] = state.m_FarZAtten;
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, atten, 1 );
pos[0] = state.m_vecLightOrigin[0]; // Set the flashlight origin
pos[1] = state.m_vecLightOrigin[1];
pos[2] = state.m_vecLightOrigin[2];
pos[3] = state.m_FarZ;
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_POSITION_RIM_BOOST, pos, 1 ); // steps on rim boost
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_TO_WORLD_TEXTURE, worldToTexture.Base(), 4 );
// Tweaks associated with a given flashlight
tweaks[0] = ShadowFilterFromState( state );
tweaks[1] = ShadowAttenFromState( state );
pShader->HashShadow2DJitter( state.m_flShadowJitterSeed, &tweaks[2], &tweaks[3] );
DynamicCmdsOut.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;
DynamicCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_SCREEN_SCALE, vScreenScale, 1 );
}
DynamicCmdsOut.End();
// end dynamic block
pShaderAPI->ExecuteCommandBuffer( DynamicCmdsOut.Base() );
// Set Vertex Shader Combos
DECLARE_DYNAMIC_VERTEX_SHADER( flesh_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( flesh_vs30 );
// Set Pixel Shader Combos
if( /*g_pHardwareConfig->SupportsPixelShaders_2_b()*/ true )
{
DECLARE_DYNAMIC_PIXEL_SHADER( flesh_ps30 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bHasFlashlight );
SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows );
SET_DYNAMIC_PIXEL_SHADER( flesh_ps30 );
}
else
{
Assert( !"No ps_3_0" );
}
}
pShader->Draw();
}
