Added many shader source files

This should include the latest version of every shader that was in the
2007 SDK. It also includes a smattering of debug shaders, both VR
distortion shaders, and other assorted shaders that will hopefully be
useful.

None of these new files are included in the game shader DLL project. If
you need to modify one of these shaders for use in your mod you will
need to rename it so that you don't collide with the version of that
shader that lives in stdshader_dx9.dll.

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
+