diff options
Diffstat (limited to 'mp/src/materialsystem/stdshaders/vertexlitgeneric_dx8.cpp')
| -rw-r--r-- | mp/src/materialsystem/stdshaders/vertexlitgeneric_dx8.cpp | 807 |
1 files changed, 807 insertions, 0 deletions
diff --git a/mp/src/materialsystem/stdshaders/vertexlitgeneric_dx8.cpp b/mp/src/materialsystem/stdshaders/vertexlitgeneric_dx8.cpp new file mode 100644 index 00000000..31addf42 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/vertexlitgeneric_dx8.cpp @@ -0,0 +1,807 @@ +//========= 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 + |