//-----------------------------------------------------------------------------
// Does the texture store translucency in its alpha channel?
//-----------------------------------------------------------------------------
bool CBaseShader::TextureIsTranslucent( int textureVar, bool isBaseTexture )
{
if (textureVar < 0)
return false;
IMaterialVar** params = s_ppParams;
if (params[textureVar]->GetType() == MATERIAL_VAR_TYPE_TEXTURE)
{
if (!isBaseTexture)
{
return params[textureVar]->GetTextureValue()->IsTranslucent();
}
else
{
// Override translucency settings if this flag is set.
if (IS_FLAG_SET(MATERIAL_VAR_OPAQUETEXTURE))
return false;
if ( (CurrentMaterialVarFlags() & (MATERIAL_VAR_SELFILLUM | MATERIAL_VAR_BASEALPHAENVMAPMASK)) == 0)
{
if ((CurrentMaterialVarFlags() & MATERIAL_VAR_TRANSLUCENT) ||
(CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST))
{
return params[textureVar]->GetTextureValue()->IsTranslucent();
}
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// 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
}
}
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;
}
FORCEINLINE void CBaseShader::SetFogMode( ShaderFogMode_t fogMode )
{
if (( CurrentMaterialVarFlags() & MATERIAL_VAR_NOFOG ) == 0)
{
bool bVertexFog = ( ( CurrentMaterialVarFlags() & MATERIAL_VAR_VERTEXFOG ) != 0 );
s_pShaderShadow->FogMode( fogMode, bVertexFog );
}
else
{
s_pShaderShadow->FogMode( SHADER_FOGMODE_DISABLED, false );
}
}
void CBaseShader::DefaultFog( void )
{
if ( CurrentMaterialVarFlags() & MATERIAL_VAR_ADDITIVE )
{
FogToBlack();
}
else
{
FogToFogColor();
}
}
void CBaseShader::SetDefaultBlendingShadowState( int textureVar, bool isBaseTexture )
{
if ( CurrentMaterialVarFlags() & MATERIAL_VAR_ADDITIVE )
{
SetAdditiveBlendingShadowState( textureVar, isBaseTexture );
}
else
{
SetNormalBlendingShadowState( textureVar, isBaseTexture );
}
}
//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::FogToFogColor( void )
{
Assert( IsSnapshotting() );
if (( CurrentMaterialVarFlags() & MATERIAL_VAR_NOFOG ) == 0)
{
s_pShaderShadow->FogMode( SHADER_FOGMODE_FOGCOLOR );
}
else
{
s_pShaderShadow->FogMode( SHADER_FOGMODE_DISABLED );
}
}
//-----------------------------------------------------------------------------
//
// Helper methods for fog
//
//-----------------------------------------------------------------------------
void CBaseShader::FogToOOOverbright( void )
{
Assert( IsSnapshotting() );
if (( CurrentMaterialVarFlags() & MATERIAL_VAR_NOFOG ) == 0)
{
s_pShaderShadow->FogMode( SHADER_FOGMODE_OO_OVERBRIGHT );
}
else
{
s_pShaderShadow->FogMode( SHADER_FOGMODE_DISABLED );
}
}
//-----------------------------------------------------------------------------
// Does the texture store translucency in its alpha channel?
//-----------------------------------------------------------------------------
bool CBaseShader::TextureIsTranslucent( int textureVar, bool isBaseTexture )
{
if (textureVar < 0)
return false;
IMaterialVar** params = s_ppParams;
if (params[textureVar]->GetType() == MATERIAL_VAR_TYPE_TEXTURE)
{
if (!isBaseTexture)
{
return params[textureVar]->GetTextureValue()->IsTranslucent();
}
else
{
// Override translucency settings if this flag is set.
if (IS_FLAG_SET(MATERIAL_VAR_OPAQUETEXTURE))
return false;
bool bHasSelfIllum = ( ( CurrentMaterialVarFlags() & MATERIAL_VAR_SELFILLUM ) != 0 );
bool bHasSelfIllumMask = ( ( CurrentMaterialVarFlags2() & MATERIAL_VAR2_SELFILLUMMASK ) != 0 );
bool bHasBaseAlphaEnvmapMask = ( ( CurrentMaterialVarFlags() & MATERIAL_VAR_BASEALPHAENVMAPMASK ) != 0 );
bool bUsingBaseTextureAlphaForSelfIllum = bHasSelfIllum && !bHasSelfIllumMask;
// Check if we are using base texture alpha for something other than translucency.
if ( !bUsingBaseTextureAlphaForSelfIllum && !bHasBaseAlphaEnvmapMask )
{
// We aren't using base alpha for anything other than trancluceny.
// check if the material is marked as translucent or alpha test.
if ((CurrentMaterialVarFlags() & MATERIAL_VAR_TRANSLUCENT) ||
(CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST))
{
// Make sure the texture has an alpha channel.
return params[textureVar]->GetTextureValue()->IsTranslucent();
}
}
}
}
return false;
}
void CBaseShader::FogToGrey( void )
{
Assert( !IsSnapshotting() );
if (( CurrentMaterialVarFlags() & MATERIAL_VAR_NOFOG ) == 0)
{
s_pShaderAPI->FogMode( s_pShaderAPI->GetSceneFogMode() );
s_pShaderAPI->FogColor3ub( 127, 127, 127 );
}
else
{
s_pShaderAPI->FogMode( MATERIAL_FOG_NONE );
}
}
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();
}
}
void CBaseShader::FogToFogColor( void )
{
Assert( !IsSnapshotting() );
if (( CurrentMaterialVarFlags() & MATERIAL_VAR_NOFOG ) == 0)
{
s_pShaderAPI->FogMode( s_pShaderAPI->GetSceneFogMode() );
unsigned char fogColor[3];
s_pShaderAPI->GetSceneFogColor( fogColor );
s_pShaderAPI->FogColor3ubv( fogColor );
}
else
{
s_pShaderAPI->FogMode( MATERIAL_FOG_NONE );
}
}
//-----------------------------------------------------------------------------
//
// Helper methods for fog
//
//-----------------------------------------------------------------------------
void CBaseShader::FogToWhite( void )
{
Assert( !IsSnapshotting() );
if (( CurrentMaterialVarFlags() & MATERIAL_VAR_NOFOG ) == 0)
{
s_pShaderAPI->FogMode( s_pShaderAPI->GetSceneFogMode() );
if ( g_pConfig->overbright == 2.0f )
{
s_pShaderAPI->FogColor3ub( 127, 127, 127 );
}
else
{
s_pShaderAPI->FogColor3ub( 255, 255, 255 );
}
}
else
{
s_pShaderAPI->FogMode( MATERIAL_FOG_NONE );
}
}
//-----------------------------------------------------------------------------
// Fixed function multiply by detail texture pass
//-----------------------------------------------------------------------------
void CBaseShader::FixedFunctionMultiplyByDetailPass( int baseTextureVar, int frameVar,
int textureTransformVar, int detailVar, int detailScaleVar )
{
IMaterialVar** params = s_ppParams;
if (!params[detailVar]->IsDefined())
return;
if (IsSnapshotting())
{
s_pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
bool translucentTexture = TextureIsTranslucent( baseTextureVar, true ) ||
IS_FLAG_SET(MATERIAL_VAR_ALPHATEST);
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, translucentTexture );
s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE1, true );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, false );
s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE1, false );
// Mod 2x blend here
EnableAlphaBlending( SHADER_BLEND_DST_COLOR, SHADER_BLEND_SRC_COLOR );
s_pShaderShadow->EnableCustomPixelPipe( true );
s_pShaderShadow->CustomTextureStages( 2 );
// We need to blend towards grey based on alpha...
// We can never get the perfect alpha (vertex alpha * cc alpha * texture alpha)
// so we'll just choose to use cc alpha * texture alpha
int flags = SHADER_DRAW_POSITION | SHADER_DRAW_TEXCOORD1;
// Compute alpha, stage 0 is used, stage 1 isn't.
if ( translucentTexture )
{
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_ALPHA, SHADER_TEXOP_MODULATE,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
flags |= SHADER_DRAW_TEXCOORD0;
}
else
{
bool hasVertexAlpha = (CurrentMaterialVarFlags() & MATERIAL_VAR_VERTEXALPHA) != 0;
if (hasVertexAlpha)
{
flags |= SHADER_DRAW_COLOR;
}
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_ALPHA, hasVertexAlpha ? SHADER_TEXOP_MODULATE : SHADER_TEXOP_SELECTARG2,
SHADER_TEXARG_VERTEXCOLOR, SHADER_TEXARG_CONSTANTCOLOR );
}
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_ALPHA, SHADER_TEXOP_SELECTARG1,
SHADER_TEXARG_PREVIOUSSTAGE, SHADER_TEXARG_NONE );
// This here will perform color = vertex light * alpha + 0.5f * (1 - alpha)
// Stage 0 really doesn't do anything
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE0,
SHADER_TEXCHANNEL_COLOR, SHADER_TEXOP_SELECTARG1,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
s_pShaderShadow->CustomTextureOperation( SHADER_TEXTURE_STAGE1,
SHADER_TEXCHANNEL_COLOR, SHADER_TEXOP_BLEND_PREVIOUSSTAGEALPHA,
SHADER_TEXARG_TEXTURE, SHADER_TEXARG_CONSTANTCOLOR );
s_pShaderShadow->DrawFlags( flags );
Draw( );
s_pShaderShadow->EnableCustomPixelPipe( false );
DisableAlphaBlending();
}
else
{
if (TextureIsTranslucent( baseTextureVar, true ) )
{
SetFixedFunctionTextureTransform( MATERIAL_TEXTURE0, textureTransformVar );
BindTexture( SHADER_TEXTURE_STAGE0, baseTextureVar, frameVar );
}
BindTexture( SHADER_TEXTURE_STAGE1, detailVar, frameVar );
SetFixedFunctionTextureScaledTransform( MATERIAL_TEXTURE1, textureTransformVar, detailScaleVar );
float alpha = GetAlpha();
s_pShaderAPI->Color4ub( 128, 128, 128, 255 * alpha );
FogToGrey();
Draw( );
}
}
