1HEADmaster

1 files changed, 696 insertions, 0 deletions

diff --git a/materialsystem/stdshaders/pyro_vision.cpp b/materialsystem/stdshaders/pyro_vision.cpp
new file mode 100644
index 0000000..9c861c7
--- /dev/null
+++ b/materialsystem/stdshaders/pyro_vision.cpp
@@ -0,0 +1,696 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#include "BaseVSShader.h"
+#include "commandbuilder.h"
+
+#include "pyro_vision_ps20.inc"
+#include "pyro_vision_ps20b.inc"
+#include "pyro_vision_vs20.inc"
+#include "pyro_vision_ps30.inc"
+#include "pyro_vision_vs30.inc"
+
+#include "../materialsystem_global.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+static ConVar mat_visualize_dof( "mat_visualize_dof", "0", FCVAR_CHEAT );
+
+
+class CPyroVision_DX9_Context : public CBasePerMaterialContextData
+{
+public:
+	uint8 *m_pStaticCmds;
+	CCommandBufferBuilder< CFixedCommandStorageBuffer< 1000 > > m_SemiStaticCmdsOut;
+
+	void ResetStaticCmds( void )
+	{
+		if ( m_pStaticCmds )
+		{
+			delete[] m_pStaticCmds;
+			m_pStaticCmds = NULL;
+		}
+	}
+
+	CPyroVision_DX9_Context( void )
+	{
+		m_pStaticCmds = NULL;
+	}
+
+	~CPyroVision_DX9_Context( void )
+	{
+		ResetStaticCmds();
+	}
+
+};
+
+
+static const float kDefaultStripeScale[ 3 ] = { 0.002f, 0.002f, 0.2f };
+static const float kDefaultStripeFadeNormal1[ 3 ] = { 0.0f, 0.0f, 1.0f };
+static const float kDefaultStripeFadeNormal2[ 3 ] = { 0.0f, 0.0f, 0.0f };
+static const float kDefaultStripeColor[ 3 ] = { 0.0f, 1.0f, 1.0f };
+static const float kDefaultSelfIllumTint[ 3 ] = { 1.0f, 1.0f, 1.0f };
+static const float kDefaultGrayStep[ 2 ] = { 0.0f, 1.0f };
+
+
+BEGIN_VS_SHADER( pyro_vision, "Help for pyro vision" )
+	BEGIN_SHADER_PARAMS
+	
+		SHADER_PARAM( EFFECT, SHADER_PARAM_TYPE_INTEGER, "0.0", "" )
+
+		SHADER_PARAM( VERTEX_LIT, SHADER_PARAM_TYPE_INTEGER, "0.0", "" )
+		SHADER_PARAM( FULLBRIGHT, SHADER_PARAM_TYPE_INTEGER, "0.0", "" )
+		SHADER_PARAM( ALPHATESTREFERENCE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )	
+		
+		SHADER_PARAM( BASETEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "" )
+		SHADER_PARAM( BASETEXTURE2, SHADER_PARAM_TYPE_TEXTURE, "shadertest/detail", "detail texture" )
+		SHADER_PARAM( BLENDMODULATETEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "texture to use r/g channels for blend range for" )
+		SHADER_PARAM( BLENDMASKTRANSFORM, SHADER_PARAM_TYPE_MATRIX, "center .5 .5 scale 1 1 rotate 0 translate 0 0", "$blendmodulatetexture texcoord transform" )
+
+		SHADER_PARAM( STRIPETEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "" )
+		SHADER_PARAM( STRIPE_SCALE, SHADER_PARAM_TYPE_VEC3, "[ 0.002 0.002 0.2 ]", "" )
+		SHADER_PARAM( STRIPE_FADE_NORMAL1, SHADER_PARAM_TYPE_VEC3, "[ 0.0 0.0 1.0 ]", "" )
+		SHADER_PARAM( STRIPE_FADE_NORMAL2, SHADER_PARAM_TYPE_VEC3, "[ 0.0 0.0 0.0 ]", "" )
+		SHADER_PARAM( STRIPE_COLOR, SHADER_PARAM_TYPE_VEC3, "[ 0.0 0.0 0.0 ]", "" )
+		SHADER_PARAM( STRIPE_LM_SCALE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+
+		// EFFECT 0
+		SHADER_PARAM( BASE_STEP_RANGE, SHADER_PARAM_TYPE_VEC2, "[ 0.0 1.0 ]", "" )
+		SHADER_PARAM( LIGHTMAP_STEP_RANGE, SHADER_PARAM_TYPE_VEC2, "[ 0.0 1.0 ]", "" )
+		SHADER_PARAM( CANVAS, SHADER_PARAM_TYPE_TEXTURE, "", "" )
+		SHADER_PARAM( CANVAS_SCALE, SHADER_PARAM_TYPE_VEC3, "[ 0.002 0.002 0.2 ]", "" )
+		SHADER_PARAM( CANVAS_STEP_RANGE, SHADER_PARAM_TYPE_VEC2, "[ 0.0 1.0 ]", "" )
+		SHADER_PARAM( CANVAS_COLOR_START, SHADER_PARAM_TYPE_VEC3, "[ 0.0 0.0 0.0 ]", "" )
+		SHADER_PARAM( CANVAS_COLOR_END, SHADER_PARAM_TYPE_VEC3, "[ 0.0 0.0 0.0 ]", "" )
+
+		// EFFECT 1
+		SHADER_PARAM( DIFFUSE_BASE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+		SHADER_PARAM( DIFFUSE_WHITE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+		SHADER_PARAM( GRAY_POWER, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+		SHADER_PARAM( GRAY_STEP, SHADER_PARAM_TYPE_VEC2, "[ 0.0 1.0 ]", "" )
+		SHADER_PARAM( LIGHTMAP_GRADIENTS, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+		SHADER_PARAM( COLORBAR, SHADER_PARAM_TYPE_TEXTURE, "", "" )
+		SHADER_PARAM( SELFILLUMTINT, SHADER_PARAM_TYPE_COLOR, "[ 1.0 1.0 1.0 ]", "Self-illumination tint" )
+		
+		// EFFECT 2 Depth of Field
+		SHADER_PARAM( DOF_START_DISTANCE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+		SHADER_PARAM( DOF_POWER, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+		SHADER_PARAM( DOF_MAX, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+
+		// EFFECT 3 Pyro Post
+		SHADER_PARAM( WARPTEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "" )
+		SHADER_PARAM( NOISETEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "" )
+		SHADER_PARAM( VIGNETTE_TEXTURE, SHADER_PARAM_TYPE_TEXTURE, "", "" )
+		SHADER_PARAM( VIGNETTE_TILE, SHADER_PARAM_TYPE_TEXTURE, "", "" )
+		SHADER_PARAM( NOISE_SCALE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+		SHADER_PARAM( TIME_SCALE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+		SHADER_PARAM( HEAT_HAZE_SCALE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+	
+	END_SHADER_PARAMS
+
+	SHADER_INIT_PARAMS()
+	{
+		SET_PARAM_INT_IF_NOT_DEFINED( EFFECT, 0 );
+		SET_PARAM_INT_IF_NOT_DEFINED( VERTEX_LIT, 0 );
+		SET_PARAM_INT_IF_NOT_DEFINED( FULLBRIGHT, 0 );
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( ALPHATESTREFERENCE, 0.0f );
+
+		SET_PARAM_STRING_IF_NOT_DEFINED( BLENDMASKTRANSFORM, "center .5 .5 scale 1 1 rotate 0 translate 0 0" );
+
+		SET_PARAM_VEC_IF_NOT_DEFINED( STRIPE_SCALE, kDefaultStripeScale, 3 );
+		SET_PARAM_VEC_IF_NOT_DEFINED( STRIPE_FADE_NORMAL1, kDefaultStripeFadeNormal1, 3 );
+		SET_PARAM_VEC_IF_NOT_DEFINED( STRIPE_FADE_NORMAL2, kDefaultStripeFadeNormal2, 3 );
+		SET_PARAM_VEC_IF_NOT_DEFINED( STRIPE_COLOR, kDefaultStripeColor, 3 );
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( STRIPE_LM_SCALE, 0.0f );
+
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( DIFFUSE_BASE, 0.0f );
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( DIFFUSE_WHITE, 0.0f );
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( GRAY_POWER, 1.0f );
+		SET_PARAM_VEC_IF_NOT_DEFINED( GRAY_STEP, kDefaultGrayStep, 2 );
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( LIGHTMAP_GRADIENTS, 255.0f );
+		
+		
+		SET_PARAM_VEC_IF_NOT_DEFINED( SELFILLUMTINT, kDefaultSelfIllumTint, 3 );
+
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( DOF_START_DISTANCE, 0.1f );
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( DOF_POWER, 0.4f );
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( DOF_MAX, 0.7f );
+
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( NOISE_SCALE, 0.2f );
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( TIME_SCALE, 0.02f );
+		SET_PARAM_FLOAT_IF_NOT_DEFINED( HEAT_HAZE_SCALE, 0.2f );
+
+		bool	bVertexLit = params[ VERTEX_LIT ]->GetIntValue() != 0;
+
+		if ( bVertexLit )
+		{
+			SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT );
+		}
+		SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING );
+	}
+
+	SHADER_FALLBACK
+	{
+		return 0;
+	}
+
+	SHADER_INIT
+	{
+		LoadTexture( BASETEXTURE, TEXTUREFLAGS_SRGB );
+
+		if ( params[ CANVAS ]->IsDefined() )
+		{
+			LoadTexture( CANVAS, TEXTUREFLAGS_SRGB );
+		}
+
+		if ( params[ COLORBAR ]->IsDefined() )
+		{
+			LoadTexture( COLORBAR, TEXTUREFLAGS_SRGB );
+		}
+
+		if ( params[ BASETEXTURE2 ]->IsDefined() )
+		{
+			LoadTexture( BASETEXTURE2, TEXTUREFLAGS_SRGB );
+		}
+
+		if ( params[ BLENDMODULATETEXTURE ]->IsDefined() )
+		{
+			LoadTexture( BLENDMODULATETEXTURE );
+		}
+
+		if ( params[ STRIPETEXTURE ]->IsDefined() )
+		{
+			LoadTexture( STRIPETEXTURE, TEXTUREFLAGS_SRGB );
+		}
+
+		if ( params[ WARPTEXTURE ]->IsDefined() )
+		{
+			LoadTexture( WARPTEXTURE );
+		}
+
+		if ( params[ NOISETEXTURE ]->IsDefined() )
+		{
+			LoadTexture( NOISETEXTURE );
+		}
+
+		if ( params[ VIGNETTE_TEXTURE ]->IsDefined() )
+		{
+			LoadTexture( VIGNETTE_TEXTURE );
+		}
+
+		if ( params[ VIGNETTE_TILE ]->IsDefined() )
+		{
+			LoadTexture( VIGNETTE_TILE, TEXTUREFLAGS_SRGB );
+		}
+	}
+
+	SHADER_DRAW
+	{
+		CPyroVision_DX9_Context		*pContextData = reinterpret_cast< CPyroVision_DX9_Context *> ( *pContextDataPtr );
+		bool						bNeedRegenStaticCmds = ( !pContextData ) || pShaderShadow;
+		bool						bVertexLit = params[ VERTEX_LIT ]->GetIntValue() != 0;
+		bool						bFullBright = params[ FULLBRIGHT ]->GetIntValue() != 0;
+		bool						bUseStaticControlFlow = g_pHardwareConfig->SupportsStaticControlFlow();
+		bool						bHasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
+		bool						bHasBaseTexture2 = ( params[ BASETEXTURE2 ]->IsDefined() ) && ( params[ BASETEXTURE2 ]->IsTexture() );
+		bool						bHasBlendModulateTexture = bHasBaseTexture2 && ( params[ BLENDMODULATETEXTURE ]->IsDefined() ) && ( params[ BLENDMODULATETEXTURE ]->IsTexture() );
+		bool						bHasHeatHaze = ( params[ WARPTEXTURE ]->IsDefined() ) && ( params[ WARPTEXTURE ]->IsTexture() );
+		int							nEffect = params[ EFFECT ]->GetIntValue();
+		bool						bSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM );
+		bool						bVisualizeDoF = mat_visualize_dof.GetBool();
+		bool						bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0;
+		bool						bFullyOpaque = !bIsAlphaTested;
+		bool						bHasColorbar = ( params[ COLORBAR ]->IsDefined() ) && ( params[ COLORBAR ]->IsTexture() );
+		bool						bHasStripes = ( params[ STRIPETEXTURE ]->IsDefined() ) && ( params[ STRIPETEXTURE ]->IsTexture() );
+		bool						bHasStripesNormal2 = false;
+		if ( bHasStripes )
+		{
+			Vector vNormal2;
+
+			params[ STRIPE_FADE_NORMAL2 ]->GetVecValue( vNormal2.Base(), 3 );
+
+			if ( vNormal2.LengthSqr() > 0.5f )
+			{
+				bHasStripesNormal2 = true;
+			}
+		}
+
+		if ( !pContextData )								// make sure allocated
+		{
+			pContextData = new CPyroVision_DX9_Context;
+			*pContextDataPtr = pContextData;
+		}
+
+		if ( nEffect == 3 )
+		{
+			static ConVarRef  pyro_vignette_distortion( "pyro_vignette_distortion" );
+
+			bHasHeatHaze &= pyro_vignette_distortion.GetBool();
+		}
+
+
+		if ( pShaderShadow || bNeedRegenStaticCmds )
+		{
+			pContextData->ResetStaticCmds();
+			CCommandBufferBuilder< CFixedCommandStorageBuffer< 5000 > > staticCmdsBuf;
+
+			Vector4D vParms(0, 0, 0, 0);
+
+			params[ STRIPE_SCALE ]->GetVecValue( &vParms.x, 3 );
+			staticCmdsBuf.SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, vParms.Base() );
+
+			staticCmdsBuf.BindTexture( this, SHADER_SAMPLER0, BASETEXTURE, -1 );
+			staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
+			if ( bHasBlendModulateTexture )
+			{
+				staticCmdsBuf.BindTexture( this, SHADER_SAMPLER3, BLENDMODULATETEXTURE, -1 );
+				staticCmdsBuf.BindTexture( this, SHADER_SAMPLER4, BASETEXTURE2, -1 );
+			}
+
+			if ( bHasStripes )
+			{
+				staticCmdsBuf.BindTexture( this, SHADER_SAMPLER5, STRIPETEXTURE, -1 );
+				
+				params[ STRIPE_COLOR ]->GetVecValue( &vParms.x, 3 );
+				vParms.w = params[ STRIPE_LM_SCALE ]->GetFloatValue();
+				staticCmdsBuf.SetPixelShaderConstant( 5, vParms.Base() );
+
+				params[ STRIPE_FADE_NORMAL1 ]->GetVecValue( &vParms.x, 3 );
+				staticCmdsBuf.SetPixelShaderConstant( 6, vParms.Base() );
+
+				if ( bHasStripesNormal2 )
+				{
+					params[ STRIPE_FADE_NORMAL2 ]->GetVecValue( &vParms.x, 3 );
+					staticCmdsBuf.SetPixelShaderConstant( 7, vParms.Base() );
+				}
+			}
+
+			switch( nEffect )
+			{
+				case 0:
+					{
+						params[ CANVAS_SCALE ]->GetVecValue( &vParms.x, 3 );
+						staticCmdsBuf.SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, vParms.Base() );
+
+						staticCmdsBuf.BindTexture( this, SHADER_SAMPLER2, CANVAS, -1 );
+
+						params[ BASE_STEP_RANGE ]->GetVecValue( &vParms.x, 2 );
+						params[ LIGHTMAP_STEP_RANGE ]->GetVecValue( &vParms.z, 2 );
+						staticCmdsBuf.SetPixelShaderConstant( 0, vParms.Base() );
+
+						params[ CANVAS_STEP_RANGE ]->GetVecValue( &vParms.x, 2 );
+						staticCmdsBuf.SetPixelShaderConstant( 2, vParms.Base() );
+
+						params[ CANVAS_COLOR_START ]->GetVecValue( &vParms.x, 3 );
+						staticCmdsBuf.SetPixelShaderConstant( 3, vParms.Base() );
+
+						params[ CANVAS_COLOR_END ]->GetVecValue( &vParms.x, 3 );
+						staticCmdsBuf.SetPixelShaderConstant( 4, vParms.Base() );
+					}
+					break;
+
+				case 1:
+					{
+						if ( bHasColorbar )
+						{
+							staticCmdsBuf.BindTexture( this, SHADER_SAMPLER2, COLORBAR, -1 );
+						}
+
+						vParms.x = params[ GRAY_POWER ]->GetFloatValue();
+						params[ GRAY_STEP ]->GetVecValue( &vParms.y, 2 );
+						vParms.w = params[ LIGHTMAP_GRADIENTS ]->GetFloatValue();
+						staticCmdsBuf.SetPixelShaderConstant( 0, vParms.Base() );
+
+						vParms[ 0 ] = params[ DIFFUSE_BASE ]->GetFloatValue();
+						params[ SELFILLUMTINT ]->GetVecValue( &vParms[ 1 ], 3 );
+						staticCmdsBuf.SetPixelShaderConstant( 2, vParms.Base() );
+					}
+					break;
+
+				case 2:
+					{
+						staticCmdsBuf.BindTexture( this, SHADER_SAMPLER4, BASETEXTURE2, -1 );
+
+						vParms.x = params[ DOF_START_DISTANCE ]->GetFloatValue();
+						vParms.y = params[ DOF_POWER ]->GetFloatValue();
+						vParms.z = params[ DOF_MAX ]->GetFloatValue();
+						vParms.w = 0.0f;
+						staticCmdsBuf.SetPixelShaderConstant( 0, vParms.Base() );
+					}
+					break;
+
+				case 3:
+					{
+						staticCmdsBuf.BindTexture( this, SHADER_SAMPLER3, NOISETEXTURE, -1 );
+						staticCmdsBuf.BindTexture( this, SHADER_SAMPLER4, WARPTEXTURE, -1 );
+						staticCmdsBuf.BindTexture( this, SHADER_SAMPLER5, VIGNETTE_TEXTURE, -1 );
+						staticCmdsBuf.BindTexture( this, SHADER_SAMPLER6, VIGNETTE_TILE, -1 );
+
+						vParms.x = params[ NOISE_SCALE ]->GetFloatValue();
+						vParms.y = params[ TIME_SCALE ]->GetFloatValue();
+						vParms.z = params[ HEAT_HAZE_SCALE ]->GetFloatValue();
+						vParms.w = 0.0f;
+						staticCmdsBuf.SetPixelShaderConstant( 0, vParms.Base() );
+					}
+					break;
+			}
+
+			staticCmdsBuf.StoreEyePosInPixelShaderConstant( 10 );
+			staticCmdsBuf.SetPixelShaderFogParams( 11 );
+			staticCmdsBuf.End();
+
+			// now, copy buf
+			pContextData->m_pStaticCmds = new uint8[ staticCmdsBuf.Size() ];
+			memcpy( pContextData->m_pStaticCmds, staticCmdsBuf.Base(), staticCmdsBuf.Size() );
+		}
+
+		if ( pShaderAPI && pContextData->m_bMaterialVarsChanged )
+		{
+			// need to regenerate the semistatic cmds
+			pContextData->m_SemiStaticCmdsOut.Reset();
+			pContextData->m_bMaterialVarsChanged = false;
+
+			if ( bHasBlendModulateTexture )
+			{
+				pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, BLENDMASKTRANSFORM );
+			}
+
+			Vector4D vParms;
+
+//			vParms.x = pShaderAPI->LinearToGamma_HardwareSpecific( 1.0f );
+
+			switch( nEffect )
+			{
+				case 0:
+					{
+						// set up shader modulation color
+						vParms[ 0 ] = vParms[ 1 ] = vParms[ 2] = vParms[ 3 ] = 1.0f;
+						ComputeModulationColor( vParms.Base() );
+						float flLScale = pShaderAPI->GetLightMapScaleFactor();
+						vParms[ 0 ] *= flLScale;
+						vParms[ 1 ] *= flLScale;
+						vParms[ 2 ] *= flLScale;
+						pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 1, vParms.Base() );
+					}
+					break;
+
+				case 1:
+					{
+						// set up shader modulation color
+						vParms[ 0 ] = vParms[ 1 ] = vParms[ 2] = vParms[ 3 ] = 1.0f;
+						ComputeModulationColor( vParms.Base() );
+						float flLScale = pShaderAPI->GetLightMapScaleFactor();
+						vParms[ 0 ] *= flLScale;
+						vParms[ 1 ] *= flLScale;
+						vParms[ 2 ] *= flLScale;
+						vParms[ 3 ] = params[ DIFFUSE_WHITE ]->GetFloatValue();
+						pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 1, vParms.Base() );
+					}
+					break;
+			}
+
+			pContextData->m_SemiStaticCmdsOut.SetAmbientCubeDynamicStateVertexShader();
+			pContextData->m_SemiStaticCmdsOut.End();
+		}
+
+		SHADOW_STATE
+		{
+			SetInitialShadowState( );
+
+			switch( nEffect )
+			{
+				case 0:
+				case 1:
+					{
+						pShaderShadow->EnableDepthWrites( true );
+						pShaderShadow->EnableDepthTest( true );
+
+						SetDefaultBlendingShadowState( BASETEXTURE );
+					}
+					break;
+
+				case 2:
+					{
+						pShaderShadow->EnableDepthWrites( false );
+						pShaderShadow->EnableDepthTest( false );
+
+						pShaderShadow->EnableBlending( true );
+						pShaderShadow->BlendFunc( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
+					}
+					break;
+
+				case 3:
+					{
+						pShaderShadow->EnableDepthWrites( false );
+						pShaderShadow->EnableDepthTest( false );
+
+						pShaderShadow->EnableBlending( false );
+					}
+					break;
+			}
+//			pShaderShadow->BlendOp( SHADER_BLEND_OP_REVSUBTRACT );
+//			EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE );
+
+			pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+			pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
+
+			pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
+			if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
+			{
+				pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );
+			}
+			else
+			{
+				pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false );
+			}
+
+			pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
+			pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
+
+			if ( nEffect == 0 || nEffect == 1 )
+			{
+				if ( bHasBlendModulateTexture )
+				{
+					pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+					pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, false );
+
+					pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
+					pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
+				}
+
+				if ( bHasStripes )
+				{
+					pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
+					pShaderShadow->EnableSRGBRead( SHADER_SAMPLER5, true );
+				}
+			}
+
+			if ( nEffect == 2 )
+			{
+				pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
+				pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
+			}
+
+			if ( nEffect == 3 )
+			{
+				pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+				pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, true );
+
+				pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
+				pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
+
+				pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
+				pShaderShadow->EnableSRGBRead( SHADER_SAMPLER5, false );
+
+				pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
+				pShaderShadow->EnableSRGBRead( SHADER_SAMPLER6, true );
+			}
+
+			pShaderShadow->EnableSRGBWrite( true );
+			pShaderShadow->EnableAlphaWrites( true );
+			pShaderShadow->EnableAlphaTest( bIsAlphaTested );
+
+			if ( params[ ALPHATESTREFERENCE ]->GetFloatValue() > 0.0f )
+			{
+				pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[ ALPHATESTREFERENCE ]->GetFloatValue() );
+			}
+
+			DefaultFog();
+
+			int nFormat = 0;
+			if ( bHasVertexColor )
+			{
+				nFormat |= VERTEX_COLOR;
+			}
+
+			if ( bVertexLit )
+			{
+				nFormat |= VERTEX_POSITION | VERTEX_NORMAL | VERTEX_FORMAT_COMPRESSED;
+				pShaderShadow->VertexShaderVertexFormat( nFormat, 1, 0, 0 );
+			}
+			else
+			{
+				nFormat |= VERTEX_POSITION;
+				pShaderShadow->VertexShaderVertexFormat( nFormat, 2, 0, 0 );
+			}
+
+			bool bHalfLambert = IS_FLAG_SET( MATERIAL_VAR_HALFLAMBERT );
+
+			if ( !g_pHardwareConfig->HasFastVertexTextures() )
+			{
+				DECLARE_STATIC_VERTEX_SHADER( pyro_vision_vs20 );
+				SET_STATIC_VERTEX_SHADER_COMBO( EFFECT, params[ EFFECT ]->GetIntValue() );
+				SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) );
+				SET_STATIC_VERTEX_SHADER_COMBO( VERTEX_LIT, bVertexLit );
+				SET_STATIC_VERTEX_SHADER_COMBO( FULLBRIGHT, bFullBright );
+				SET_STATIC_VERTEX_SHADER_COMBO( HALFLAMBERT,  bHalfLambert );
+				SET_STATIC_VERTEX_SHADER_COMBO( BASETEXTURE2, bHasBaseTexture2 );
+				SET_STATIC_VERTEX_SHADER_COMBO( STRIPES, bHasStripes );
+				SET_STATIC_VERTEX_SHADER_COMBO( STRIPES_USE_NORMAL2, bHasStripesNormal2 );
+				SET_STATIC_VERTEX_SHADER_COMBO( USE_STATIC_CONTROL_FLOW, bUseStaticControlFlow );
+				SET_STATIC_VERTEX_SHADER( pyro_vision_vs20 );
+
+				if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
+				{
+					DECLARE_STATIC_PIXEL_SHADER( pyro_vision_ps20b );
+					SET_STATIC_PIXEL_SHADER_COMBO( EFFECT, params[ EFFECT ]->GetIntValue() );
+					SET_STATIC_PIXEL_SHADER_COMBO( VERTEX_LIT, bVertexLit );
+					SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, bHasBaseTexture2 );
+					SET_STATIC_PIXEL_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture );
+					SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bSelfIllum );
+					SET_STATIC_PIXEL_SHADER_COMBO( COLOR_BAR, bHasColorbar );
+					SET_STATIC_PIXEL_SHADER_COMBO( STRIPES, bHasStripes );
+					SET_STATIC_PIXEL_SHADER_COMBO( STRIPES_USE_NORMAL2, bHasStripesNormal2 );
+					SET_STATIC_PIXEL_SHADER( pyro_vision_ps20b );
+				}
+				else
+				{
+					DECLARE_STATIC_PIXEL_SHADER( pyro_vision_ps20 );
+					SET_STATIC_PIXEL_SHADER_COMBO( EFFECT, params[ EFFECT ]->GetIntValue() );
+					SET_STATIC_PIXEL_SHADER_COMBO( VERTEX_LIT, bVertexLit );
+					SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, bHasBaseTexture2 );
+					SET_STATIC_PIXEL_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture );
+					SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bSelfIllum );
+					SET_STATIC_PIXEL_SHADER_COMBO( COLOR_BAR, bHasColorbar );
+					SET_STATIC_PIXEL_SHADER_COMBO( STRIPES, bHasStripes );
+					SET_STATIC_PIXEL_SHADER_COMBO( STRIPES_USE_NORMAL2, bHasStripesNormal2 );
+					SET_STATIC_PIXEL_SHADER( pyro_vision_ps20 );
+				}
+			}
+			else
+			{
+				DECLARE_STATIC_VERTEX_SHADER( pyro_vision_vs30 );
+				SET_STATIC_VERTEX_SHADER_COMBO( EFFECT, params[ EFFECT ]->GetIntValue() );
+				SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) );
+				SET_STATIC_VERTEX_SHADER_COMBO( VERTEX_LIT, bVertexLit );
+				SET_STATIC_VERTEX_SHADER_COMBO( FULLBRIGHT, bFullBright );
+				SET_STATIC_VERTEX_SHADER_COMBO( HALFLAMBERT,  bHalfLambert );
+				SET_STATIC_VERTEX_SHADER_COMBO( BASETEXTURE2, bHasBaseTexture2 );
+				SET_STATIC_VERTEX_SHADER_COMBO( STRIPES, bHasStripes );
+				SET_STATIC_VERTEX_SHADER_COMBO( STRIPES_USE_NORMAL2, bHasStripesNormal2 );
+				SET_STATIC_VERTEX_SHADER( pyro_vision_vs30 );
+
+				DECLARE_STATIC_PIXEL_SHADER( pyro_vision_ps30 );
+				SET_STATIC_PIXEL_SHADER_COMBO( EFFECT, params[ EFFECT ]->GetIntValue() );
+				SET_STATIC_PIXEL_SHADER_COMBO( VERTEX_LIT, bVertexLit );
+				SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, bHasBaseTexture2 );
+				SET_STATIC_PIXEL_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture );
+				SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bSelfIllum );
+				SET_STATIC_PIXEL_SHADER_COMBO( COLOR_BAR, bHasColorbar );
+				SET_STATIC_PIXEL_SHADER_COMBO( STRIPES, bHasStripes );
+				SET_STATIC_PIXEL_SHADER_COMBO( STRIPES_USE_NORMAL2, bHasStripesNormal2 );
+				SET_STATIC_PIXEL_SHADER( pyro_vision_ps30 );
+			}
+		}
+
+		DYNAMIC_STATE
+		{
+			CCommandBufferBuilder< CFixedCommandStorageBuffer< 1000 > > DynamicCmdsOut;
+			DynamicCmdsOut.Call( pContextData->m_pStaticCmds );
+			DynamicCmdsOut.Call( pContextData->m_SemiStaticCmdsOut.Base() );
+
+			pShaderAPI->SetDefaultState();
+
+			bool bWriteDepthToAlpha;
+			if( bFullyOpaque ) 
+			{
+				bWriteDepthToAlpha = pShaderAPI->ShouldWriteDepthToDestAlpha();
+			}
+			else
+			{
+				//can't write a special value to dest alpha if we're actually using as-intended alpha
+				bWriteDepthToAlpha = false;
+			}
+
+			Vector4D vParms;
+
+			vParms.x = bWriteDepthToAlpha ? 1.0f : 0.0f;
+			vParms.y = pShaderAPI->CurrentTime();
+			vParms.z = 0.0f;
+			vParms.w = 0.0f;
+
+			DynamicCmdsOut.SetPixelShaderConstant( 12, vParms.Base() );
+
+			int numBones = pShaderAPI->GetCurrentNumBones();
+			LightState_t lightState = { 0, false, false };
+			if ( bVertexLit && !bFullBright )
+			{
+				pShaderAPI->GetDX9LightState( &lightState );
+			}
+
+			if ( !g_pHardwareConfig->HasFastVertexTextures() )
+			{
+				DECLARE_DYNAMIC_VERTEX_SHADER( pyro_vision_vs20 );
+				SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING,  numBones > 0 );
+				SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
+				SET_DYNAMIC_VERTEX_SHADER_COMBO( DYNAMIC_LIGHT, lightState.HasDynamicLight() );
+				SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT,  lightState.m_bStaticLightVertex ? 1 : 0 );
+				SET_DYNAMIC_VERTEX_SHADER_COMBO( NUM_LIGHTS, bUseStaticControlFlow ? 0 : lightState.m_nNumLights );
+				SET_DYNAMIC_VERTEX_SHADER( pyro_vision_vs20 );
+
+				if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
+				{
+					DECLARE_DYNAMIC_PIXEL_SHADER( pyro_vision_ps20b );
+					SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
+					SET_DYNAMIC_PIXEL_SHADER_COMBO( VISUALIZE_DOF, bVisualizeDoF );
+					SET_DYNAMIC_PIXEL_SHADER_COMBO( HEATHAZE, bHasHeatHaze );
+					SET_DYNAMIC_PIXEL_SHADER( pyro_vision_ps20b );
+				}
+				else
+				{
+					DECLARE_DYNAMIC_PIXEL_SHADER( pyro_vision_ps20 );
+					SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
+					SET_DYNAMIC_PIXEL_SHADER_COMBO( VISUALIZE_DOF, bVisualizeDoF );
+					SET_DYNAMIC_PIXEL_SHADER_COMBO( HEATHAZE, bHasHeatHaze );
+					SET_DYNAMIC_PIXEL_SHADER( pyro_vision_ps20 );
+				}
+			}
+			else
+			{
+				DECLARE_DYNAMIC_VERTEX_SHADER( pyro_vision_vs30 );
+				SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING,  numBones > 0 );
+				SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
+				SET_DYNAMIC_VERTEX_SHADER_COMBO( DYNAMIC_LIGHT, lightState.HasDynamicLight() );
+				SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT,  lightState.m_bStaticLightVertex ? 1 : 0 );
+				SET_DYNAMIC_VERTEX_SHADER( pyro_vision_vs30 );
+
+				DECLARE_DYNAMIC_PIXEL_SHADER( pyro_vision_ps30 );
+				SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
+				SET_DYNAMIC_PIXEL_SHADER_COMBO( VISUALIZE_DOF, bVisualizeDoF );
+				SET_DYNAMIC_PIXEL_SHADER_COMBO( HEATHAZE, bHasHeatHaze );
+				SET_DYNAMIC_PIXEL_SHADER( pyro_vision_ps30 );
+			}
+
+
+			DynamicCmdsOut.End();
+			pShaderAPI->ExecuteCommandBuffer( DynamicCmdsOut.Base() );
+		}
+		Draw();
+	}
+END_SHADER