//-----------------------------------------------------------------------------
// GR - translucency query
//-----------------------------------------------------------------------------
BlendType_t CBaseVSShader::EvaluateBlendRequirements( int textureVar, bool isBaseTexture,
int detailTextureVar )
{
// Either we've got a constant modulation
bool isTranslucent = IsAlphaModulating();
// Or we've got a vertex alpha
isTranslucent = isTranslucent || (CurrentMaterialVarFlags() & MATERIAL_VAR_VERTEXALPHA);
// Or we've got a texture alpha (for blending or alpha test)
isTranslucent = isTranslucent || ( TextureIsTranslucent( textureVar, isBaseTexture ) &&
!(CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST ) );
if ( ( detailTextureVar != -1 ) && ( ! isTranslucent ) )
{
isTranslucent = TextureIsTranslucent( detailTextureVar, isBaseTexture );
}
if ( CurrentMaterialVarFlags() & MATERIAL_VAR_ADDITIVE )
{
return isTranslucent ? BT_BLENDADD : BT_ADD; // Additive
}
else
{
return isTranslucent ? BT_BLEND : BT_NONE; // Normal blending
}
}
void CBaseShader::SetModulationShadowState( int tintVar )
{
// Have have no control over the tint var...
bool doModulation = (tintVar != -1);
// We activate color modulating when we're alpha or color modulating
doModulation = doModulation || IsAlphaModulating() || IsColorModulating();
s_pShaderShadow->EnableConstantColor( doModulation );
}
BlendType_t CBaseOES2Shader::EvaluateBlendRequirements(int textureVar, bool isBaseTexture, int detailTextureVar)
{
IMaterialVar **params = s_ppParams;
bool isTranslucent = IsAlphaModulating() ||
(CurrentMaterialVarFlags() & MATERIAL_VAR_VERTEXALPHA) ||
(!(CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST) && TextureIsTranslucent(textureVar, isBaseTexture)) ||
((detailTextureVar != -1) && TextureIsTranslucent(detailTextureVar, isBaseTexture));
if (CurrentMaterialVarFlags() & MATERIAL_VAR_ADDITIVE)
return isTranslucent ? BT_BLENDADD : BT_ADD;
return isTranslucent ? BT_BLEND : BT_NONE;
}
//ConVar mat_debug_flashlight_only( "mat_debug_flashlight_only", "0" );
void CBaseShader::SetAdditiveBlendingShadowState( int textureVar, bool isBaseTexture )
{
Assert( IsSnapshotting() );
// Either we've got a constant modulation
bool isTranslucent = IsAlphaModulating();
// Or we've got a vertex alpha
isTranslucent = isTranslucent || (CurrentMaterialVarFlags() & MATERIAL_VAR_VERTEXALPHA);
// Or we've got a texture alpha
isTranslucent = isTranslucent || ( TextureIsTranslucent( textureVar, isBaseTexture ) &&
!(CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST ) );
/*
if ( mat_debug_flashlight_only.GetBool() )
{
if (isTranslucent)
{
EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA);
//s_pShaderShadow->EnableAlphaTest( true );
//s_pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GREATER, 0.99f );
}
else
{
EnableAlphaBlending( SHADER_BLEND_ONE, SHADER_BLEND_ZERO);
}
}
else
*/
{
if (isTranslucent)
{
EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE );
}
else
{
EnableAlphaBlending( SHADER_BLEND_ONE, SHADER_BLEND_ONE );
}
}
}
void CBaseShader::SetNormalBlendingShadowState( int textureVar, bool isBaseTexture )
{
Assert( IsSnapshotting() );
// Either we've got a constant modulation
bool isTranslucent = IsAlphaModulating();
// Or we've got a vertex alpha
isTranslucent = isTranslucent || (CurrentMaterialVarFlags() & MATERIAL_VAR_VERTEXALPHA);
// Or we've got a texture alpha
isTranslucent = isTranslucent || ( TextureIsTranslucent( textureVar, isBaseTexture ) &&
!(CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST ) );
if (isTranslucent)
{
EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
}
else
{
DisableAlphaBlending();
}
}
//-----------------------------------------------------------------------------
// Helpers for environment mapping...
//-----------------------------------------------------------------------------
int CBaseShader::SetShadowEnvMappingState( int envMapMaskVar, int tintVar )
{
Assert( IsSnapshotting() );
IMaterialVar** params = s_ppParams;
int varFlags = params[FLAGS]->GetIntValue();
s_pShaderShadow->EnableAlphaTest( false );
// envmap on stage 0
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, true );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, true );
if ( (varFlags & MATERIAL_VAR_ENVMAPSPHERE) == 0 )
s_pShaderShadow->TexGen( SHADER_TEXTURE_STAGE0, SHADER_TEXGENPARAM_CAMERASPACEREFLECTIONVECTOR );
else
s_pShaderShadow->TexGen( SHADER_TEXTURE_STAGE0, SHADER_TEXGENPARAM_SPHERE_MAP );
int flags = SHADER_DRAW_POSITION | SHADER_DRAW_NORMAL;
// mask on stage 1
if (params[envMapMaskVar]->IsDefined() || (varFlags & MATERIAL_VAR_BASEALPHAENVMAPMASK))
{
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE1, true );
flags |= SHADER_DRAW_TEXCOORD1;
}
else
{
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE1, false );
}
if (varFlags & MATERIAL_VAR_BASEALPHAENVMAPMASK)
{
s_pShaderShadow->EnableCustomPixelPipe( true );
s_pShaderShadow->CustomTextureStages( 2 );
// Color = base texture * envmaptint * (1 - mask alpha)
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_COLOR, SHADER_TEXOP_MODULATE, SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_COLOR, SHADER_TEXOP_MODULATE, SHADER_TEXARG_PREVIOUSSTAGE, SHADER_TEXARG_INVTEXTUREALPHA );
// Use alpha modulation * vertex alpha * env map alpha
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_ALPHA, SHADER_TEXOP_MODULATE, SHADER_TEXARG_VERTEXCOLOR, SHADER_TEXARG_TEXTURE );
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_ALPHA, SHADER_TEXOP_SELECTARG1, SHADER_TEXARG_PREVIOUSSTAGE, SHADER_TEXARG_CONSTANTCOLOR );
}
else
{
s_pShaderShadow->EnableAlphaPipe( true );
// Color = base texture * envmaptint * mask
s_pShaderShadow->EnableConstantColor( tintVar >= 0 );
// Alpha = vertex alpha * constant alpha * env map alpha * mask alpha (only if it's not a base alpha mask)
s_pShaderShadow->EnableConstantAlpha( IsAlphaModulating() );
s_pShaderShadow->EnableVertexAlpha( (varFlags & MATERIAL_VAR_VERTEXALPHA) != 0 );
s_pShaderShadow->EnableTextureAlpha( SHADER_TEXTURE_STAGE0, true );
s_pShaderShadow->EnableTextureAlpha( SHADER_TEXTURE_STAGE1, params[envMapMaskVar]->IsDefined() );
}
return flags;
}
//-----------------------------------------------------------------------------
// Fixed function Base * detail pass
//-----------------------------------------------------------------------------
void CBaseShader::FixedFunctionBaseTimesDetailPass( int baseTextureVar,
int frameVar, int baseTextureTransformVar, int detailVar, int detailScaleVar )
{
IMaterialVar** params = s_ppParams;
// We can't do this one one pass if CC and VC are both active...
bool hasDetail = (detailVar != -1) && params[detailVar]->IsDefined();
bool detailInSecondPass = hasDetail && IsColorModulating() &&
(IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR) || IS_FLAG_SET(MATERIAL_VAR_VERTEXALPHA));
if (IsSnapshotting())
{
IMaterialVar** params = s_ppParams;
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, false );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE1, false );
// alpha test
s_pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
// Alpha blending
SetDefaultBlendingShadowState( baseTextureVar, true );
// independently configure alpha and color
s_pShaderShadow->EnableAlphaPipe( true );
// Here's the color states (NOTE: SHADER_DRAW_COLOR == use Vertex Color)
s_pShaderShadow->EnableConstantColor( IsColorModulating() );
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, true );
int flags = SHADER_DRAW_POSITION | SHADER_DRAW_TEXCOORD0;
// Detail texture..
if (hasDetail && (!detailInSecondPass))
{
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE1, true );
// Force mod2x
s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE1, 2.0f );
flags |= SHADER_DRAW_TEXCOORD1;
}
// Here's the alpha states
s_pShaderShadow->EnableConstantAlpha( IsAlphaModulating() );
s_pShaderShadow->EnableVertexAlpha( IS_FLAG_SET(MATERIAL_VAR_VERTEXALPHA) );
s_pShaderShadow->EnableTextureAlpha( SHADER_TEXTURE_STAGE0, TextureIsTranslucent(baseTextureVar, true) );
if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR))
flags |= SHADER_DRAW_COLOR;
s_pShaderShadow->DrawFlags( flags );
Draw();
s_pShaderShadow->EnableAlphaPipe( false );
}
else
{
SetFixedFunctionTextureTransform( MATERIAL_TEXTURE0, baseTextureTransformVar );
BindTexture( SHADER_TEXTURE_STAGE0, baseTextureVar, frameVar );
// Detail texture..
if (hasDetail && (!detailInSecondPass))
{
BindTexture( SHADER_TEXTURE_STAGE1, detailVar, frameVar );
SetFixedFunctionTextureScaledTransform( MATERIAL_TEXTURE1, baseTextureTransformVar, detailScaleVar );
}
SetModulationDynamicState();
DefaultFog();
Draw();
}
if (detailInSecondPass)
{
FixedFunctionMultiplyByDetailPass( baseTextureVar, frameVar, baseTextureTransformVar, detailVar, detailScaleVar );
}
}
