You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
807 lines
27 KiB
807 lines
27 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $Header: $ |
|
// $NoKeywords: $ |
|
//=============================================================================// |
|
|
|
#include "BaseVSShader.h" |
|
|
|
#include "vertexlitgeneric_vs11.inc" |
|
#include "vertexlitgeneric_selfillumonly.inc" |
|
#include "emissive_scroll_blended_pass_helper.h" |
|
#include "flesh_interior_blended_pass_helper.h" |
|
#include "cloak_blended_pass_helper.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
DEFINE_FALLBACK_SHADER( VertexLitGeneric, VertexLitGeneric_DX8 ) |
|
DEFINE_FALLBACK_SHADER( Skin_DX9, VertexLitGeneric_DX8 ) |
|
|
|
BEGIN_VS_SHADER( VertexLitGeneric_DX8, |
|
"Help for VertexLitGeneric" ) |
|
BEGIN_SHADER_PARAMS |
|
SHADER_PARAM( SELFILLUMTINT, SHADER_PARAM_TYPE_COLOR, "[1 1 1]", "Self-illumination tint" ) |
|
SHADER_PARAM( DETAIL, SHADER_PARAM_TYPE_TEXTURE, "shadertest/detail", "detail texture" ) |
|
SHADER_PARAM( DETAILSCALE, SHADER_PARAM_TYPE_FLOAT, "4", "scale of the detail texture" ) |
|
SHADER_PARAM( DETAILFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "frame number for $detail" ) |
|
SHADER_PARAM( ENVMAP, SHADER_PARAM_TYPE_TEXTURE, "shadertest/shadertest_env", "envmap" ) |
|
SHADER_PARAM( ENVMAPFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "envmap frame number" ) |
|
SHADER_PARAM( ENVMAPMASK, SHADER_PARAM_TYPE_TEXTURE, "shadertest/shadertest_envmask", "envmap mask" ) |
|
SHADER_PARAM( ENVMAPMASKFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "" ) |
|
SHADER_PARAM( ENVMAPMASKSCALE, SHADER_PARAM_TYPE_FLOAT, "1", "envmap mask scale" ) |
|
SHADER_PARAM( ENVMAPTINT, SHADER_PARAM_TYPE_COLOR, "[1 1 1]", "envmap tint" ) |
|
SHADER_PARAM( BUMPMAP, SHADER_PARAM_TYPE_TEXTURE, "models/shadertest/shader1_normal", "bump map" ) |
|
SHADER_PARAM( BUMPFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "frame number for $bumpmap" ) |
|
SHADER_PARAM( BUMPTRANSFORM, SHADER_PARAM_TYPE_MATRIX, "center .5 .5 scale 1 1 rotate 0 translate 0 0", "$bumpmap texcoord transform" ) |
|
SHADER_PARAM( ENVMAPCONTRAST, SHADER_PARAM_TYPE_FLOAT, "0.0", "contrast 0 == normal 1 == color*color" ) |
|
SHADER_PARAM( ENVMAPSATURATION, SHADER_PARAM_TYPE_FLOAT, "1.0", "saturation 0 == greyscale 1 == normal" ) |
|
SHADER_PARAM( ENVMAPOPTIONAL, SHADER_PARAM_TYPE_BOOL, "0", "Make the envmap only apply to dx9 and higher hardware" ) |
|
SHADER_PARAM( FORCEBUMP, SHADER_PARAM_TYPE_BOOL, "0", "0 == Do bumpmapping if the card says it can handle it. 1 == Always do bumpmapping." ) |
|
SHADER_PARAM( ALPHATESTREFERENCE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" ) |
|
|
|
SHADER_PARAM( DETAILBLENDMODE, SHADER_PARAM_TYPE_INTEGER, "0", "mode for combining detail texture with base. 0=normal, 1= additive, 2=alpha blend detail over base, 3=crossfade" ) |
|
SHADER_PARAM( DETAILBLENDFACTOR, SHADER_PARAM_TYPE_FLOAT, "1", "blend amount for detail texture." ) |
|
|
|
// Emissive Scroll Pass |
|
SHADER_PARAM( EMISSIVEBLENDENABLED, SHADER_PARAM_TYPE_BOOL, "0", "Enable emissive blend pass" ) |
|
SHADER_PARAM( EMISSIVEBLENDBASETEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "self-illumination map" ) |
|
SHADER_PARAM( EMISSIVEBLENDSCROLLVECTOR, SHADER_PARAM_TYPE_VEC2, "[0.11 0.124]", "Emissive scroll vec" ) |
|
SHADER_PARAM( EMISSIVEBLENDSTRENGTH, SHADER_PARAM_TYPE_FLOAT, "1.0", "Emissive blend strength" ) |
|
SHADER_PARAM( EMISSIVEBLENDTEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "self-illumination map" ) |
|
SHADER_PARAM( EMISSIVEBLENDTINT, SHADER_PARAM_TYPE_COLOR, "[1 1 1]", "Self-illumination tint" ) |
|
SHADER_PARAM( TIME, SHADER_PARAM_TYPE_FLOAT, "0.0", "Needs CurrentTime Proxy" ) |
|
|
|
// Cloak Pass |
|
SHADER_PARAM( CLOAKPASSENABLED, SHADER_PARAM_TYPE_BOOL, "0", "Enables cloak render in a second pass" ) |
|
SHADER_PARAM( CLOAKFACTOR, SHADER_PARAM_TYPE_FLOAT, "0.0", "" ) |
|
SHADER_PARAM( CLOAKCOLORTINT, SHADER_PARAM_TYPE_COLOR, "[1 1 1]", "Cloak color tint" ) |
|
SHADER_PARAM( REFRACTAMOUNT, SHADER_PARAM_TYPE_FLOAT, "2", "" ) |
|
|
|
// Flesh Interior Pass |
|
SHADER_PARAM( FLESHINTERIORENABLED, SHADER_PARAM_TYPE_BOOL, "0", "Enable Flesh interior blend pass" ) |
|
SHADER_PARAM( FLESHINTERIORTEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "Flesh color texture" ) |
|
SHADER_PARAM( FLESHINTERIORNOISETEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "Flesh noise texture" ) |
|
SHADER_PARAM( FLESHBORDERTEXTURE1D, SHADER_PARAM_TYPE_TEXTURE, "", "Flesh border 1D texture" ) |
|
SHADER_PARAM( FLESHNORMALTEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "Flesh normal texture" ) |
|
SHADER_PARAM( FLESHSUBSURFACETEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "Flesh subsurface texture" ) |
|
SHADER_PARAM( FLESHCUBETEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "Flesh cubemap texture" ) |
|
SHADER_PARAM( FLESHBORDERNOISESCALE, SHADER_PARAM_TYPE_FLOAT, "1.5", "Flesh Noise UV scalar for border" ) |
|
SHADER_PARAM( FLESHDEBUGFORCEFLESHON, SHADER_PARAM_TYPE_BOOL, "0", "Flesh Debug full flesh" ) |
|
SHADER_PARAM( FLESHEFFECTCENTERRADIUS1, SHADER_PARAM_TYPE_VEC4, "[0 0 0 0.001]", "Flesh effect center and radius" ) |
|
SHADER_PARAM( FLESHEFFECTCENTERRADIUS2, SHADER_PARAM_TYPE_VEC4, "[0 0 0 0.001]", "Flesh effect center and radius" ) |
|
SHADER_PARAM( FLESHEFFECTCENTERRADIUS3, SHADER_PARAM_TYPE_VEC4, "[0 0 0 0.001]", "Flesh effect center and radius" ) |
|
SHADER_PARAM( FLESHEFFECTCENTERRADIUS4, SHADER_PARAM_TYPE_VEC4, "[0 0 0 0.001]", "Flesh effect center and radius" ) |
|
SHADER_PARAM( FLESHSUBSURFACETINT, SHADER_PARAM_TYPE_COLOR, "[1 1 1]", "Subsurface Color" ) |
|
SHADER_PARAM( FLESHBORDERWIDTH, SHADER_PARAM_TYPE_FLOAT, "0.3", "Flesh border" ) |
|
SHADER_PARAM( FLESHBORDERSOFTNESS, SHADER_PARAM_TYPE_FLOAT, "0.42", "Flesh border softness (> 0.0 && <= 0.5)" ) |
|
SHADER_PARAM( FLESHBORDERTINT, SHADER_PARAM_TYPE_COLOR, "[1 1 1]", "Flesh border Color" ) |
|
SHADER_PARAM( FLESHGLOBALOPACITY, SHADER_PARAM_TYPE_FLOAT, "1.0", "Flesh global opacity" ) |
|
SHADER_PARAM( FLESHGLOSSBRIGHTNESS, SHADER_PARAM_TYPE_FLOAT, "0.66", "Flesh gloss brightness" ) |
|
SHADER_PARAM( FLESHSCROLLSPEED, SHADER_PARAM_TYPE_FLOAT, "1.0", "Flesh scroll speed" ) |
|
|
|
// Color Replacement Pass |
|
SHADER_PARAM( BLENDTINTBYBASEALPHA, SHADER_PARAM_TYPE_BOOL, "0", "Use the base alpha to blend in the $color modulation") |
|
SHADER_PARAM( BLENDTINTCOLOROVERBASE, SHADER_PARAM_TYPE_FLOAT, "0", "blend between tint acting as a multiplication versus a replace" ) |
|
|
|
END_SHADER_PARAMS |
|
|
|
// Cloak Pass |
|
void SetupVarsCloakBlendedPass( CloakBlendedPassVars_t &info ) |
|
{ |
|
info.m_nCloakFactor = CLOAKFACTOR; |
|
info.m_nCloakColorTint = CLOAKCOLORTINT; |
|
info.m_nRefractAmount = REFRACTAMOUNT; |
|
|
|
// Delete these lines if not bump mapping! |
|
info.m_nBumpmap = BUMPMAP; |
|
info.m_nBumpFrame = BUMPFRAME; |
|
info.m_nBumpTransform = BUMPTRANSFORM; |
|
} |
|
|
|
bool NeedsPowerOfTwoFrameBufferTexture( IMaterialVar **params, bool bCheckSpecificToThisFrame ) const |
|
{ |
|
if ( params[CLOAKPASSENABLED]->GetIntValue() ) // If material supports cloaking |
|
{ |
|
if ( bCheckSpecificToThisFrame == false ) // For setting model flag at load time |
|
return true; |
|
else if ( ( params[CLOAKFACTOR]->GetFloatValue() > 0.0f ) && ( params[CLOAKFACTOR]->GetFloatValue() < 1.0f ) ) // Per-frame check |
|
return true; |
|
// else, not cloaking this frame, so check flag2 in case the base material still needs it |
|
} |
|
|
|
// Check flag2 if not drawing cloak pass |
|
return IS_FLAG2_SET( MATERIAL_VAR2_NEEDS_POWER_OF_TWO_FRAME_BUFFER_TEXTURE ); |
|
} |
|
|
|
bool IsTranslucent( IMaterialVar **params ) const |
|
{ |
|
if ( params[CLOAKPASSENABLED]->GetIntValue() ) // If material supports cloaking |
|
{ |
|
if ( ( params[CLOAKFACTOR]->GetFloatValue() > 0.0f ) && ( params[CLOAKFACTOR]->GetFloatValue() < 1.0f ) ) // Per-frame check |
|
return true; |
|
// else, not cloaking this frame, so check flag in case the base material still needs it |
|
} |
|
|
|
// Check flag if not drawing cloak pass |
|
return IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ); |
|
} |
|
|
|
// Emissive Scroll Pass |
|
void SetupVarsEmissiveScrollBlendedPass( EmissiveScrollBlendedPassVars_t &info ) |
|
{ |
|
info.m_nBlendStrength = EMISSIVEBLENDSTRENGTH; |
|
info.m_nBaseTexture = EMISSIVEBLENDBASETEXTURE; |
|
info.m_nFlowTexture = -1; // Not used in DX8 |
|
info.m_nEmissiveTexture = EMISSIVEBLENDTEXTURE; |
|
info.m_nEmissiveTint = EMISSIVEBLENDTINT; |
|
info.m_nEmissiveScrollVector = EMISSIVEBLENDSCROLLVECTOR; |
|
info.m_nTime = TIME; |
|
} |
|
|
|
// Flesh Interior Pass |
|
void SetupVarsFleshInteriorBlendedPass( FleshInteriorBlendedPassVars_t &info ) |
|
{ |
|
info.m_nFleshTexture = FLESHINTERIORTEXTURE; |
|
info.m_nFleshNoiseTexture = FLESHINTERIORNOISETEXTURE; |
|
info.m_nFleshBorderTexture1D = FLESHBORDERTEXTURE1D; |
|
info.m_nFleshNormalTexture = FLESHNORMALTEXTURE; |
|
info.m_nFleshSubsurfaceTexture = FLESHSUBSURFACETEXTURE; |
|
info.m_nFleshCubeTexture = FLESHCUBETEXTURE; |
|
|
|
info.m_nflBorderNoiseScale = FLESHBORDERNOISESCALE; |
|
info.m_nflDebugForceFleshOn = FLESHDEBUGFORCEFLESHON; |
|
info.m_nvEffectCenterRadius1 = FLESHEFFECTCENTERRADIUS1; |
|
info.m_nvEffectCenterRadius2 = FLESHEFFECTCENTERRADIUS2; |
|
info.m_nvEffectCenterRadius3 = FLESHEFFECTCENTERRADIUS3; |
|
info.m_nvEffectCenterRadius4 = FLESHEFFECTCENTERRADIUS4; |
|
|
|
info.m_ncSubsurfaceTint = FLESHSUBSURFACETINT; |
|
info.m_nflBorderWidth = FLESHBORDERWIDTH; |
|
info.m_nflBorderSoftness = FLESHBORDERSOFTNESS; |
|
info.m_ncBorderTint = FLESHBORDERTINT; |
|
info.m_nflGlobalOpacity = FLESHGLOBALOPACITY; |
|
info.m_nflGlossBrightness = FLESHGLOSSBRIGHTNESS; |
|
info.m_nflScrollSpeed = FLESHSCROLLSPEED; |
|
|
|
info.m_nTime = TIME; |
|
} |
|
|
|
SHADER_INIT_PARAMS() |
|
{ |
|
// FLASHLIGHTFIXME |
|
params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" ); |
|
|
|
// We don't want no stinking bump mapping on models in dx8. |
|
// Wait a minute! We want specular bump. .need to make that work by itself. |
|
// params[BUMPMAP]->SetUndefined(); |
|
// if( IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ) ) |
|
// { |
|
// CLEAR_FLAGS( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); |
|
// params[ENVMAP]->SetUndefined(); |
|
// } |
|
SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); |
|
|
|
if( !params[ENVMAPMASKSCALE]->IsDefined() ) |
|
params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f ); |
|
|
|
if( !params[ENVMAPMASKFRAME]->IsDefined() ) |
|
params[ENVMAPMASKFRAME]->SetIntValue( 0 ); |
|
|
|
if( !params[ENVMAPTINT]->IsDefined() ) |
|
params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); |
|
|
|
if( !params[SELFILLUMTINT]->IsDefined() ) |
|
params[SELFILLUMTINT]->SetVecValue( 1.0f, 1.0f, 1.0f ); |
|
|
|
if( !params[DETAILSCALE]->IsDefined() ) |
|
params[DETAILSCALE]->SetFloatValue( 4.0f ); |
|
|
|
if( !params[DETAILBLENDFACTOR]->IsDefined() ) |
|
params[DETAILBLENDFACTOR]->SetFloatValue( 1.0f ); |
|
|
|
if( !params[DETAILBLENDMODE]->IsDefined() ) |
|
params[DETAILBLENDMODE]->SetFloatValue( 0 ); |
|
|
|
if( !params[ENVMAPCONTRAST]->IsDefined() ) |
|
params[ENVMAPCONTRAST]->SetFloatValue( 0.0f ); |
|
|
|
if( !params[ENVMAPSATURATION]->IsDefined() ) |
|
params[ENVMAPSATURATION]->SetFloatValue( 1.0f ); |
|
|
|
if( !params[ENVMAPFRAME]->IsDefined() ) |
|
params[ENVMAPFRAME]->SetIntValue( 0 ); |
|
|
|
if( !params[BUMPFRAME]->IsDefined() ) |
|
params[BUMPFRAME]->SetIntValue( 0 ); |
|
|
|
if( !params[ALPHATESTREFERENCE]->IsDefined() ) |
|
params[ALPHATESTREFERENCE]->SetFloatValue( 0.0f ); |
|
|
|
// No texture means no self-illum or env mask in base alpha |
|
if ( !params[BASETEXTURE]->IsDefined() ) |
|
{ |
|
CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); |
|
CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); |
|
} |
|
|
|
// If in decal mode, no debug override... |
|
if (IS_FLAG_SET(MATERIAL_VAR_DECAL)) |
|
{ |
|
SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); |
|
} |
|
|
|
if( g_pConfig->UseBumpmapping() && params[BUMPMAP]->IsDefined() ) |
|
{ |
|
SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES ); |
|
} |
|
|
|
SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT ); |
|
|
|
// Get rid of the envmap if it's optional for this dx level. |
|
if( params[ENVMAPOPTIONAL]->IsDefined() && params[ENVMAPOPTIONAL]->GetIntValue() ) |
|
{ |
|
params[ENVMAP]->SetUndefined(); |
|
} |
|
|
|
// If mat_specular 0, then get rid of envmap |
|
if( !g_pConfig->UseSpecular() && params[ENVMAP]->IsDefined() && params[BASETEXTURE]->IsDefined() ) |
|
{ |
|
params[ENVMAP]->SetUndefined(); |
|
} |
|
|
|
// If a bumpmap is defined but an envmap isn't, then ignore the bumpmap. |
|
// It was meant to be used with diffuse |
|
if ( !params[ENVMAP]->IsDefined() ) |
|
{ |
|
params[BUMPMAP]->SetUndefined(); |
|
} |
|
|
|
// Cloak Pass |
|
if ( !params[CLOAKPASSENABLED]->IsDefined() ) |
|
{ |
|
params[CLOAKPASSENABLED]->SetIntValue( 0 ); |
|
} |
|
else if ( params[CLOAKPASSENABLED]->GetIntValue() ) |
|
{ |
|
CloakBlendedPassVars_t info; |
|
SetupVarsCloakBlendedPass( info ); |
|
InitParamsCloakBlendedPass( this, params, pMaterialName, info ); |
|
} |
|
|
|
// Emissive Scroll Pass |
|
if ( !params[EMISSIVEBLENDENABLED]->IsDefined() ) |
|
{ |
|
params[EMISSIVEBLENDENABLED]->SetIntValue( 0 ); |
|
} |
|
else if ( params[EMISSIVEBLENDENABLED]->GetIntValue() ) |
|
{ |
|
EmissiveScrollBlendedPassVars_t info; |
|
SetupVarsEmissiveScrollBlendedPass( info ); |
|
InitParamsEmissiveScrollBlendedPass( this, params, pMaterialName, info ); |
|
} |
|
|
|
// Flesh Interior Pass |
|
if ( !params[FLESHINTERIORENABLED]->IsDefined() ) |
|
{ |
|
params[FLESHINTERIORENABLED]->SetIntValue( 0 ); |
|
} |
|
else if ( params[FLESHINTERIORENABLED]->GetIntValue() ) |
|
{ |
|
FleshInteriorBlendedPassVars_t info; |
|
SetupVarsFleshInteriorBlendedPass( info ); |
|
InitParamsFleshInteriorBlendedPass( this, params, pMaterialName, info ); |
|
} |
|
|
|
// Color Replacement Pass |
|
if ( !params[BLENDTINTBYBASEALPHA]->IsDefined() ) |
|
{ |
|
params[BLENDTINTBYBASEALPHA]->SetIntValue(0); |
|
} |
|
|
|
if ( !params[BLENDTINTCOLOROVERBASE]->IsDefined() ) |
|
{ |
|
params[BLENDTINTCOLOROVERBASE]->SetFloatValue(0); |
|
} |
|
} |
|
|
|
SHADER_FALLBACK |
|
{ |
|
if ( IsPC() ) |
|
{ |
|
if ( g_pHardwareConfig->GetDXSupportLevel() < 70) |
|
return "VertexLitGeneric_DX6"; |
|
|
|
if ( g_pHardwareConfig->GetDXSupportLevel() < 80) |
|
return "VertexLitGeneric_DX7"; |
|
|
|
if ( g_pHardwareConfig->PreferReducedFillrate() ) |
|
return "VertexLitGeneric_NoBump_DX8"; |
|
} |
|
return 0; |
|
} |
|
|
|
SHADER_INIT |
|
{ |
|
LoadTexture( FLASHLIGHTTEXTURE ); |
|
|
|
if (params[BASETEXTURE]->IsDefined()) |
|
{ |
|
LoadTexture( BASETEXTURE ); |
|
|
|
if (!params[BASETEXTURE]->GetTextureValue()->IsTranslucent()) |
|
{ |
|
CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM ); |
|
CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK ); |
|
} |
|
} |
|
|
|
if (params[DETAIL]->IsDefined()) |
|
{ |
|
LoadTexture( DETAIL ); |
|
} |
|
|
|
if (g_pConfig->UseBumpmapping() && params[BUMPMAP]->IsDefined()) |
|
{ |
|
LoadBumpMap( BUMPMAP ); |
|
} |
|
|
|
// Don't alpha test if the alpha channel is used for other purposes |
|
if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM) || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) ) |
|
{ |
|
CLEAR_FLAGS( MATERIAL_VAR_ALPHATEST ); |
|
} |
|
|
|
if (params[ENVMAP]->IsDefined()) |
|
{ |
|
if( !IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) ) |
|
{ |
|
LoadCubeMap( ENVMAP ); |
|
} |
|
else |
|
{ |
|
LoadTexture( ENVMAP ); |
|
} |
|
|
|
if( !g_pHardwareConfig->SupportsCubeMaps() ) |
|
{ |
|
SET_FLAGS( MATERIAL_VAR_ENVMAPSPHERE ); |
|
} |
|
|
|
if (params[ENVMAPMASK]->IsDefined()) |
|
{ |
|
LoadTexture( ENVMAPMASK ); |
|
} |
|
} |
|
|
|
// Cloak Pass |
|
if ( params[CLOAKPASSENABLED]->GetIntValue() ) |
|
{ |
|
CloakBlendedPassVars_t info; |
|
SetupVarsCloakBlendedPass( info ); |
|
InitCloakBlendedPass( this, params, info ); |
|
} |
|
|
|
// Emissive Scroll Pass |
|
if ( params[EMISSIVEBLENDENABLED]->GetIntValue() ) |
|
{ |
|
EmissiveScrollBlendedPassVars_t info; |
|
SetupVarsEmissiveScrollBlendedPass( info ); |
|
InitEmissiveScrollBlendedPass( this, params, info ); |
|
} |
|
|
|
// Flesh Interior Pass |
|
if ( params[FLESHINTERIORENABLED]->GetIntValue() ) |
|
{ |
|
FleshInteriorBlendedPassVars_t info; |
|
SetupVarsFleshInteriorBlendedPass( info ); |
|
InitFleshInteriorBlendedPass( this, params, info ); |
|
} |
|
} |
|
|
|
inline const char *GetUnbumpedPixelShaderName( IMaterialVar** params, bool bSkipEnvmap ) |
|
{ |
|
static char const* s_pPixelShaders[] = |
|
{ |
|
"VertexLitGeneric_EnvmapV2", |
|
"VertexLitGeneric_SelfIlluminatedEnvmapV2", |
|
|
|
"VertexLitGeneric_BaseAlphaMaskedEnvmapV2", |
|
"VertexLitGeneric_SelfIlluminatedEnvmapV2", |
|
|
|
// Env map mask |
|
"VertexLitGeneric_MaskedEnvmapV2", |
|
"VertexLitGeneric_SelfIlluminatedMaskedEnvmapV2", |
|
|
|
"VertexLitGeneric_MaskedEnvmapV2", |
|
"VertexLitGeneric_SelfIlluminatedMaskedEnvmapV2", |
|
|
|
// Detail |
|
"VertexLitGeneric_DetailEnvmapV2", |
|
"VertexLitGeneric_DetailSelfIlluminatedEnvmapV2", |
|
|
|
"VertexLitGeneric_DetailBaseAlphaMaskedEnvmapV2", |
|
"VertexLitGeneric_DetailSelfIlluminatedEnvmapV2", |
|
|
|
// Env map mask |
|
"VertexLitGeneric_DetailMaskedEnvmapV2", |
|
"VertexLitGeneric_DetailSelfIlluminatedMaskedEnvmapV2", |
|
|
|
"VertexLitGeneric_DetailMaskedEnvmapV2", |
|
"VertexLitGeneric_DetailSelfIlluminatedMaskedEnvmapV2", |
|
}; |
|
|
|
if ( !params[BASETEXTURE]->IsTexture() ) |
|
{ |
|
if (params[ENVMAP]->IsTexture() && !bSkipEnvmap ) |
|
{ |
|
if (!params[ENVMAPMASK]->IsTexture()) |
|
{ |
|
return "VertexLitGeneric_EnvmapNoTexture"; |
|
} |
|
else |
|
{ |
|
return "VertexLitGeneric_MaskedEnvmapNoTexture"; |
|
} |
|
} |
|
else |
|
{ |
|
if ( params[DETAIL]->IsTexture() ) |
|
{ |
|
return "VertexLitGeneric_DetailNoTexture"; |
|
} |
|
else |
|
{ |
|
return "VertexLitGeneric_NoTexture"; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if ( params[BLENDTINTBYBASEALPHA]->GetIntValue() ) |
|
{ |
|
return "VertexLitGeneric_BlendTint"; |
|
} |
|
else if ( params[ENVMAP]->IsTexture() && !bSkipEnvmap ) |
|
{ |
|
int pshIndex = 0; |
|
if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM)) |
|
pshIndex |= 0x1; |
|
if (IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK)) |
|
pshIndex |= 0x2; |
|
if (params[ENVMAPMASK]->IsTexture()) |
|
pshIndex |= 0x4; |
|
if (params[DETAIL]->IsTexture()) |
|
pshIndex |= 0x8; |
|
return s_pPixelShaders[pshIndex]; |
|
} |
|
else |
|
{ |
|
if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM)) |
|
{ |
|
if ( params[DETAIL]->IsTexture() ) |
|
return "VertexLitGeneric_DetailSelfIlluminated"; |
|
else |
|
return "VertexLitGeneric_SelfIlluminated"; |
|
} |
|
else if ( params[DETAIL]->IsTexture() ) |
|
{ |
|
switch( params[DETAILBLENDMODE]->GetIntValue() ) |
|
{ |
|
case 0: |
|
return "VertexLitGeneric_Detail"; |
|
|
|
case 1: // additive modes |
|
return "VertexLitGeneric_Detail_Additive"; |
|
|
|
case 5: |
|
case 6: |
|
return "VertexLitGeneric_Detail_Additive_selfillum"; |
|
break; |
|
|
|
default: |
|
return "VertexLitGeneric_Detail_LerpBase"; |
|
} |
|
} |
|
else |
|
{ |
|
return "VertexLitGeneric"; |
|
} |
|
} |
|
} |
|
} |
|
|
|
void DrawUnbumpedUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bSkipEnvmap ) |
|
{ |
|
SHADOW_STATE |
|
{ |
|
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); |
|
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) ); |
|
|
|
if ( params[ALPHATESTREFERENCE]->GetFloatValue() > 0.0f ) |
|
{ |
|
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[ALPHATESTREFERENCE]->GetFloatValue() ); |
|
} |
|
|
|
int fmt = VERTEX_POSITION | VERTEX_NORMAL; |
|
|
|
// FIXME: We could enable this, but we'd never get it working on dx7 or lower |
|
// FIXME: This isn't going to work until we make more vertex shaders that |
|
// pass the vertex color and alpha values through. |
|
#if 0 |
|
if ( IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) || IS_FLAG_SET( MATERIAL_VAR_VERTEXALPHA ) ) |
|
fmt |= VERTEX_COLOR; |
|
#endif |
|
|
|
if (params[ENVMAP]->IsTexture() && !bSkipEnvmap ) |
|
{ |
|
// envmap on stage 1 |
|
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); |
|
|
|
// envmapmask on stage 2 |
|
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK ) ) |
|
{ |
|
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); |
|
} |
|
} |
|
|
|
if (params[BASETEXTURE]->IsTexture()) |
|
{ |
|
SetDefaultBlendingShadowState( BASETEXTURE, true ); |
|
} |
|
else |
|
{ |
|
SetDefaultBlendingShadowState( ENVMAPMASK, false ); |
|
} |
|
|
|
if ( params[DETAIL]->IsTexture()) |
|
{ |
|
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); |
|
} |
|
|
|
pShaderShadow->VertexShaderVertexFormat( fmt, 1, 0, 0 ); |
|
|
|
// Set up the vertex shader index. |
|
vertexlitgeneric_vs11_Static_Index vshIndex; |
|
vshIndex.SetHALF_LAMBERT( IS_FLAG_SET( MATERIAL_VAR_HALFLAMBERT ) ); |
|
//vshIndex.SetDETAIL( params[DETAIL]->IsTexture() ); |
|
if( params[ENVMAP]->IsTexture() && !bSkipEnvmap ) |
|
{ |
|
vshIndex.SetENVMAP( true ); |
|
vshIndex.SetENVMAPCAMERASPACE( IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE) ); |
|
if( IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE) ) |
|
{ |
|
vshIndex.SetENVMAPSPHERE( false ); |
|
} |
|
else |
|
{ |
|
vshIndex.SetENVMAPSPHERE( IS_FLAG_SET( MATERIAL_VAR_ENVMAPSPHERE ) ); |
|
} |
|
} |
|
else |
|
{ |
|
vshIndex.SetENVMAP( false ); |
|
vshIndex.SetENVMAPCAMERASPACE( false ); |
|
vshIndex.SetENVMAPSPHERE( false ); |
|
} |
|
pShaderShadow->SetVertexShader( "vertexlitgeneric_vs11", vshIndex.GetIndex() ); |
|
|
|
const char *pshName = GetUnbumpedPixelShaderName( params, bSkipEnvmap ); |
|
pShaderShadow->SetPixelShader( pshName ); |
|
DefaultFog(); |
|
pShaderShadow->EnableAlphaWrites( true ); |
|
} |
|
DYNAMIC_STATE |
|
{ |
|
if (params[BASETEXTURE]->IsTexture()) |
|
{ |
|
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME ); |
|
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM ); |
|
} |
|
|
|
// if (params[ENVMAP]->IsTexture()) |
|
if (params[ENVMAP]->IsTexture() && !bSkipEnvmap ) |
|
{ |
|
BindTexture( SHADER_SAMPLER1, ENVMAP, ENVMAPFRAME ); |
|
|
|
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) ) |
|
{ |
|
if (params[ENVMAPMASK]->IsTexture() ) |
|
BindTexture( SHADER_SAMPLER2, ENVMAPMASK, ENVMAPMASKFRAME ); |
|
else |
|
BindTexture( SHADER_SAMPLER2, BASETEXTURE, FRAME ); |
|
|
|
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, ENVMAPMASKSCALE ); |
|
} |
|
|
|
if (IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) || |
|
IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE)) |
|
{ |
|
LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_VIEWMODEL ); |
|
} |
|
SetEnvMapTintPixelShaderDynamicState( 2, ENVMAPTINT, -1 ); |
|
} |
|
|
|
if ( params[DETAIL]->IsTexture()) |
|
{ |
|
BindTexture( SHADER_SAMPLER3, DETAIL, DETAILFRAME ); |
|
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, BASETEXTURETRANSFORM, DETAILSCALE ); |
|
} |
|
|
|
SetAmbientCubeDynamicStateVertexShader(); |
|
SetModulationPixelShaderDynamicState( 3 ); |
|
EnablePixelShaderOverbright( 0, true, true ); |
|
SetPixelShaderConstant( 1, SELFILLUMTINT ); |
|
|
|
if ( params[DETAIL]->IsTexture() && ( ! IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ) ) ) |
|
{ |
|
float c1[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; |
|
c1[0] = c1[1] = c1[2] = c1[3] = params[DETAILBLENDFACTOR]->GetFloatValue(); |
|
pShaderAPI->SetPixelShaderConstant( 1, c1, 1 ); |
|
} |
|
|
|
if ( params[BLENDTINTBYBASEALPHA]->GetIntValue() ) |
|
{ |
|
float c1[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; |
|
c1[0] = c1[1] = c1[2] = c1[3] = params[BLENDTINTCOLOROVERBASE]->GetFloatValue(); |
|
pShaderAPI->SetPixelShaderConstant( 1, c1 ); |
|
} |
|
|
|
vertexlitgeneric_vs11_Dynamic_Index vshIndex; |
|
vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ); |
|
vshIndex.SetSKINNING( pShaderAPI->GetCurrentNumBones() > 0 ); |
|
vshIndex.SetLIGHT_COMBO( pShaderAPI->GetCurrentLightCombo() ); |
|
pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() ); |
|
if( pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_WRITE_DEPTH_TO_DESTALPHA ) ) |
|
{ |
|
pShaderAPI->SetPixelShaderIndex( 0 ); |
|
} |
|
else |
|
{ |
|
// write 255 to alpha if we aren't told to write depth to dest alpha (We don't ever actually write depth to dest alpha in dx8) |
|
pShaderAPI->SetPixelShaderIndex( 1 ); |
|
float c4[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; |
|
pShaderAPI->SetPixelShaderConstant( 4, c4, 1 ); |
|
} |
|
} |
|
Draw(); |
|
} |
|
|
|
SHADER_DRAW |
|
{ |
|
// Skip the standard rendering if cloak pass is fully opaque |
|
bool bDrawStandardPass = true; |
|
if ( false/*disabled! no effect*/ && params[CLOAKPASSENABLED]->GetIntValue() && ( pShaderShadow == NULL ) ) // && not snapshotting |
|
{ |
|
CloakBlendedPassVars_t info; |
|
SetupVarsCloakBlendedPass( info ); |
|
if ( CloakBlendedPassIsFullyOpaque( params, info ) ) |
|
{ |
|
// There is some strangeness in DX8 when trying to skip the main pass, so leave this alone for now |
|
//bDrawStandardPass = false; |
|
} |
|
} |
|
|
|
// Standard rendering pass |
|
if ( bDrawStandardPass ) |
|
{ |
|
// FLASHLIGHTFIXME: need to make these the same. |
|
bool hasFlashlight = UsingFlashlight( params ); |
|
bool bBump = g_pConfig->UseBumpmapping() && params[BUMPMAP]->IsTexture(); |
|
|
|
if( hasFlashlight ) |
|
{ |
|
DrawFlashlight_dx80( params, pShaderAPI, pShaderShadow, bBump, BUMPMAP, BUMPFRAME, BUMPTRANSFORM, |
|
FLASHLIGHTTEXTURE, FLASHLIGHTTEXTUREFRAME, false, false, 0, -1, -1 ); |
|
} |
|
else if( bBump ) |
|
{ |
|
bool bSkipEnvmap = true; |
|
DrawUnbumpedUsingVertexShader( params, pShaderAPI, pShaderShadow, bSkipEnvmap ); |
|
|
|
// specular pass |
|
bool bBlendSpecular = true; |
|
if( params[ENVMAP]->IsTexture() ) |
|
{ |
|
DrawModelBumpedSpecularLighting( BUMPMAP, BUMPFRAME, ENVMAP, ENVMAPFRAME, |
|
ENVMAPTINT, ALPHA, ENVMAPCONTRAST, ENVMAPSATURATION, BUMPTRANSFORM, bBlendSpecular ); |
|
} |
|
} |
|
else |
|
{ |
|
bool bSkipEnvmap = false; |
|
DrawUnbumpedUsingVertexShader( params, pShaderAPI, pShaderShadow, bSkipEnvmap ); |
|
} |
|
} |
|
else |
|
{ |
|
// Skip this pass! |
|
Draw( false ); |
|
} |
|
|
|
// Cloak Pass |
|
if ( params[CLOAKPASSENABLED]->GetIntValue() ) |
|
{ |
|
// If ( snapshotting ) or ( we need to draw this frame ) |
|
if ( ( pShaderShadow != NULL ) || ( ( params[CLOAKFACTOR]->GetFloatValue() > 0.0f ) && ( params[CLOAKFACTOR]->GetFloatValue() < 1.0f ) ) ) |
|
{ |
|
CloakBlendedPassVars_t info; |
|
SetupVarsCloakBlendedPass( info ); |
|
DrawCloakBlendedPass( this, params, pShaderAPI, pShaderShadow, info, vertexCompression ); |
|
} |
|
else // We're not snapshotting and we don't need to draw this frame |
|
{ |
|
// Skip this pass! |
|
Draw( false ); |
|
} |
|
} |
|
|
|
// Emissive Scroll Pass |
|
if ( params[EMISSIVEBLENDENABLED]->GetIntValue() ) |
|
{ |
|
// If ( snapshotting ) or ( we need to draw this frame ) |
|
if ( ( pShaderShadow != NULL ) || ( params[EMISSIVEBLENDSTRENGTH]->GetFloatValue() > 0.0f ) ) |
|
{ |
|
EmissiveScrollBlendedPassVars_t info; |
|
SetupVarsEmissiveScrollBlendedPass( info ); |
|
DrawEmissiveScrollBlendedPass( this, params, pShaderAPI, pShaderShadow, info, vertexCompression ); |
|
} |
|
else // We're not snapshotting and we don't need to draw this frame |
|
{ |
|
// Skip this pass! |
|
Draw( false ); |
|
} |
|
} |
|
|
|
// Flesh Interior Pass |
|
if ( params[FLESHINTERIORENABLED]->GetIntValue() ) |
|
{ |
|
// If ( snapshotting ) or ( we need to draw this frame ) |
|
if ( ( pShaderShadow != NULL ) || ( true ) ) |
|
{ |
|
FleshInteriorBlendedPassVars_t info; |
|
SetupVarsFleshInteriorBlendedPass( info ); |
|
DrawFleshInteriorBlendedPass( this, params, pShaderAPI, pShaderShadow, info, vertexCompression ); |
|
} |
|
else // We're not snapshotting and we don't need to draw this frame |
|
{ |
|
// Skip this pass! |
|
Draw( false ); |
|
} |
|
} |
|
} |
|
END_SHADER |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Version that doesn't do bumpmapping |
|
//----------------------------------------------------------------------------- |
|
BEGIN_INHERITED_SHADER( VertexLitGeneric_NoBump_DX8, VertexLitGeneric_DX8, |
|
"Help for VertexLitGeneric_NoBump_DX8" ) |
|
|
|
SHADER_FALLBACK |
|
{ |
|
if (g_pConfig->bSoftwareLighting) |
|
return "VertexLitGeneric_DX6"; |
|
|
|
if (!g_pHardwareConfig->SupportsVertexAndPixelShaders()) |
|
return "VertexLitGeneric_DX7"; |
|
|
|
return 0; |
|
} |
|
|
|
virtual bool ShouldUseBumpmapping( IMaterialVar **params ) |
|
{ |
|
if ( !g_pConfig->UseBumpmapping() ) |
|
return false; |
|
|
|
if ( !params[BUMPMAP]->IsDefined() ) |
|
return false; |
|
|
|
return ( params[FORCEBUMP]->GetIntValue() != 0 ); |
|
} |
|
|
|
END_INHERITED_SHADER |
|
|
|
|