Fix line endings. WHAMMY.

1 files changed, 2234 insertions, 2234 deletions

diff --git a/mp/src/materialsystem/stdshaders/BaseVSShader.cpp b/mp/src/materialsystem/stdshaders/BaseVSShader.cpp
index ba1f6e15..31c2e9b2 100644
--- a/mp/src/materialsystem/stdshaders/BaseVSShader.cpp
+++ b/mp/src/materialsystem/stdshaders/BaseVSShader.cpp
@@ -1,2234 +1,2234 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: 

-//

-// $NoKeywords: $

-// This is what all vs/ps (dx8+) shaders inherit from.

-//===========================================================================//

-#if !defined(_STATIC_LINKED) || defined(STDSHADER_DX8_DLL_EXPORT) || defined(STDSHADER_DX9_DLL_EXPORT)

-

-#include "BaseVSShader.h"

-#include "mathlib/vmatrix.h"

-#include "mathlib/bumpvects.h"

-#include "cpp_shader_constant_register_map.h"

-#include "convar.h"

-

-#ifndef GAME_SHADER_DLL

-#ifdef HDR

-#include "vertexlit_and_unlit_generic_hdr_ps20.inc"

-#include "vertexlit_and_unlit_generic_hdr_ps20b.inc"

-#endif

-

-#if SUPPORT_DX8

-#include "lightmappedgeneric_flashlight_vs11.inc"

-#include "flashlight_ps11.inc"

-#endif

-

-#ifdef STDSHADER_DX9_DLL_EXPORT

-#include "lightmappedgeneric_flashlight_vs20.inc"

-#endif

-#ifdef STDSHADER_DX9_DLL_EXPORT

-#include "flashlight_ps20.inc"

-#include "flashlight_ps20b.inc"

-#endif

-#include "unlitgeneric_vs11.inc"

-#include "VertexLitGeneric_EnvmappedBumpmap_NoLighting_ps14.inc"

-#include "VertexLitGeneric_EnvmappedBumpmap_NoLighting.inc"

-#include "vertexlitgeneric_flashlight_vs11.inc"

-#include "LightmappedGeneric_BaseTexture.inc"

-#include "LightmappedGeneric_BumpmappedLightmap_Base_ps14.inc"

-#include "LightmappedGeneric_BumpmappedLightmap_Blend_ps14.inc"

-#include "lightmappedgeneric_bumpmappedenvmap_ps14.inc"

-#include "lightmappedgeneric_bumpmappedenvmap.inc"

-#include "lightmappedgeneric_basetextureblend.inc"

-#include "lightmappedgeneric_bumpmappedlightmap.inc"

-#endif // GAME_SHADER_DLL

-

-// memdbgon must be the last include file in a .cpp file!!!

-#include "tier0/memdbgon.h"

-

-static ConVar mat_fullbright( "mat_fullbright","0", FCVAR_CHEAT );

-

-// These functions are to be called from the shaders.

-

-//-----------------------------------------------------------------------------

-// Pixel and vertex shader constants....

-//-----------------------------------------------------------------------------

-void CBaseVSShader::SetPixelShaderConstant( int pixelReg, int constantVar, int constantVar2 )

-{

-	Assert( !IsSnapshotting() );

-	if ((!s_ppParams) || (constantVar == -1) || (constantVar2 == -1))

-		return;

-

-	IMaterialVar* pPixelVar = s_ppParams[constantVar];

-	Assert( pPixelVar );

-	IMaterialVar* pPixelVar2 = s_ppParams[constantVar2];

-	Assert( pPixelVar2 );

-

-	float val[4];

-	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-	{

-		pPixelVar->GetVecValue( val, 3 );

-	}

-	else

-	{

-		val[0] = val[1] = val[2] = pPixelVar->GetFloatValue();

-	}

-

-	val[3] = pPixelVar2->GetFloatValue();

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	

-}

-

-void CBaseVSShader::SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar, int constantVar2 )

-{

-	Assert( !IsSnapshotting() );

-	if ((!s_ppParams) || (constantVar == -1) || (constantVar2 == -1))

-		return;

-

-	IMaterialVar* pPixelVar = s_ppParams[constantVar];

-	Assert( pPixelVar );

-	IMaterialVar* pPixelVar2 = s_ppParams[constantVar2];

-	Assert( pPixelVar2 );

-

-	float val[4];

-	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-	{

-		pPixelVar->GetVecValue( val, 3 );

-	}

-	else

-	{

-		val[0] = val[1] = val[2] = pPixelVar->GetFloatValue();

-	}

-

-	val[3] = pPixelVar2->GetFloatValue();

-	val[0] = val[0] > 1.0f ? val[0] : GammaToLinear( val[0] );

-	val[1] = val[1] > 1.0f ? val[1] : GammaToLinear( val[1] );

-	val[2] = val[2] > 1.0f ? val[2] : GammaToLinear( val[2] );

-

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	

-}

-

-void CBaseVSShader::SetPixelShaderConstant_W( int pixelReg, int constantVar, float fWValue )

-{

-	Assert( !IsSnapshotting() );

-	if ((!s_ppParams) || (constantVar == -1))

-		return;

-

-	IMaterialVar* pPixelVar = s_ppParams[constantVar];

-	Assert( pPixelVar );

-

-	float val[4];

-	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-		pPixelVar->GetVecValue( val, 4 );

-	else

-		val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue();

-	val[3]=fWValue;

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	

-}

-

-void CBaseVSShader::SetPixelShaderConstant( int pixelReg, int constantVar )

-{

-	Assert( !IsSnapshotting() );

-	if ((!s_ppParams) || (constantVar == -1))

-		return;

-

-	IMaterialVar* pPixelVar = s_ppParams[constantVar];

-	Assert( pPixelVar );

-

-	float val[4];

-	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-		pPixelVar->GetVecValue( val, 4 );

-	else

-		val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue();

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	

-}

-

-void CBaseVSShader::SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar )

-{

-	Assert( !IsSnapshotting() );

-	if ((!s_ppParams) || (constantVar == -1))

-		return;

-

-	IMaterialVar* pPixelVar = s_ppParams[constantVar];

-	Assert( pPixelVar );

-

-	float val[4];

-	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-		pPixelVar->GetVecValue( val, 4 );

-	else

-		val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue();

-

-	val[0] = val[0] > 1.0f ? val[0] : GammaToLinear( val[0] );

-	val[1] = val[1] > 1.0f ? val[1] : GammaToLinear( val[1] );

-	val[2] = val[2] > 1.0f ? val[2] : GammaToLinear( val[2] );

-

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	

-}

-

-void CBaseVSShader::SetVertexShaderConstantGammaToLinear( int var, float const* pVec, int numConst, bool bForce )

-{

-	int i;

-	for( i = 0; i < numConst; i++ )

-	{

-		float vec[4];

-		vec[0] = pVec[i*4+0] > 1.0f ? pVec[i*4+0] : GammaToLinear( pVec[i*4+0] );

-		vec[1] = pVec[i*4+1] > 1.0f ? pVec[i*4+1] : GammaToLinear( pVec[i*4+1] );

-		vec[2] = pVec[i*4+2] > 1.0f ? pVec[i*4+2] : GammaToLinear( pVec[i*4+2] );

-		vec[3] = pVec[i*4+3];

-

-		s_pShaderAPI->SetVertexShaderConstant( var + i, vec, 1, bForce );

-	}

-}

-

-void CBaseVSShader::SetPixelShaderConstantGammaToLinear( int var, float const* pVec, int numConst, bool bForce )

-{

-	int i;

-	for( i = 0; i < numConst; i++ )

-	{

-		float vec[4];

-		vec[0] = pVec[i*4+0] > 1.0f ? pVec[i*4+0] : GammaToLinear( pVec[i*4+0] );

-		vec[1] = pVec[i*4+1] > 1.0f ? pVec[i*4+1] : GammaToLinear( pVec[i*4+1] );

-		vec[2] = pVec[i*4+2] > 1.0f ? pVec[i*4+2] : GammaToLinear( pVec[i*4+2] );

-

-		vec[3] = pVec[i*4+3];

-

-		s_pShaderAPI->SetPixelShaderConstant( var + i, vec, 1, bForce );

-	}

-}

-

-// GR - special version with fix for const/lerp issue

-void CBaseVSShader::SetPixelShaderConstantFudge( int pixelReg, int constantVar )

-{

-	Assert( !IsSnapshotting() );

-	if ((!s_ppParams) || (constantVar == -1))

-		return;

-

-	IMaterialVar* pPixelVar = s_ppParams[constantVar];

-	Assert( pPixelVar );

-

-	float val[4];

-	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-	{

-		pPixelVar->GetVecValue( val, 4 );

-		val[0] = val[0] * 0.992f + 0.0078f;

-		val[1] = val[1] * 0.992f + 0.0078f;

-		val[2] = val[2] * 0.992f + 0.0078f;

-		val[3] = val[3] * 0.992f + 0.0078f;

-	}

-	else

-		val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue() * 0.992f + 0.0078f;

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	

-}

-

-void CBaseVSShader::SetVertexShaderConstant( int vertexReg, int constantVar )

-{

-	Assert( !IsSnapshotting() );

-	if ((!s_ppParams) || (constantVar == -1))

-		return;

-

-	IMaterialVar* pVertexVar = s_ppParams[constantVar];

-	Assert( pVertexVar );

-

-	float val[4];

-	if (pVertexVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-		pVertexVar->GetVecValue( val, 4 );

-	else

-		val[0] = val[1] = val[2] = val[3] = pVertexVar->GetFloatValue();

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, val );	

-}

-

-//-----------------------------------------------------------------------------

-// Sets normalized light color for pixel shaders.

-//-----------------------------------------------------------------------------

-void CBaseVSShader::SetPixelShaderLightColors( int pixelReg )

-{

-	int i;

-	int maxLights = s_pShaderAPI->GetMaxLights();

-	for( i = 0; i < maxLights; i++ )

-	{

-		const LightDesc_t & lightDesc = s_pShaderAPI->GetLight( i );

-		if( lightDesc.m_Type != MATERIAL_LIGHT_DISABLE )

-		{

-			Vector color( lightDesc.m_Color[0], lightDesc.m_Color[1], lightDesc.m_Color[2] );

-			VectorNormalize( color );

-			float val[4] = { color[0], color[1], color[2], 1.0f };

-			s_pShaderAPI->SetPixelShaderConstant( pixelReg + i, val, 1 );

-		}

-		else

-		{

-			float zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };

-			s_pShaderAPI->SetPixelShaderConstant( pixelReg + i, zero, 1 );

-		}

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Sets vertex shader texture transforms

-//-----------------------------------------------------------------------------

-void CBaseVSShader::SetVertexShaderTextureTranslation( int vertexReg, int translationVar )

-{

-	float offset[2] = {0, 0};

-

-	IMaterialVar* pTranslationVar = s_ppParams[translationVar];

-	if (pTranslationVar)

-	{

-		if (pTranslationVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-			pTranslationVar->GetVecValue( offset, 2 );

-		else

-			offset[0] = offset[1] = pTranslationVar->GetFloatValue();

-	}

-

-	Vector4D translation[2];

-	translation[0].Init( 1.0f, 0.0f, 0.0f, offset[0] );

-	translation[1].Init( 0.0f, 1.0f, 0.0f, offset[1] );

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, translation[0].Base(), 2 ); 

-}

-

-void CBaseVSShader::SetVertexShaderTextureScale( int vertexReg, int scaleVar )

-{

-	float scale[2] = {1, 1};

-

-	IMaterialVar* pScaleVar = s_ppParams[scaleVar];

-	if (pScaleVar)

-	{

-		if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-			pScaleVar->GetVecValue( scale, 2 );

-		else if (pScaleVar->IsDefined())

-			scale[0] = scale[1] = pScaleVar->GetFloatValue();

-	}

-

-	Vector4D scaleMatrix[2];

-	scaleMatrix[0].Init( scale[0], 0.0f, 0.0f, 0.0f );

-	scaleMatrix[1].Init( 0.0f, scale[1], 0.0f, 0.0f );

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, scaleMatrix[0].Base(), 2 ); 

-}

-

-void CBaseVSShader::SetVertexShaderTextureTransform( int vertexReg, int transformVar )

-{

-	Vector4D transformation[2];

-	IMaterialVar* pTransformationVar = s_ppParams[transformVar];

-	if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))

-	{

-		const VMatrix &mat = pTransformationVar->GetMatrixValue();

-		transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] );

-		transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] );

-	}

-	else

-	{

-		transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f );

-		transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f );

-	}

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, transformation[0].Base(), 2 ); 

-}

-

-void CBaseVSShader::SetVertexShaderTextureScaledTransform( int vertexReg, int transformVar, int scaleVar )

-{

-	Vector4D transformation[2];

-	IMaterialVar* pTransformationVar = s_ppParams[transformVar];

-	if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))

-	{

-		const VMatrix &mat = pTransformationVar->GetMatrixValue();

-		transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] );

-		transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] );

-	}

-	else

-	{

-		transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f );

-		transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f );

-	}

-

-	Vector2D scale( 1, 1 );

-	IMaterialVar* pScaleVar = s_ppParams[scaleVar];

-	if (pScaleVar)

-	{

-		if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-			pScaleVar->GetVecValue( scale.Base(), 2 );

-		else if (pScaleVar->IsDefined())

-			scale[0] = scale[1] = pScaleVar->GetFloatValue();

-	}

-

-	// Apply the scaling

-	transformation[0][0] *= scale[0];

-	transformation[0][1] *= scale[1];

-	transformation[1][0] *= scale[0];

-	transformation[1][1] *= scale[1];

-	transformation[0][3] *= scale[0];

-	transformation[1][3] *= scale[1];

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, transformation[0].Base(), 2 ); 

-}

-

-

-//-----------------------------------------------------------------------------

-// Sets pixel shader texture transforms

-//-----------------------------------------------------------------------------

-void CBaseVSShader::SetPixelShaderTextureTranslation( int pixelReg, int translationVar )

-{

-	float offset[2] = {0, 0};

-

-	IMaterialVar* pTranslationVar = s_ppParams[translationVar];

-	if (pTranslationVar)

-	{

-		if (pTranslationVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-			pTranslationVar->GetVecValue( offset, 2 );

-		else

-			offset[0] = offset[1] = pTranslationVar->GetFloatValue();

-	}

-

-	Vector4D translation[2];

-	translation[0].Init( 1.0f, 0.0f, 0.0f, offset[0] );

-	translation[1].Init( 0.0f, 1.0f, 0.0f, offset[1] );

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, translation[0].Base(), 2 ); 

-}

-

-void CBaseVSShader::SetPixelShaderTextureScale( int pixelReg, int scaleVar )

-{

-	float scale[2] = {1, 1};

-

-	IMaterialVar* pScaleVar = s_ppParams[scaleVar];

-	if (pScaleVar)

-	{

-		if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-			pScaleVar->GetVecValue( scale, 2 );

-		else if (pScaleVar->IsDefined())

-			scale[0] = scale[1] = pScaleVar->GetFloatValue();

-	}

-

-	Vector4D scaleMatrix[2];

-	scaleMatrix[0].Init( scale[0], 0.0f, 0.0f, 0.0f );

-	scaleMatrix[1].Init( 0.0f, scale[1], 0.0f, 0.0f );

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, scaleMatrix[0].Base(), 2 ); 

-}

-

-void CBaseVSShader::SetPixelShaderTextureTransform( int pixelReg, int transformVar )

-{

-	Vector4D transformation[2];

-	IMaterialVar* pTransformationVar = s_ppParams[transformVar];

-	if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))

-	{

-		const VMatrix &mat = pTransformationVar->GetMatrixValue();

-		transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] );

-		transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] );

-	}

-	else

-	{

-		transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f );

-		transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f );

-	}

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, transformation[0].Base(), 2 ); 

-}

-

-void CBaseVSShader::SetPixelShaderTextureScaledTransform( int pixelReg, int transformVar, int scaleVar )

-{

-	Vector4D transformation[2];

-	IMaterialVar* pTransformationVar = s_ppParams[transformVar];

-	if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))

-	{

-		const VMatrix &mat = pTransformationVar->GetMatrixValue();

-		transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] );

-		transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] );

-	}

-	else

-	{

-		transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f );

-		transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f );

-	}

-

-	Vector2D scale( 1, 1 );

-	IMaterialVar* pScaleVar = s_ppParams[scaleVar];

-	if (pScaleVar)

-	{

-		if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)

-			pScaleVar->GetVecValue( scale.Base(), 2 );

-		else if (pScaleVar->IsDefined())

-			scale[0] = scale[1] = pScaleVar->GetFloatValue();

-	}

-

-	// Apply the scaling

-	transformation[0][0] *= scale[0];

-	transformation[0][1] *= scale[1];

-	transformation[1][0] *= scale[0];

-	transformation[1][1] *= scale[1];

-	transformation[0][3] *= scale[0];

-	transformation[1][3] *= scale[1];

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, transformation[0].Base(), 2 ); 

-}

-

-

-//-----------------------------------------------------------------------------

-// Moves a matrix into vertex shader constants 

-//-----------------------------------------------------------------------------

-void CBaseVSShader::SetVertexShaderMatrix3x4( int vertexReg, int matrixVar )

-{

-	IMaterialVar* pTranslationVar = s_ppParams[matrixVar];

-	if (pTranslationVar)

-	{

-		s_pShaderAPI->SetVertexShaderConstant( vertexReg, &pTranslationVar->GetMatrixValue( )[0][0], 3 ); 

-	}

-	else

-	{

-		VMatrix matrix;

-		MatrixSetIdentity( matrix );

-		s_pShaderAPI->SetVertexShaderConstant( vertexReg, &matrix[0][0], 3 ); 

-	}

-}

-

-void CBaseVSShader::SetVertexShaderMatrix4x4( int vertexReg, int matrixVar )

-{

-	IMaterialVar* pTranslationVar = s_ppParams[matrixVar];

-	if (pTranslationVar)

-	{

-		s_pShaderAPI->SetVertexShaderConstant( vertexReg, &pTranslationVar->GetMatrixValue( )[0][0], 4 ); 

-	}

-	else

-	{

-		VMatrix matrix;

-		MatrixSetIdentity( matrix );

-		s_pShaderAPI->SetVertexShaderConstant( vertexReg, &matrix[0][0], 4 ); 

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Loads the view matrix into pixel shader constants

-//-----------------------------------------------------------------------------

-void CBaseVSShader::LoadViewMatrixIntoVertexShaderConstant( int vertexReg )

-{

-	VMatrix mat, transpose;

-	s_pShaderAPI->GetMatrix( MATERIAL_VIEW, mat.m[0] );

-

-	MatrixTranspose( mat, transpose );

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, transpose.m[0], 3 );

-}

-

-

-//-----------------------------------------------------------------------------

-// Loads the projection matrix into pixel shader constants

-//-----------------------------------------------------------------------------

-void CBaseVSShader::LoadProjectionMatrixIntoVertexShaderConstant( int vertexReg )

-{

-	VMatrix mat, transpose;

-	s_pShaderAPI->GetMatrix( MATERIAL_PROJECTION, mat.m[0] );

-

-	MatrixTranspose( mat, transpose );

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, transpose.m[0], 4 );

-}

-

-

-//-----------------------------------------------------------------------------

-// Loads the projection matrix into pixel shader constants

-//-----------------------------------------------------------------------------

-void CBaseVSShader::LoadModelViewMatrixIntoVertexShaderConstant( int vertexReg )

-{

-	VMatrix view, model, modelView, transpose;

-	s_pShaderAPI->GetMatrix( MATERIAL_MODEL, model.m[0] );

-	MatrixTranspose( model, model );

-	s_pShaderAPI->GetMatrix( MATERIAL_VIEW, view.m[0] );

-	MatrixTranspose( view, view );

-

-	MatrixMultiply( view, model, modelView );

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, modelView.m[0], 3 );

-}

-

-//-----------------------------------------------------------------------------

-// Loads a scale/offset version of the viewport transform into the specified constant.

-//-----------------------------------------------------------------------------

-void CBaseVSShader::LoadViewportTransformScaledIntoVertexShaderConstant( int vertexReg )

-{

-	ShaderViewport_t viewport;

-

-	s_pShaderAPI->GetViewports( &viewport, 1 );

-

-	int bbWidth = 0, 

-		bbHeight = 0;

-

-	s_pShaderAPI->GetBackBufferDimensions( bbWidth, bbHeight );

-

-	// (x, y, z, w) = (Width / bbWidth, Height / bbHeight, MinX / bbWidth, MinY / bbHeight)

-	Vector4D viewportTransform( 

-		1.0f * viewport.m_nWidth / bbWidth,

-		1.0f * viewport.m_nHeight / bbHeight,

-		1.0f * viewport.m_nTopLeftX / bbWidth, 

-		1.0f * viewport.m_nTopLeftY / bbHeight

-	);

-

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, viewportTransform.Base() );

-}

-

-

-

-//-----------------------------------------------------------------------------

-// Loads bump lightmap coordinates into the pixel shader

-//-----------------------------------------------------------------------------

-void CBaseVSShader::LoadBumpLightmapCoordinateAxes_PixelShader( int pixelReg )

-{

-	Vector4D basis[3];

-	for (int i = 0; i < 3; ++i)

-	{

-		memcpy( &basis[i], &g_localBumpBasis[i], 3 * sizeof(float) );

-		basis[i][3] = 0.0f;

-	}

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, (float*)basis, 3 );

-}

-

-

-//-----------------------------------------------------------------------------

-// Loads bump lightmap coordinates into the pixel shader

-//-----------------------------------------------------------------------------

-void CBaseVSShader::LoadBumpLightmapCoordinateAxes_VertexShader( int vertexReg )

-{

-	Vector4D basis[3];

-

-	// transpose

-	int i;

-	for (i = 0; i < 3; ++i)

-	{

-		basis[i][0] = g_localBumpBasis[0][i];

-		basis[i][1] = g_localBumpBasis[1][i];

-		basis[i][2] = g_localBumpBasis[2][i];

-		basis[i][3] = 0.0f;

-	}

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg, (float*)basis, 3 );

-	for (i = 0; i < 3; ++i)

-	{

-		memcpy( &basis[i], &g_localBumpBasis[i], 3 * sizeof(float) );

-		basis[i][3] = 0.0f;

-	}

-	s_pShaderAPI->SetVertexShaderConstant( vertexReg + 3, (float*)basis, 3 );

-}

-

-

-//-----------------------------------------------------------------------------

-// Helper methods for pixel shader overbrighting

-//-----------------------------------------------------------------------------

-void CBaseVSShader::EnablePixelShaderOverbright( int reg, bool bEnable, bool bDivideByTwo )

-{

-	// can't have other overbright values with pixel shaders as it stands.

-	float v[4];

-	if( bEnable )

-	{

-		v[0] = v[1] = v[2] = v[3] = bDivideByTwo ? OVERBRIGHT / 2.0f : OVERBRIGHT;

-	}

-	else

-	{

-		v[0] = v[1] = v[2] = v[3] = bDivideByTwo ? 1.0f / 2.0f : 1.0f;

-	}

-	s_pShaderAPI->SetPixelShaderConstant( reg, v, 1 );

-}

-

-

-//-----------------------------------------------------------------------------

-// Helper for dealing with modulation

-//-----------------------------------------------------------------------------

-void CBaseVSShader::SetModulationVertexShaderDynamicState()

-{

- 	float color[4] = { 1.0, 1.0, 1.0, 1.0 };

-	ComputeModulationColor( color );

-	s_pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_MODULATION_COLOR, color );

-}

-

-void CBaseVSShader::SetModulationPixelShaderDynamicState( int modulationVar )

-{

-	float color[4] = { 1.0, 1.0, 1.0, 1.0 };

-	ComputeModulationColor( color );

-	s_pShaderAPI->SetPixelShaderConstant( modulationVar, color );

-}

-

-void CBaseVSShader::SetModulationPixelShaderDynamicState_LinearColorSpace( int modulationVar )

-{

-	float color[4] = { 1.0, 1.0, 1.0, 1.0 };

-	ComputeModulationColor( color );

-	color[0] = color[0] > 1.0f ? color[0] : GammaToLinear( color[0] );

-	color[1] = color[1] > 1.0f ? color[1] : GammaToLinear( color[1] );

-	color[2] = color[2] > 1.0f ? color[2] : GammaToLinear( color[2] );

-

-	s_pShaderAPI->SetPixelShaderConstant( modulationVar, color );

-}

-

-void CBaseVSShader::SetModulationPixelShaderDynamicState_LinearColorSpace_LinearScale( int modulationVar, float flScale )

-{

-	float color[4] = { 1.0, 1.0, 1.0, 1.0 };

-	ComputeModulationColor( color );

-	color[0] = ( color[0] > 1.0f ? color[0] : GammaToLinear( color[0] ) ) * flScale;

-	color[1] = ( color[1] > 1.0f ? color[1] : GammaToLinear( color[1] ) ) * flScale;

-	color[2] = ( color[2] > 1.0f ? color[2] : GammaToLinear( color[2] ) ) * flScale;

-

-	s_pShaderAPI->SetPixelShaderConstant( modulationVar, color );

-}

-

-

-//-----------------------------------------------------------------------------

-// Converts a color + alpha into a vector4

-//-----------------------------------------------------------------------------

-void CBaseVSShader::ColorVarsToVector( int colorVar, int alphaVar, Vector4D &color )

-{

-	color.Init( 1.0, 1.0, 1.0, 1.0 ); 

-	if ( colorVar != -1 )

-	{

-		IMaterialVar* pColorVar = s_ppParams[colorVar];

-		if ( pColorVar->GetType() == MATERIAL_VAR_TYPE_VECTOR )

-		{

-			pColorVar->GetVecValue( color.Base(), 3 );

-		}

-		else

-		{

-			color[0] = color[1] = color[2] = pColorVar->GetFloatValue();

-		}

-	}

-	if ( alphaVar != -1 )

-	{

-		float flAlpha = s_ppParams[alphaVar]->GetFloatValue();

-		color[3] = clamp( flAlpha, 0.0f, 1.0f );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Sets a color + alpha into shader constants

-//-----------------------------------------------------------------------------

-void CBaseVSShader::SetColorVertexShaderConstant( int nVertexReg, int colorVar, int alphaVar )

-{

-	Vector4D color;

-	ColorVarsToVector( colorVar, alphaVar, color );

-	s_pShaderAPI->SetVertexShaderConstant( nVertexReg, color.Base() );

-}

-

-void CBaseVSShader::SetColorPixelShaderConstant( int nPixelReg, int colorVar, int alphaVar )

-{

-	Vector4D color;

-	ColorVarsToVector( colorVar, alphaVar, color );

-	s_pShaderAPI->SetPixelShaderConstant( nPixelReg, color.Base() );

-}

-

-#ifdef _DEBUG

-ConVar mat_envmaptintoverride( "mat_envmaptintoverride", "-1" );

-ConVar mat_envmaptintscale( "mat_envmaptintscale", "-1" );

-#endif

-

-//-----------------------------------------------------------------------------

-// Helpers for dealing with envmap tint

-//-----------------------------------------------------------------------------

-// set alphaVar to -1 to ignore it.

-void CBaseVSShader::SetEnvMapTintPixelShaderDynamicState( int pixelReg, int tintVar, int alphaVar, bool bConvertFromGammaToLinear )

-{

-	float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f };

-	if( g_pConfig->bShowSpecular && mat_fullbright.GetInt() != 2 )

-	{

-		IMaterialVar* pAlphaVar = NULL;

-		if( alphaVar >= 0 )

-		{

-			pAlphaVar = s_ppParams[alphaVar];

-		}

-		if( pAlphaVar )

-		{

-			color[3] = pAlphaVar->GetFloatValue();

-		}

-

-		IMaterialVar* pTintVar = s_ppParams[tintVar];

-#ifdef _DEBUG

-		pTintVar->GetVecValue( color, 3 );

-

-		float envmapTintOverride = mat_envmaptintoverride.GetFloat();

-		float envmapTintScaleOverride = mat_envmaptintscale.GetFloat();

-

-		if( envmapTintOverride != -1.0f )

-		{

-			color[0] = color[1] = color[2] = envmapTintOverride;

-		}

-		if( envmapTintScaleOverride != -1.0f )

-		{

-			color[0] *= envmapTintScaleOverride;

-			color[1] *= envmapTintScaleOverride;

-			color[2] *= envmapTintScaleOverride;

-		}

-

-		if( bConvertFromGammaToLinear )

-		{

-			color[0] = color[0] > 1.0f ? color[0] : GammaToLinear( color[0] );

-			color[1] = color[1] > 1.0f ? color[1] : GammaToLinear( color[1] );

-			color[2] = color[2] > 1.0f ? color[2] : GammaToLinear( color[2] );

-		}

-#else

-		if( bConvertFromGammaToLinear )

-		{

-			pTintVar->GetLinearVecValue( color, 3 );

-		}

-		else

-		{

-			pTintVar->GetVecValue( color, 3 );

-		}

-#endif

-	}

-	else

-	{

-		color[0] = color[1] = color[2] = color[3] = 0.0f;

-	}

-	s_pShaderAPI->SetPixelShaderConstant( pixelReg, color, 1 );

-}

-

-void CBaseVSShader::SetAmbientCubeDynamicStateVertexShader( )

-{

-	s_pShaderAPI->SetVertexShaderStateAmbientLightCube();

-}

-

-float CBaseVSShader::GetAmbientLightCubeLuminance( )

-{

-	return s_pShaderAPI->GetAmbientLightCubeLuminance();

-}

-

-#ifndef GAME_SHADER_DLL

-const char *CBaseVSShader::UnlitGeneric_ComputePixelShaderName( bool bMask,

-																bool bEnvmap,

-																bool bBaseTexture,

-																bool bBaseAlphaEnvmapMask,

-																bool bDetail,

-																bool bDetailMultiplyMode,

-																bool bMaskBaseByDetailAlpha )

-{

-	static char const* s_pPixelShaders[] = 

-	{

-		"UnlitGeneric_NoTexture",

-		"UnlitGeneric",

-		"UnlitGeneric_EnvMapNoTexture",

-		"UnlitGeneric_EnvMap",

-		"UnlitGeneric_NoTexture",

-		"UnlitGeneric",

-		"UnlitGeneric_EnvMapMaskNoTexture",

-		"UnlitGeneric_EnvMapMask",

-

-		// Detail texture

-		// The other commented-out versions are used if we want to

-		// apply the detail *after* the environment map is added

-		"UnlitGeneric_DetailNoTexture",

-		"UnlitGeneric_Detail",

-		"UnlitGeneric_EnvMapNoTexture", //"UnlitGeneric_DetailEnvMapNoTexture",

-		"UnlitGeneric_DetailEnvMap",

-		"UnlitGeneric_DetailNoTexture",

-		"UnlitGeneric_Detail",

-		"UnlitGeneric_EnvMapMaskNoTexture", //"UnlitGeneric_DetailEnvMapMaskNoTexture",

-		"UnlitGeneric_DetailEnvMapMask",

-	};

-

-	// handle hud elements

-	if ( bDetail & bDetailMultiplyMode )

-		return "alphadist_ps11";

-

-	if ( bDetail & bMaskBaseByDetailAlpha )

-		return "UnlitGeneric_MaskBaseByDetailAlpha_ps11";

-

-	if (!bMask && bEnvmap && bBaseTexture && bBaseAlphaEnvmapMask)

-	{

-		if (!bDetail)

-			return "UnlitGeneric_BaseAlphaMaskedEnvMap";

-		else

-			return "UnlitGeneric_DetailBaseAlphaMaskedEnvMap";

-	}

-	else

-	{

-		int pshIndex = 0;

-		if (bBaseTexture)

-			pshIndex |= 0x1;

-		if (bEnvmap)

-			pshIndex |= 0x2;

-		if (bMask)

-			pshIndex |= 0x4;

-		if (bDetail)

-			pshIndex |= 0x8;

-		return s_pPixelShaders[pshIndex];

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Sets up hw morphing state for the vertex shader

-//-----------------------------------------------------------------------------

-void CBaseVSShader::SetHWMorphVertexShaderState( int nDimConst, int nSubrectConst, VertexTextureSampler_t morphSampler )

-{

-#ifndef _X360

-	if ( !s_pShaderAPI->IsHWMorphingEnabled() )

-		return;

-

-	int nMorphWidth, nMorphHeight;

-	s_pShaderAPI->GetStandardTextureDimensions( &nMorphWidth, &nMorphHeight, TEXTURE_MORPH_ACCUMULATOR );

-

-	int nDim = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_4TUPLE_COUNT );

-	float pMorphAccumSize[4] = { nMorphWidth, nMorphHeight, nDim, 0.0f };

-	s_pShaderAPI->SetVertexShaderConstant( nDimConst, pMorphAccumSize );

-

-	int nXOffset = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_X_OFFSET );

-	int nYOffset = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_Y_OFFSET );

-	int nWidth = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_SUBRECT_WIDTH );

-	int nHeight = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_SUBRECT_HEIGHT );

-	float pMorphAccumSubrect[4] = { nXOffset, nYOffset, nWidth, nHeight };

-	s_pShaderAPI->SetVertexShaderConstant( nSubrectConst, pMorphAccumSubrect );

-

-	s_pShaderAPI->BindStandardVertexTexture( morphSampler, TEXTURE_MORPH_ACCUMULATOR );

-#endif

-}

-

-

-//-----------------------------------------------------------------------------

-// Vertex shader unlit generic pass

-//-----------------------------------------------------------------------------

-void CBaseVSShader::VertexShaderUnlitGenericPass( int baseTextureVar, int frameVar, 

-												  int baseTextureTransformVar, 

-												  int detailVar, int detailTransform,

-												  bool bDetailTransformIsScale,

-												  int envmapVar, int envMapFrameVar,

-												  int envmapMaskVar, int envmapMaskFrameVar, 

-												  int envmapMaskScaleVar, int envmapTintVar,

-												  int alphaTestReferenceVar,

-												  int nDetailBlendModeVar,

-												  int nOutlineVar,

-												  int nOutlineColorVar,

-												  int nOutlineStartVar,

-												  int nOutlineEndVar,

-												  int nSeparateDetailUVsVar )

-{

-	IMaterialVar** params = s_ppParams;

-

-	bool bBaseAlphaEnvmapMask = IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK);

-	bool bEnvmap = (envmapVar >= 0) && params[envmapVar]->IsTexture();

-	bool bMask = false;

-	if (bEnvmap && (envmapMaskVar >= 0))

-	{

-		bMask = params[envmapMaskVar]->IsTexture();

-	}

-	bool bDetail = (detailVar >= 0) && params[detailVar]->IsTexture(); 

-	bool bBaseTexture = (baseTextureVar >= 0) && params[baseTextureVar]->IsTexture();

-	bool bVertexColor = IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR);

-	bool bEnvmapCameraSpace = IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE);

-	bool bEnvmapSphere = IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE);

-

-	bool bDetailMultiply = ( nDetailBlendModeVar >= 0 ) && ( params[nDetailBlendModeVar]->GetIntValue() == 8 );

-	bool bMaskBaseByDetailAlpha = ( nDetailBlendModeVar >= 0 ) && ( params[nDetailBlendModeVar]->GetIntValue() == 9 );

-	bool bSeparateDetailUVs = ( nSeparateDetailUVsVar >= 0 ) && ( params[nSeparateDetailUVsVar]->GetIntValue() != 0 );

-

-	if (IsSnapshotting())

-	{

-		// Alpha test

-		s_pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );

-

-		if( alphaTestReferenceVar != -1 && params[alphaTestReferenceVar]->GetFloatValue() > 0.0f )

-		{

-			s_pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[alphaTestReferenceVar]->GetFloatValue() );

-		}

-

-		// Base texture on stage 0

-		if (bBaseTexture)

-		{

-			s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		}

-

-		if (bDetail)

-		{

-			s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );

-		}

-

-		if (bEnvmap)

-		{

-			// envmap on stage 1

-			s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );

-

-			// envmapmask on stage 2

-			if (bMask || bBaseAlphaEnvmapMask )

-				s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );

-		}

-

-		if (bBaseTexture)

-			SetDefaultBlendingShadowState( baseTextureVar, true );

-		else if (bMask)

-			SetDefaultBlendingShadowState( envmapMaskVar, false );

-		else

-			SetDefaultBlendingShadowState();

-

-		int fmt = VERTEX_POSITION;

-		if( bEnvmap )

-			fmt |= VERTEX_NORMAL;

-		if ( bVertexColor )

-			fmt |= VERTEX_COLOR;

-

-		int numTexCoords = 1;

-		if( bSeparateDetailUVs )

-		{

-			numTexCoords = 2;

-		}

-

-		s_pShaderShadow->VertexShaderVertexFormat( fmt, numTexCoords, 0, 0 );

-		const char *pshName = UnlitGeneric_ComputePixelShaderName(

-			bMask,

-			bEnvmap,

-			bBaseTexture,

-			bBaseAlphaEnvmapMask,

-			bDetail,

-			bDetailMultiply,

-			bMaskBaseByDetailAlpha );

-		s_pShaderShadow->SetPixelShader( pshName );

-

-		// Compute the vertex shader index.

-		unlitgeneric_vs11_Static_Index vshIndex;

-		vshIndex.SetDETAIL( bDetail );

-		vshIndex.SetENVMAP( bEnvmap );

-		vshIndex.SetENVMAPCAMERASPACE( bEnvmap && bEnvmapCameraSpace );

-		vshIndex.SetENVMAPSPHERE( bEnvmap && bEnvmapSphere );

-		vshIndex.SetVERTEXCOLOR( bVertexColor );

-		vshIndex.SetSEPARATEDETAILUVS( bSeparateDetailUVs );

-		s_pShaderShadow->SetVertexShader( "unlitgeneric_vs11", vshIndex.GetIndex() );

-

-		DefaultFog();

-	}

-	else

-	{

-		if ( s_pShaderAPI->InFlashlightMode() ) // Not snapshotting && flashlight pass

-		{

-			Draw( false );

-			return;

-		}

-

-		if (bBaseTexture)

-		{

-			BindTexture( SHADER_SAMPLER0, baseTextureVar, frameVar );

-			SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, baseTextureTransformVar );

-		}

-

-		if (bDetail)

-		{

-			BindTexture( SHADER_SAMPLER3, detailVar, frameVar );

-

-			if (bDetailTransformIsScale)

-			{

-				SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, baseTextureTransformVar, detailTransform );

-			}

-			else

-			{

-				SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, detailTransform );

-			}

-		}

-

-		if (bEnvmap)

-		{

-			BindTexture( SHADER_SAMPLER1, envmapVar, envMapFrameVar );

-

-			if (bMask || bBaseAlphaEnvmapMask)

-			{

-				if (bMask)

-					BindTexture( SHADER_SAMPLER2, envmapMaskVar, envmapMaskFrameVar );

-				else

-					BindTexture( SHADER_SAMPLER2, baseTextureVar, frameVar );

-

-				SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, baseTextureTransformVar, envmapMaskScaleVar );

-			}

-

-			SetEnvMapTintPixelShaderDynamicState( 2, envmapTintVar, -1 );

-

-			if (bEnvmapSphere || IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE))

-			{

-				LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_VIEWMODEL );

-			}

-		}

-

-		SetModulationVertexShaderDynamicState();

-	

-		float flConsts[12]={ 0, 0, 0, 1, 				// color

-			0, 0, 0, 0,					// max

-			0, 0, 0, .5,				// min

-		};

-

-		// set up outline pixel shader constants

-		if ( bDetailMultiply && ( nOutlineVar != -1 ) && ( params[nOutlineVar]->GetIntValue() ) )

-		{

-			if ( nOutlineColorVar != -1 )

-				params[nOutlineColorVar]->GetVecValue( flConsts, 3 );

-			if ( nOutlineEndVar != -1 )

-				flConsts[7] = params[nOutlineEndVar]->GetFloatValue();

-			if ( nOutlineStartVar != -1 )

-				flConsts[11] = params[nOutlineStartVar]->GetFloatValue();

-		}

-

-		s_pShaderAPI->SetPixelShaderConstant( 0, flConsts, 3 );

-

-		// Compute the vertex shader index.

-		unlitgeneric_vs11_Dynamic_Index vshIndex;

-		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-		vshIndex.SetSKINNING( s_pShaderAPI->GetCurrentNumBones() > 0 );

-		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-	}

-

-	Draw();

-}

-

-

-void CBaseVSShader::DrawWorldBaseTexture( int baseTextureVar, int baseTextureTransformVar,

-									int frameVar, int colorVar, int alphaVar )

-{

-	if( IsSnapshotting() )

-	{

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		s_pShaderShadow->VertexShaderVertexFormat( 

-			VERTEX_POSITION, 1, 0, 0 );

-		s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BaseTexture" );

-		SetNormalBlendingShadowState();

-		lightmappedgeneric_basetexture_Static_Index vshIndex;

-		s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BaseTexture", vshIndex.GetIndex() );

-

-		FogToOOOverbright();

-	}

-	else

-	{

-		IMaterialVar** params = s_ppParams;

-		bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE );

-		if( bLightingOnly )

-		{

-			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );

-		}

-		else

-		{

-			BindTexture( SHADER_SAMPLER0, baseTextureVar, frameVar );

-		}

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, baseTextureTransformVar );

-		SetColorPixelShaderConstant( 0, colorVar, alphaVar );

-		lightmappedgeneric_basetexture_Dynamic_Index vshIndex;

-		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-	}

-	Draw();

-}

-

-void CBaseVSShader::DrawWorldBumpedDiffuseLighting( int bumpmapVar, int bumpFrameVar,

-													int bumpTransformVar, bool bMultiply,

-													bool bSSBump )

-{

-	if( IsSnapshotting() )

-	{

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );

-		if( bMultiply )

-		{

-			s_pShaderShadow->EnableBlending( true );

-			SingleTextureLightmapBlendMode();

-		}

-		s_pShaderShadow->VertexShaderVertexFormat( VERTEX_POSITION, 3, 0, 0 );

-

-		lightmappedgeneric_bumpmappedlightmap_Static_Index vshIndex;

-		s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedLightmap", vshIndex.GetIndex() );

-

-		if ( bSSBump )

-			s_pShaderShadow->SetPixelShader( "LightmappedGeneric_SSBumpmappedLightmap" );

-		else

-			s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedLightmap" );

-			FogToFogColor();

-	}

-	else

-	{

-		if( !g_pConfig->m_bFastNoBump )

-		{

-			BindTexture( SHADER_SAMPLER0, bumpmapVar, bumpFrameVar );

-		}

-		else

-		{

-			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_NORMALMAP_FLAT );

-		}

-		LoadBumpLightmapCoordinateAxes_PixelShader( 0 );

-		s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP_BUMPED );

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, bumpTransformVar );

-		SetModulationPixelShaderDynamicState( 3 );

-

-		lightmappedgeneric_bumpmappedlightmap_Dynamic_Index vshIndex;

-		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-	}

-	Draw();

-}

-

-void CBaseVSShader::DrawWorldBumpedDiffuseLighting_Base_ps14( int bumpmapVar, int bumpFrameVar,

-											  int bumpTransformVar, 

-											  int baseTextureVar, int baseTextureTransformVar, int frameVar )

-{

-	if( IsSnapshotting() )

-	{

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );

-		s_pShaderShadow->VertexShaderVertexFormat( VERTEX_POSITION, 3, 0, 0 );

-

-		lightmappedgeneric_bumpmappedlightmap_base_ps14_Static_Index vshIndex;

-		s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedLightmap_Base_ps14", vshIndex.GetIndex() );

-

-		s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedLightmap_Base_ps14" );

-		FogToFogColor();

-	}

-	else

-	{

-		if( !g_pConfig->m_bFastNoBump )

-		{

-			BindTexture( SHADER_SAMPLER0, bumpmapVar, bumpFrameVar );

-		}

-		else

-		{

-			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_NORMALMAP_FLAT );

-		}

-		LoadBumpLightmapCoordinateAxes_PixelShader( 0 );

-		s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP_BUMPED );

-		BindTexture( SHADER_SAMPLER4, baseTextureVar, frameVar );

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, bumpTransformVar );

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, baseTextureTransformVar );

-		SetModulationPixelShaderDynamicState( 3 );

-

-		lightmappedgeneric_bumpmappedlightmap_base_ps14_Dynamic_Index vshIndex;

-		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-	}

-	Draw();

-}

-

-void CBaseVSShader::DrawWorldBumpedDiffuseLighting_Blend_ps14( int bumpmapVar, int bumpFrameVar,

-											int bumpTransformVar,

-											int baseTextureVar, int baseTextureTransformVar, 

-											int baseTextureFrameVar,

-											int baseTexture2Var, int baseTextureTransform2Var, 

-											int baseTextureFrame2Var)

-{

-	if( IsSnapshotting() )

-	{

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );

-		s_pShaderShadow->VertexShaderVertexFormat( VERTEX_POSITION, 3, 0, 0 );

-

-		lightmappedgeneric_bumpmappedlightmap_blend_ps14_Static_Index vshIndex;

-		s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedLightmap_Blend_ps14", vshIndex.GetIndex() );

-

-		s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedLightmap_Blend_ps14" );

-		FogToFogColor();

-	}

-	else

-	{

-		if( !g_pConfig->m_bFastNoBump )

-		{

-			BindTexture( SHADER_SAMPLER0, bumpmapVar, bumpFrameVar );

-		}

-		else

-		{

-			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_NORMALMAP_FLAT );

-		}

-		LoadBumpLightmapCoordinateAxes_PixelShader( 0 );

-		s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP_BUMPED );

-		BindTexture( SHADER_SAMPLER4, baseTextureVar, baseTextureFrameVar );

-		BindTexture( SHADER_SAMPLER5, baseTexture2Var, baseTextureFrame2Var );

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, bumpTransformVar );

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, baseTextureTransformVar );

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, baseTextureTransform2Var );

-		SetModulationPixelShaderDynamicState( 3 );

-

-		lightmappedgeneric_bumpmappedlightmap_blend_ps14_Dynamic_Index vshIndex;

-		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-	}

-	Draw();

-}

-

-//#define USE_DEST_ALPHA

-#define USE_NORMALMAP_ALPHA

-

-void CBaseVSShader::DrawWorldBumpedSpecularLighting( int bumpmapVar, int envmapVar,

-											   int bumpFrameVar, int envmapFrameVar,

-											   int envmapTintVar, int alphaVar,

-											   int envmapContrastVar, int envmapSaturationVar,

-											   int bumpTransformVar, int fresnelReflectionVar,

-											   bool bBlend, bool bNoWriteZ )

-{

-	// + BUMPED CUBEMAP

-	if( IsSnapshotting() )

-	{

-		SetInitialShadowState( );

-		if ( bNoWriteZ )

-		{

-			s_pShaderShadow->EnableDepthWrites( false );

-		}

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );

-		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )

-		{

-			s_pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );

-		}

-		if( bBlend )

-		{

-			s_pShaderShadow->EnableBlending( true );

-			s_pShaderShadow->BlendFunc( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE );

-		}

-		// FIXME: Remove the normal (needed for tangent space gen)

-		s_pShaderShadow->VertexShaderVertexFormat( 

-			VERTEX_POSITION | VERTEX_NORMAL | VERTEX_TANGENT_S |

-			VERTEX_TANGENT_T, 1, 0, 0 );

-

-		IMaterialVar** params = s_ppParams;

-		bool bHasNormalMapAlphaEnvMapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK );

-

-		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )

-		{

-			lightmappedgeneric_bumpmappedenvmap_ps14_Static_Index vshIndex;

-			s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedEnvmap_ps14", vshIndex.GetIndex() );

-

-			int nPshIndex = bHasNormalMapAlphaEnvMapMask ? 1 : 0;

-			s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedEnvmap_ps14", nPshIndex );

-		}

-		else

-		{

-			lightmappedgeneric_bumpmappedenvmap_Static_Index vshIndex;

-			s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedEnvmap", vshIndex.GetIndex() );

-

-			int nPshIndex = bHasNormalMapAlphaEnvMapMask ? 1 : 0;

-			s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedEnvmap", nPshIndex );

-		}

-		FogToBlack();

-	}

-	else

-	{

-		IMaterialVar** params = s_ppParams;

-		s_pShaderAPI->SetDefaultState();

-		BindTexture( SHADER_SAMPLER0, bumpmapVar, bumpFrameVar );

-		BindTexture( SHADER_SAMPLER3, envmapVar, envmapFrameVar );

-

-		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )

-		{

-			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALIZATION_CUBEMAP );

-

-			lightmappedgeneric_bumpmappedenvmap_ps14_Dynamic_Index vshIndex;

-			vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-			s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-		}

-		else

-		{

-			lightmappedgeneric_bumpmappedenvmap_Dynamic_Index vshIndex;

-			vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-			s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-		}

-				

-		SetEnvMapTintPixelShaderDynamicState( 0, envmapTintVar, alphaVar );

-		// GR - fudge consts a bit to fix const/lerp issues

-		SetPixelShaderConstantFudge( 1, envmapContrastVar );

-		SetPixelShaderConstantFudge( 2, envmapSaturationVar );

-		float greyWeights[4] = { 0.299f, 0.587f, 0.114f, 0.0f };

-		s_pShaderAPI->SetPixelShaderConstant( 3, greyWeights );

-

-		// [ 0, 0 ,0, R(0) ]

-		float fresnel[4] = { 0.0f, 0.0f, 0.0f, 0.0f };

-		fresnel[3] = params[fresnelReflectionVar]->GetFloatValue();

-		s_pShaderAPI->SetPixelShaderConstant( 4, fresnel );

-		// [ 0, 0 ,0, 1-R(0) ]

-		fresnel[3] = 1.0f - fresnel[3];

-		s_pShaderAPI->SetPixelShaderConstant( 6, fresnel );

-

-		float one[4] = { 1.0f, 1.0f, 1.0f, 1.0f };

-		s_pShaderAPI->SetPixelShaderConstant( 5, one );

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, bumpTransformVar );

-	}

-	Draw();

-}

-

-void CBaseVSShader::DrawModelBumpedSpecularLighting( int bumpMapVar, int bumpMapFrameVar,

-											   int envMapVar, int envMapVarFrame,

-											   int envMapTintVar, int alphaVar,

-											   int envMapContrastVar, int envMapSaturationVar,

-											   int bumpTransformVar,

-											   bool bBlendSpecular, bool bNoWriteZ )

-{

-	IMaterialVar** params = s_ppParams;

-	

-	if( IsSnapshotting() )

-	{

-		SetInitialShadowState( );

-		if ( bNoWriteZ )

-		{

-			s_pShaderShadow->EnableDepthWrites( false );

-		}

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );

-		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )

-		{

-			s_pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );

-		}

-		s_pShaderShadow->EnableAlphaTest( false );

-		if( bBlendSpecular )

-		{

-			s_pShaderShadow->EnableBlending( true );

-			SetAdditiveBlendingShadowState( -1, false );

-		}

-		else

-		{

-			s_pShaderShadow->EnableBlending( false );

-			SetNormalBlendingShadowState( -1, false );

-		}

-				

-		s_pShaderShadow->VertexShaderVertexFormat( 

-			VERTEX_POSITION | VERTEX_NORMAL, 1, 0, 4 /* userDataSize */ );

-

-		bool bHasNormalMapAlphaEnvMapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK );

-

-		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )

-		{

-			vertexlitgeneric_envmappedbumpmap_nolighting_ps14_Static_Index vshIndex;

-			s_pShaderShadow->SetVertexShader( "VertexLitGeneric_EnvmappedBumpmap_NoLighting_ps14", vshIndex.GetIndex() );

-			if( bHasNormalMapAlphaEnvMapMask )

-			{

-				s_pShaderShadow->SetPixelShader( "VertexLitGeneric_EnvmappedBumpmapV2_MultByAlpha_ps14" );

-			}

-			else

-			{

-				s_pShaderShadow->SetPixelShader( "VertexLitGeneric_EnvmappedBumpmapV2_ps14" );

-			}

-		}

-		else

-		{

-			vertexlitgeneric_envmappedbumpmap_nolighting_Static_Index vshIndex;

-			s_pShaderShadow->SetVertexShader( "VertexLitGeneric_EnvmappedBumpmap_NoLighting", vshIndex.GetIndex() );

-			// This version does not multiply by lighting

-			// NOTE: We don't support multiplying by lighting for bumped specular stuff.

-			if( bHasNormalMapAlphaEnvMapMask )

-			{

-				s_pShaderShadow->SetPixelShader( "VertexLitGeneric_EnvmappedBumpmapV2_MultByAlpha" );

-			}

-			else

-			{

-				s_pShaderShadow->SetPixelShader( "VertexLitGeneric_EnvmappedBumpmapV2" );

-			}

-		}

-		FogToBlack();

-	}

-	else

-	{

-		s_pShaderAPI->SetDefaultState();

-		BindTexture( SHADER_SAMPLER0, bumpMapVar, bumpMapFrameVar );

-		BindTexture( SHADER_SAMPLER3, envMapVar, envMapVarFrame );

-		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )

-		{

-			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALIZATION_CUBEMAP );

-		}

-				

-		if( bBlendSpecular )

-		{

-			SetEnvMapTintPixelShaderDynamicState( 0, envMapTintVar, -1 );

-		}

-		else

-		{

-			SetEnvMapTintPixelShaderDynamicState( 0, envMapTintVar, alphaVar );

-		}

-		// GR - fudge consts a bit to fix const/lerp issues

-		SetPixelShaderConstantFudge( 1, envMapContrastVar );

-		SetPixelShaderConstantFudge( 2, envMapSaturationVar );

-		float greyWeights[4] = { 0.299f, 0.587f, 0.114f, 0.0f };

-		s_pShaderAPI->SetPixelShaderConstant( 3, greyWeights );

-		

-		// handle scrolling of bump texture

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, bumpTransformVar );

-

-		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )

-		{

-			vertexlitgeneric_envmappedbumpmap_nolighting_ps14_Dynamic_Index vshIndex;

-			vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-			vshIndex.SetSKINNING( s_pShaderAPI->GetCurrentNumBones() > 0 );

-			s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-		}

-		else

-		{

-			vertexlitgeneric_envmappedbumpmap_nolighting_Dynamic_Index vshIndex;

-			vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-			vshIndex.SetSKINNING( s_pShaderAPI->GetCurrentNumBones() > 0 );

-			s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-		}

-	}

-	Draw();

-}

-

-void CBaseVSShader::DrawBaseTextureBlend( int baseTextureVar, int baseTextureTransformVar, 

-									 int baseTextureFrameVar,

-									 int baseTexture2Var, int baseTextureTransform2Var, 

-									 int baseTextureFrame2Var, int colorVar, int alphaVar )

-{

-	if( IsSnapshotting() )

-	{

-		SetInitialShadowState();

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );

-		s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );

-		s_pShaderShadow->DrawFlags( SHADER_DRAW_POSITION | SHADER_DRAW_TEXCOORD0 |

-			SHADER_DRAW_LIGHTMAP_TEXCOORD1 );

-		// FIXME: Remove the normal (needed for tangent space gen)

-		s_pShaderShadow->VertexShaderVertexFormat( 

-			VERTEX_POSITION, 2, 0, 0 );

-

-		lightmappedgeneric_basetextureblend_Static_Index vshIndex;

-		s_pShaderShadow->SetVertexShader( "lightmappedgeneric_basetextureblend", vshIndex.GetIndex() );

-

-		s_pShaderShadow->SetPixelShader( "lightmappedgeneric_basetextureblend", 0 );

-		FogToOOOverbright();

-	}

-	else

-	{

-		IMaterialVar** params = s_ppParams;

-		bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE );

-

-		s_pShaderAPI->SetDefaultState();

-		if( bLightingOnly )

-		{

-			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY );

-			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );

-		}

-		else

-		{

-			BindTexture( SHADER_SAMPLER0, baseTextureVar, baseTextureFrameVar );

-			BindTexture( SHADER_SAMPLER1, baseTexture2Var, baseTextureFrame2Var );

-		}

-		s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_LIGHTMAP );

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, baseTextureTransformVar );

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, baseTextureTransform2Var );

-		SetColorPixelShaderConstant( 0, colorVar, alphaVar );

-		lightmappedgeneric_basetextureblend_Dynamic_Index vshIndex;

-		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-	}

-	Draw();

-}

-

-void CBaseVSShader::DrawWorldBumpedUsingVertexShader( int baseTextureVar, int baseTextureTransformVar,

-													  int bumpmapVar, int bumpFrameVar, 

-													  int bumpTransformVar,

-													  int envmapMaskVar, int envmapMaskFrame,

-													  int envmapVar, 

-													  int envmapFrameVar,

-													  int envmapTintVar, int colorVar, int alphaVar,

-													  int envmapContrastVar, int envmapSaturationVar,

-													  int frameVar, int fresnelReflectionVar,

-													  bool doBaseTexture2,

-													  int baseTexture2Var, int baseTextureTransform2Var,

-													  int baseTextureFrame2Var,

-													  bool bSSBump

-												)

-{

-	IMaterialVar** params = s_ppParams;

-	// Draw base texture

-	bool bMultiplyDiffuseLighting = false;

-	bool bBlendSpecular = false;

-	

-	// Draw base texture(s)

-	if( doBaseTexture2 && params[baseTexture2Var]->IsTexture() && params[baseTextureVar]->IsTexture() )

-	{

-		DrawBaseTextureBlend( baseTextureVar, baseTextureTransformVar, frameVar,

-			baseTexture2Var, baseTextureTransform2Var, baseTextureFrame2Var, colorVar, alphaVar );

-		bMultiplyDiffuseLighting = true;

-		bBlendSpecular = true;

-	}

-	else if( params[baseTextureVar]->IsTexture() )

-	{

-		DrawWorldBaseTexture( baseTextureVar, baseTextureTransformVar, frameVar, colorVar, alphaVar );

-		bMultiplyDiffuseLighting = true;

-		bBlendSpecular = true;

-	}

-	else

-	{

-		// Just use color here

-	}

-

-	// Draw diffuse lighting

-	if( params[baseTextureVar]->IsTexture() || !params[envmapVar]->IsTexture() )

-	{

-		DrawWorldBumpedDiffuseLighting( bumpmapVar, bumpFrameVar, bumpTransformVar, 

-			bMultiplyDiffuseLighting, bSSBump );

-		bBlendSpecular = true;

-	}

-

-	// Add specular lighting

-	if( params[envmapVar]->IsTexture() )

-	{

-		DrawWorldBumpedSpecularLighting(

-			bumpmapVar, envmapVar,

-			bumpFrameVar, envmapFrameVar,

-			envmapTintVar, alphaVar,

-			envmapContrastVar, envmapSaturationVar,

-			bumpTransformVar, fresnelReflectionVar,

-			bBlendSpecular );

-	}

-}

-#endif // GAME_SHADER_DLL

-

-

-//-----------------------------------------------------------------------------

-// GR - translucency query

-//-----------------------------------------------------------------------------

-BlendType_t CBaseVSShader::EvaluateBlendRequirements( int textureVar, bool isBaseTexture,

-													  int detailTextureVar )

-{

-	// Either we've got a constant modulation

-	bool isTranslucent = IsAlphaModulating();

-

-	// Or we've got a vertex alpha

-	isTranslucent = isTranslucent || (CurrentMaterialVarFlags() & MATERIAL_VAR_VERTEXALPHA);

-

-	// Or we've got a texture alpha (for blending or alpha test)

-	isTranslucent = isTranslucent || ( TextureIsTranslucent( textureVar, isBaseTexture ) &&

-		                               !(CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST ) );

-

-	if ( ( detailTextureVar != -1 ) && ( ! isTranslucent ) )

-	{

-		isTranslucent = TextureIsTranslucent( detailTextureVar, isBaseTexture );

-	}

-

-	if ( CurrentMaterialVarFlags() & MATERIAL_VAR_ADDITIVE )

-	{	

-		return isTranslucent ? BT_BLENDADD : BT_ADD;	// Additive

-	}

-	else

-	{

-		return isTranslucent ? BT_BLEND : BT_NONE;		// Normal blending

-	}

-}

-

-#ifndef GAME_SHADER_DLL

-

-void CBaseVSShader::SetFlashlightVertexShaderConstants( bool bBump, int bumpTransformVar, bool bDetail, int detailScaleVar, bool bSetTextureTransforms )

-{

-	Assert( !IsSnapshotting() );

-

-	VMatrix worldToTexture;

-	const FlashlightState_t &flashlightState = s_pShaderAPI->GetFlashlightState( worldToTexture );

-

-	// Set the flashlight origin

-	float pos[4];

-	pos[0] = flashlightState.m_vecLightOrigin[0];

-	pos[1] = flashlightState.m_vecLightOrigin[1];

-	pos[2] = flashlightState.m_vecLightOrigin[2];

-	pos[3] = 1.0f / ( ( 0.6f * flashlightState.m_FarZ ) - flashlightState.m_FarZ );		// DX8 needs this

-

-	s_pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, pos, 1 );

-

-	s_pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, worldToTexture.Base(), 4 );

-

-	// Set the flashlight attenuation factors

-	float atten[4];

-	atten[0] = flashlightState.m_fConstantAtten;

-	atten[1] = flashlightState.m_fLinearAtten;

-	atten[2] = flashlightState.m_fQuadraticAtten;

-	atten[3] = flashlightState.m_FarZ;

-	s_pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, atten, 1 );

-

-	if ( bDetail )

-	{

-		SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_8, BASETEXTURETRANSFORM, detailScaleVar );

-	}

-

-	if( bSetTextureTransforms )

-	{

-		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, BASETEXTURETRANSFORM );

-		if( !bDetail && bBump && bumpTransformVar != -1 )

-		{

-			SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_8, bumpTransformVar ); // aliased on top of detail transform

-		}

-	}

-}

-

-#if SUPPORT_DX8

-void CBaseVSShader::DrawFlashlight_dx80( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bBump,

-										int bumpmapVar, int bumpmapFrame, int bumpTransform, int flashlightTextureVar, int flashlightTextureFrameVar,

-										bool bLightmappedGeneric, bool bWorldVertexTransition, int nWorldVertexTransitionPassID, int baseTexture2Var,

-										int baseTexture2FrameVar, bool bTeeth, int nTeethForwardVar, int nTeethIllumFactorVar )

-{

-	// FLASHLIGHTFIXME: hack . . need to fix the vertex shader so that it can deal with and without bumps for vertexlitgeneric

-	if( !bLightmappedGeneric )

-	{

-		bBump = false;

-	}

-	if( pShaderShadow )

-	{

-		SetInitialShadowState();

-		pShaderShadow->EnableDepthWrites( false );

-

-		// Be sure not to write to dest alpha

-		pShaderShadow->EnableAlphaWrites( false );

-

-		// Never alpha test the flashlight pass

-		pShaderShadow->EnableAlphaTest( false );

-

-		if ( IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) )

-		{

-			// use zfunc zequals since alpha isn't guaranteed to 

-			// be the same on both the regular pass and the flashlight pass.

-			pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL );

-		}

-

-		// Alpha blend

-		if( bWorldVertexTransition )

-		{

-			// use separate alpha blend to make sure that we aren't adding alpha from source

-			if( nWorldVertexTransitionPassID == 0 )

-			{

-				EnableAlphaBlending( SHADER_BLEND_DST_ALPHA, SHADER_BLEND_ONE );

-			}

-			else

-			{

-				EnableAlphaBlending( SHADER_BLEND_ONE_MINUS_DST_ALPHA, SHADER_BLEND_ONE );

-			}

-		}

-		else

-		{

-			SetAdditiveBlendingShadowState( BASETEXTURE, true );

-		}

-		

-		pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );

-		pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );

-		pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );

-

-		if( bLightmappedGeneric )

-		{

-			bool bUsingVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );

-			lightmappedgeneric_flashlight_vs11_Static_Index	vshIndex;

-			vshIndex.SetNORMALMAP( bBump );

-			vshIndex.SetWORLDVERTEXTRANSITION( bWorldVertexTransition );

-			vshIndex.SetVERTEXCOLOR( bUsingVertexColor );

-			pShaderShadow->SetVertexShader( "lightmappedgeneric_flashlight_vs11", vshIndex.GetIndex() );

-

-			unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;

-			if( bBump )

-			{

-				flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T;

-			}

-			if ( bWorldVertexTransition || bUsingVertexColor )

-			{

-				flags |= VERTEX_COLOR;

-			}

-			pShaderShadow->VertexShaderVertexFormat( flags, 1, 0, 0 );

-		}

-		else

-		{

-			vertexlitgeneric_flashlight_vs11_Static_Index vshIndex;

-			vshIndex.SetTEETH( bTeeth );

-			pShaderShadow->SetVertexShader( "vertexlitgeneric_flashlight_vs11", vshIndex.GetIndex() );

-

-			unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;

-			pShaderShadow->VertexShaderVertexFormat( flags, 1, 0, bBump ? 4 : 0 );

-		}

-

-		bool bNoCull = IS_FLAG_SET( MATERIAL_VAR_NOCULL );

-

-		flashlight_ps11_Static_Index	pshIndex;

-		pshIndex.SetNORMALMAP( bBump );

-		pshIndex.SetNOCULL( bNoCull );

-		pShaderShadow->SetPixelShader( "flashlight_ps11", pshIndex.GetIndex() );

-

-		FogToBlack();

-	}

-	else

-	{

-		// Specify that we have XYZ texcoords that need to be divided by W before the pixel shader.

-		// NOTE Tried to divide XY by Z, but doesn't work.

-		// The dx9.0c runtime says that we shouldn't have a non-zero dimension when using vertex and pixel shaders.

-		pShaderAPI->SetTextureTransformDimension( SHADER_TEXTURE_STAGE0, 0, true );

-		BindTexture( SHADER_SAMPLER0, flashlightTextureVar, flashlightTextureFrameVar );

-

-		if( bWorldVertexTransition && ( nWorldVertexTransitionPassID == 1 ) )

-		{

-			BindTexture( SHADER_SAMPLER1, baseTexture2Var, baseTexture2FrameVar );

-		}

-		else

-		{

-			if( params[BASETEXTURE]->IsTexture() )

-			{

-				BindTexture( SHADER_SAMPLER1, BASETEXTURE, FRAME );

-			}

-			else

-			{

-				pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );

-			}

-		}

-		pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_NORMALIZATION_CUBEMAP );

-		if( bBump )

-		{

-			BindTexture( SHADER_SAMPLER3, bumpmapVar, bumpmapFrame );

-		}

-		else

-		{

-			pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALIZATION_CUBEMAP );

-		}

-

-		if( bLightmappedGeneric )

-		{

-			lightmappedgeneric_flashlight_vs11_Dynamic_Index vshIndex;

-			vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-			pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-		}

-		else

-		{

-			vertexlitgeneric_flashlight_vs11_Dynamic_Index vshIndex;

-			vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-

-			if( bTeeth )

-			{

-				Assert( nTeethForwardVar >= 0 );

-				Assert( nTeethIllumFactorVar >= 0 );

-				Vector4D lighting;

-				params[nTeethForwardVar]->GetVecValue( lighting.Base(), 3 );

-				lighting[3] = params[nTeethIllumFactorVar]->GetFloatValue();

-				pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, lighting.Base() );

-			}

-

-			vshIndex.SetSKINNING( pShaderAPI->GetCurrentNumBones() > 0 );

-			pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-		}

-

-		flashlight_ps11_Dynamic_Index pshIndex;

-		pShaderAPI->SetPixelShaderIndex( pshIndex.GetIndex() );

-

-		SetFlashlightVertexShaderConstants( bBump, bumpTransform, false, -1, true );

-	}

-	Draw();

-}

-#endif // support_dx8

-

-#ifdef STDSHADER_DX9_DLL_EXPORT

-void CBaseVSShader::DrawFlashlight_dx90( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, 

-										IShaderShadow* pShaderShadow, DrawFlashlight_dx90_Vars_t &vars )

-{

-	// FLASHLIGHTFIXME: hack . . need to fix the vertex shader so that it can deal with and without bumps for vertexlitgeneric

-	if( !vars.m_bLightmappedGeneric )

-	{

-		vars.m_bBump = false;

-	}

-	bool bBump2 = vars.m_bWorldVertexTransition && vars.m_bBump && vars.m_nBumpmap2Var != -1 && params[vars.m_nBumpmap2Var]->IsTexture();

-	bool bSeamless = vars.m_fSeamlessScale != 0.0;

-	bool bDetail = vars.m_bLightmappedGeneric && (vars.m_nDetailVar != -1) && params[vars.m_nDetailVar]->IsDefined() && (vars.m_nDetailScale != -1);

-

-	int nDetailBlendMode = 0;

-	if ( bDetail )

-	{

-		nDetailBlendMode = GetIntParam( vars.m_nDetailTextureCombineMode, params );

-		nDetailBlendMode = nDetailBlendMode > 1 ? 1 : nDetailBlendMode;

-	}

-

-	if( pShaderShadow )

-	{

-		SetInitialShadowState();

-		pShaderShadow->EnableDepthWrites( false );

-		pShaderShadow->EnableAlphaWrites( false );

-

-		// Alpha blend

-		SetAdditiveBlendingShadowState( BASETEXTURE, true );

-

-		// Alpha test

-		pShaderShadow->EnableAlphaTest( IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) );

-		if ( vars.m_nAlphaTestReference != -1 && params[vars.m_nAlphaTestReference]->GetFloatValue() > 0.0f )

-		{

-			pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[vars.m_nAlphaTestReference]->GetFloatValue() );

-		}

-

-		// Spot sampler

-		pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );

-		pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );

-

-		// Base sampler

-		pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );

-		pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );

-

-		// Normalizing cubemap sampler

-		pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );

-

-		// Normalizing cubemap sampler2 or normal map sampler

-		pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );

-

-		// RandomRotation sampler

-		pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );

-

-		// Flashlight depth sampler

-		pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );

-		pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER7 );

-

-		if( vars.m_bWorldVertexTransition )

-		{

-			// $basetexture2

-			pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );

-			pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );

-		}

-		if( bBump2 )

-		{

-			// Normalmap2 sampler

-			pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );

-		}

-		if( bDetail )

-		{

-			pShaderShadow->EnableTexture( SHADER_SAMPLER8, true );				// detail sampler

-			if ( nDetailBlendMode != 0 ) //Not Mod2X

-				pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, true );

-		}

-		

-		pShaderShadow->EnableSRGBWrite( true );

-

-		if( vars.m_bLightmappedGeneric )

-		{

-			lightmappedgeneric_flashlight_vs20_Static_Index	vshIndex;

-			vshIndex.SetWORLDVERTEXTRANSITION( vars.m_bWorldVertexTransition );

-			vshIndex.SetNORMALMAP( vars.m_bBump );

-			vshIndex.SetSEAMLESS( bSeamless );

-			vshIndex.SetDETAIL( bDetail );

-			pShaderShadow->SetVertexShader( "lightmappedgeneric_flashlight_vs20", vshIndex.GetIndex() );

-

-			unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;

-			if( vars.m_bBump )

-			{

-				flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T;

-			}

-			int numTexCoords = 1;

-			if( vars.m_bWorldVertexTransition )

-			{

-				flags |= VERTEX_COLOR;

-				numTexCoords = 2; // need lightmap texcoords to get alpha.

-			}

-			pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, 0 );

-		}

-		else

-		{

-			vertexlitgeneric_flashlight_vs11_Static_Index vshIndex;

-			vshIndex.SetTEETH( vars.m_bTeeth );

-			pShaderShadow->SetVertexShader( "vertexlitgeneric_flashlight_vs11", vshIndex.GetIndex() );

-

-			unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;

-			int numTexCoords = 1;

-			pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, vars.m_bBump ? 4 : 0 );

-		}

-

-		int nBumpMapVariant = 0;

-		if ( vars.m_bBump )

-		{

-			nBumpMapVariant = ( vars.m_bSSBump ) ? 2 : 1;

-		}

-		if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )

-		{

-			int nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode();

-

-			flashlight_ps20b_Static_Index	pshIndex;

-			pshIndex.SetNORMALMAP( nBumpMapVariant );

-			pshIndex.SetNORMALMAP2( bBump2 );

-			pshIndex.SetWORLDVERTEXTRANSITION( vars.m_bWorldVertexTransition );

-			pshIndex.SetSEAMLESS( bSeamless );

-			pshIndex.SetDETAILTEXTURE( bDetail );

-			pshIndex.SetDETAIL_BLEND_MODE( nDetailBlendMode );

-			pshIndex.SetFLASHLIGHTDEPTHFILTERMODE( nShadowFilterMode );

-			pShaderShadow->SetPixelShader( "flashlight_ps20b", pshIndex.GetIndex() );

-		}

-		else

-		{

-			flashlight_ps20_Static_Index	pshIndex;

-			pshIndex.SetNORMALMAP( nBumpMapVariant );

-			pshIndex.SetNORMALMAP2( bBump2 );

-			pshIndex.SetWORLDVERTEXTRANSITION( vars.m_bWorldVertexTransition );

-			pshIndex.SetSEAMLESS( bSeamless );

-			pshIndex.SetDETAILTEXTURE( bDetail );

-			pshIndex.SetDETAIL_BLEND_MODE( nDetailBlendMode );

-			pShaderShadow->SetPixelShader( "flashlight_ps20", pshIndex.GetIndex() );

-		}

-		FogToBlack();

-	}

-	else

-	{

-		VMatrix worldToTexture;

-		ITexture *pFlashlightDepthTexture;

-		FlashlightState_t flashlightState = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );

-

-		SetFlashLightColorFromState( flashlightState, pShaderAPI );

-

-		BindTexture( SHADER_SAMPLER0, flashlightState.m_pSpotlightTexture, flashlightState.m_nSpotlightTextureFrame );

-

-		if( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() && flashlightState.m_bEnableShadows )

-		{

-			BindTexture( SHADER_SAMPLER7, pFlashlightDepthTexture, 0 );

-			pShaderAPI->BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SHADOW_NOISE_2D );

-

-			// Tweaks associated with a given flashlight

-			float tweaks[4];

-			tweaks[0] = ShadowFilterFromState( flashlightState );

-			tweaks[1] = ShadowAttenFromState( flashlightState );

-			HashShadow2DJitter( flashlightState.m_flShadowJitterSeed, &tweaks[2], &tweaks[3] );

-			pShaderAPI->SetPixelShaderConstant( PSREG_ENVMAP_TINT__SHADOW_TWEAKS, tweaks, 1 );

-

-			// Dimensions of screen, used for screen-space noise map sampling

-			float vScreenScale[4] = {1280.0f / 32.0f, 720.0f / 32.0f, 0, 0};

-			int nWidth, nHeight;

-			pShaderAPI->GetBackBufferDimensions( nWidth, nHeight );

-			vScreenScale[0] = (float) nWidth  / 32.0f;

-			vScreenScale[1] = (float) nHeight / 32.0f;

-			pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_SCREEN_SCALE, vScreenScale, 1 );

-		}

-

-		if( params[BASETEXTURE]->IsTexture() && mat_fullbright.GetInt() != 2 )

-		{

-			BindTexture( SHADER_SAMPLER1, BASETEXTURE, FRAME );

-		}

-		else

-		{

-			pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );

-		}

-		if( vars.m_bWorldVertexTransition )

-		{

-			Assert( vars.m_nBaseTexture2Var >= 0 && vars.m_nBaseTexture2FrameVar >= 0 );

-			BindTexture( SHADER_SAMPLER4, vars.m_nBaseTexture2Var, vars.m_nBaseTexture2FrameVar );

-		}

-		pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_NORMALIZATION_CUBEMAP );

-		if( vars.m_bBump )

-		{

-			BindTexture( SHADER_SAMPLER3, vars.m_nBumpmapVar, vars.m_nBumpmapFrame );

-		}

-		else

-		{

-			pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALIZATION_CUBEMAP );

-		}

-

-		if( bDetail )

-		{

-			BindTexture( SHADER_SAMPLER8, vars.m_nDetailVar );

-		}

-

-		if( vars.m_bWorldVertexTransition )

-		{

-			if( bBump2 )

-			{

-				BindTexture( SHADER_SAMPLER6, vars.m_nBumpmap2Var, vars.m_nBumpmap2Frame );

-			}

-		}

-

-		if( vars.m_bLightmappedGeneric )

-		{

-			DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs20 );

-			SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-			SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs20 );

-			if ( bSeamless )

-			{

-				float const0[4]={ vars.m_fSeamlessScale,0,0,0};

-				pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, const0 );

-			}

-

-			if ( bDetail )

-			{

-				float vDetailConstants[4] = {1,1,1,1};

-

-				if ( vars.m_nDetailTint != -1 )

-				{

-					params[vars.m_nDetailTint]->GetVecValue( vDetailConstants, 3 );

-				}

-

-				if ( vars.m_nDetailTextureBlendFactor != -1 )

-				{

-					vDetailConstants[3] = params[vars.m_nDetailTextureBlendFactor]->GetFloatValue();

-				}

-

-				pShaderAPI->SetPixelShaderConstant( 0, vDetailConstants, 1 );

-			}

-		}

-		else

-		{

-			vertexlitgeneric_flashlight_vs11_Dynamic_Index vshIndex;

-			vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );

-			vshIndex.SetSKINNING( pShaderAPI->GetCurrentNumBones() > 0 );

-			pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );

-

-			if( vars.m_bTeeth )

-			{

-				Assert( vars.m_nTeethForwardVar >= 0 );

-				Assert( vars.m_nTeethIllumFactorVar >= 0 );

-				Vector4D lighting;

-				params[vars.m_nTeethForwardVar]->GetVecValue( lighting.Base(), 3 );

-				lighting[3] = params[vars.m_nTeethIllumFactorVar]->GetFloatValue();

-				pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, lighting.Base() );

-			}

-		}

-

-		pShaderAPI->SetPixelShaderFogParams( PSREG_FOG_PARAMS );

-

-		float vEyePos_SpecExponent[4];

-		pShaderAPI->GetWorldSpaceCameraPosition( vEyePos_SpecExponent );

-		vEyePos_SpecExponent[3] = 0.0f;

-		pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vEyePos_SpecExponent, 1 );

-

-		if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )

-		{

-			DECLARE_DYNAMIC_PIXEL_SHADER( flashlight_ps20b );

-			SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE,  pShaderAPI->GetPixelFogCombo() );

-			SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, flashlightState.m_bEnableShadows && ( pFlashlightDepthTexture != NULL ) );

-			SET_DYNAMIC_PIXEL_SHADER( flashlight_ps20b );

-		}

-		else

-		{

-			DECLARE_DYNAMIC_PIXEL_SHADER( flashlight_ps20 );

-			SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE,  pShaderAPI->GetPixelFogCombo() );

-			SET_DYNAMIC_PIXEL_SHADER( flashlight_ps20 );

-		}

-

-		float atten[4];										// Set the flashlight attenuation factors

-		atten[0] = flashlightState.m_fConstantAtten;

-		atten[1] = flashlightState.m_fLinearAtten;

-		atten[2] = flashlightState.m_fQuadraticAtten;

-		atten[3] = flashlightState.m_FarZ;

-		s_pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, atten, 1 );

-

-		SetFlashlightVertexShaderConstants( vars.m_bBump, vars.m_nBumpTransform, bDetail, vars.m_nDetailScale,  bSeamless ? false : true );

-	}

-	Draw();

-}

-

-#endif

-

-void CBaseVSShader::InitParamsUnlitGeneric_DX8(

-		int baseTextureVar,

-		int detailScaleVar,

-		int envmapOptionalVar,

-		int envmapVar,

-		int envmapTintVar, 

-		int envmapMaskScaleVar,

-		int nDetailBlendMode )

-{

-	IMaterialVar** params = s_ppParams;

-

-	SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING );

-

-	if( envmapTintVar >= 0 && !params[envmapTintVar]->IsDefined() )

-	{

-		params[envmapTintVar]->SetVecValue( 1.0f, 1.0f, 1.0f );

-	}

-

-	if( envmapMaskScaleVar >= 0 && !params[envmapMaskScaleVar]->IsDefined() )

-	{

-		params[envmapMaskScaleVar]->SetFloatValue( 1.0f );

-	}

-

-	if( detailScaleVar >= 0 && !params[detailScaleVar]->IsDefined() )

-	{

-		params[detailScaleVar]->SetFloatValue( 4.0f );

-	}

-

-	// No texture means no self-illum or env mask in base alpha

-	if ( baseTextureVar >= 0 && !params[baseTextureVar]->IsDefined() )

-	{

-		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 );

-	}

-

-	// Get rid of the envmap if it's optional for this dx level.

-	if( envmapOptionalVar >= 0 && params[envmapOptionalVar]->IsDefined() && params[envmapOptionalVar]->GetIntValue() )

-	{

-		if (envmapVar >= 0)

-		{

-			params[envmapVar]->SetUndefined();

-		}

-	}

-

-	// If mat_specular 0, then get rid of envmap

-	if( envmapVar >= 0 && baseTextureVar >= 0 && !g_pConfig->UseSpecular() && params[envmapVar]->IsDefined() && params[baseTextureVar]->IsDefined() )

-	{

-		params[envmapVar]->SetUndefined();

-	}

-}

-

-void CBaseVSShader::InitUnlitGeneric_DX8(

-		int baseTextureVar,

-		int detailVar,

-		int envmapVar,

-		int envmapMaskVar )

-{

-	IMaterialVar** params = s_ppParams;

-

-	if (baseTextureVar >= 0 && params[baseTextureVar]->IsDefined())

-	{

-		LoadTexture( baseTextureVar );

-

-		if (!params[baseTextureVar]->GetTextureValue()->IsTranslucent())

-		{

-			if (IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK))

-				CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK );

-		}

-	}

-

-	// Don't alpha test if the alpha channel is used for other purposes

-	if ( IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) )

-		CLEAR_FLAGS( MATERIAL_VAR_ALPHATEST );

-

-	// the second texture (if there is one)

-	if (detailVar >= 0 && params[detailVar]->IsDefined())

-	{

-		LoadTexture( detailVar );

-	}

-

-	if (envmapVar >= 0 && params[envmapVar]->IsDefined())

-	{

-		if( !IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) )

-			LoadCubeMap( envmapVar );

-		else

-			LoadTexture( envmapVar );

-

-		if( !g_pHardwareConfig->SupportsCubeMaps() )

-			SET_FLAGS(MATERIAL_VAR_ENVMAPSPHERE);

-

-		if (envmapMaskVar >= 0 && params[envmapMaskVar]->IsDefined())

-			LoadTexture( envmapMaskVar );

-	}

-}

-#endif // GAME_SHADER_DLL

-

-#endif // !_STATIC_LINKED || STDSHADER_DX8_DLL_EXPORT

-

-

-// Take 0..1 seed and map to (u, v) coordinate to be used in shadow filter jittering...

-void CBaseVSShader::HashShadow2DJitter( const float fJitterSeed, float *fU, float* fV )

-{

-	const int nTexRes = 32;

-	int nSeed = fmod (fJitterSeed, 1.0f) * nTexRes * nTexRes;

-

-	int nRow = nSeed / nTexRes;

-	int nCol = nSeed % nTexRes;

-

-	// Div and mod to get an individual texel in the fTexRes x fTexRes grid

-	*fU = nRow / (float) nTexRes;	// Row

-	*fV = nCol / (float) nTexRes;	// Column

-}

-

-

-void CBaseVSShader::DrawEqualDepthToDestAlpha( void )

-{

-#ifdef STDSHADER_DX9_DLL_EXPORT

-	if( g_pHardwareConfig->SupportsPixelShaders_2_b() )

-	{

-		bool bMakeActualDrawCall = false;

-		if( s_pShaderShadow )

-		{

-			s_pShaderShadow->EnableColorWrites( false );

-			s_pShaderShadow->EnableAlphaWrites( true );

-			s_pShaderShadow->EnableDepthWrites( false );

-			s_pShaderShadow->EnableAlphaTest( false );

-			s_pShaderShadow->EnableBlending( false );

-

-			s_pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL );

-

-			s_pShaderShadow->SetVertexShader( "depthtodestalpha_vs20", 0 );

-			s_pShaderShadow->SetPixelShader( "depthtodestalpha_ps20b", 0 );

-		}

-		if( s_pShaderAPI )

-		{

-			s_pShaderAPI->SetVertexShaderIndex( 0 );

-			s_pShaderAPI->SetPixelShaderIndex( 0 );

-

-			bMakeActualDrawCall = s_pShaderAPI->ShouldWriteDepthToDestAlpha();

-		}

-		Draw( bMakeActualDrawCall );

-	}

-#else

-	Assert( 0 ); //probably just needs a shader update to the latest

-#endif

-}

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+// This is what all vs/ps (dx8+) shaders inherit from.
+//===========================================================================//
+#if !defined(_STATIC_LINKED) || defined(STDSHADER_DX8_DLL_EXPORT) || defined(STDSHADER_DX9_DLL_EXPORT)
+
+#include "BaseVSShader.h"
+#include "mathlib/vmatrix.h"
+#include "mathlib/bumpvects.h"
+#include "cpp_shader_constant_register_map.h"
+#include "convar.h"
+
+#ifndef GAME_SHADER_DLL
+#ifdef HDR
+#include "vertexlit_and_unlit_generic_hdr_ps20.inc"
+#include "vertexlit_and_unlit_generic_hdr_ps20b.inc"
+#endif
+
+#if SUPPORT_DX8
+#include "lightmappedgeneric_flashlight_vs11.inc"
+#include "flashlight_ps11.inc"
+#endif
+
+#ifdef STDSHADER_DX9_DLL_EXPORT
+#include "lightmappedgeneric_flashlight_vs20.inc"
+#endif
+#ifdef STDSHADER_DX9_DLL_EXPORT
+#include "flashlight_ps20.inc"
+#include "flashlight_ps20b.inc"
+#endif
+#include "unlitgeneric_vs11.inc"
+#include "VertexLitGeneric_EnvmappedBumpmap_NoLighting_ps14.inc"
+#include "VertexLitGeneric_EnvmappedBumpmap_NoLighting.inc"
+#include "vertexlitgeneric_flashlight_vs11.inc"
+#include "LightmappedGeneric_BaseTexture.inc"
+#include "LightmappedGeneric_BumpmappedLightmap_Base_ps14.inc"
+#include "LightmappedGeneric_BumpmappedLightmap_Blend_ps14.inc"
+#include "lightmappedgeneric_bumpmappedenvmap_ps14.inc"
+#include "lightmappedgeneric_bumpmappedenvmap.inc"
+#include "lightmappedgeneric_basetextureblend.inc"
+#include "lightmappedgeneric_bumpmappedlightmap.inc"
+#endif // GAME_SHADER_DLL
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static ConVar mat_fullbright( "mat_fullbright","0", FCVAR_CHEAT );
+
+// These functions are to be called from the shaders.
+
+//-----------------------------------------------------------------------------
+// Pixel and vertex shader constants....
+//-----------------------------------------------------------------------------
+void CBaseVSShader::SetPixelShaderConstant( int pixelReg, int constantVar, int constantVar2 )
+{
+	Assert( !IsSnapshotting() );
+	if ((!s_ppParams) || (constantVar == -1) || (constantVar2 == -1))
+		return;
+
+	IMaterialVar* pPixelVar = s_ppParams[constantVar];
+	Assert( pPixelVar );
+	IMaterialVar* pPixelVar2 = s_ppParams[constantVar2];
+	Assert( pPixelVar2 );
+
+	float val[4];
+	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+	{
+		pPixelVar->GetVecValue( val, 3 );
+	}
+	else
+	{
+		val[0] = val[1] = val[2] = pPixelVar->GetFloatValue();
+	}
+
+	val[3] = pPixelVar2->GetFloatValue();
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	
+}
+
+void CBaseVSShader::SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar, int constantVar2 )
+{
+	Assert( !IsSnapshotting() );
+	if ((!s_ppParams) || (constantVar == -1) || (constantVar2 == -1))
+		return;
+
+	IMaterialVar* pPixelVar = s_ppParams[constantVar];
+	Assert( pPixelVar );
+	IMaterialVar* pPixelVar2 = s_ppParams[constantVar2];
+	Assert( pPixelVar2 );
+
+	float val[4];
+	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+	{
+		pPixelVar->GetVecValue( val, 3 );
+	}
+	else
+	{
+		val[0] = val[1] = val[2] = pPixelVar->GetFloatValue();
+	}
+
+	val[3] = pPixelVar2->GetFloatValue();
+	val[0] = val[0] > 1.0f ? val[0] : GammaToLinear( val[0] );
+	val[1] = val[1] > 1.0f ? val[1] : GammaToLinear( val[1] );
+	val[2] = val[2] > 1.0f ? val[2] : GammaToLinear( val[2] );
+
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	
+}
+
+void CBaseVSShader::SetPixelShaderConstant_W( int pixelReg, int constantVar, float fWValue )
+{
+	Assert( !IsSnapshotting() );
+	if ((!s_ppParams) || (constantVar == -1))
+		return;
+
+	IMaterialVar* pPixelVar = s_ppParams[constantVar];
+	Assert( pPixelVar );
+
+	float val[4];
+	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+		pPixelVar->GetVecValue( val, 4 );
+	else
+		val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue();
+	val[3]=fWValue;
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	
+}
+
+void CBaseVSShader::SetPixelShaderConstant( int pixelReg, int constantVar )
+{
+	Assert( !IsSnapshotting() );
+	if ((!s_ppParams) || (constantVar == -1))
+		return;
+
+	IMaterialVar* pPixelVar = s_ppParams[constantVar];
+	Assert( pPixelVar );
+
+	float val[4];
+	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+		pPixelVar->GetVecValue( val, 4 );
+	else
+		val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue();
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	
+}
+
+void CBaseVSShader::SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar )
+{
+	Assert( !IsSnapshotting() );
+	if ((!s_ppParams) || (constantVar == -1))
+		return;
+
+	IMaterialVar* pPixelVar = s_ppParams[constantVar];
+	Assert( pPixelVar );
+
+	float val[4];
+	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+		pPixelVar->GetVecValue( val, 4 );
+	else
+		val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue();
+
+	val[0] = val[0] > 1.0f ? val[0] : GammaToLinear( val[0] );
+	val[1] = val[1] > 1.0f ? val[1] : GammaToLinear( val[1] );
+	val[2] = val[2] > 1.0f ? val[2] : GammaToLinear( val[2] );
+
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	
+}
+
+void CBaseVSShader::SetVertexShaderConstantGammaToLinear( int var, float const* pVec, int numConst, bool bForce )
+{
+	int i;
+	for( i = 0; i < numConst; i++ )
+	{
+		float vec[4];
+		vec[0] = pVec[i*4+0] > 1.0f ? pVec[i*4+0] : GammaToLinear( pVec[i*4+0] );
+		vec[1] = pVec[i*4+1] > 1.0f ? pVec[i*4+1] : GammaToLinear( pVec[i*4+1] );
+		vec[2] = pVec[i*4+2] > 1.0f ? pVec[i*4+2] : GammaToLinear( pVec[i*4+2] );
+		vec[3] = pVec[i*4+3];
+
+		s_pShaderAPI->SetVertexShaderConstant( var + i, vec, 1, bForce );
+	}
+}
+
+void CBaseVSShader::SetPixelShaderConstantGammaToLinear( int var, float const* pVec, int numConst, bool bForce )
+{
+	int i;
+	for( i = 0; i < numConst; i++ )
+	{
+		float vec[4];
+		vec[0] = pVec[i*4+0] > 1.0f ? pVec[i*4+0] : GammaToLinear( pVec[i*4+0] );
+		vec[1] = pVec[i*4+1] > 1.0f ? pVec[i*4+1] : GammaToLinear( pVec[i*4+1] );
+		vec[2] = pVec[i*4+2] > 1.0f ? pVec[i*4+2] : GammaToLinear( pVec[i*4+2] );
+
+		vec[3] = pVec[i*4+3];
+
+		s_pShaderAPI->SetPixelShaderConstant( var + i, vec, 1, bForce );
+	}
+}
+
+// GR - special version with fix for const/lerp issue
+void CBaseVSShader::SetPixelShaderConstantFudge( int pixelReg, int constantVar )
+{
+	Assert( !IsSnapshotting() );
+	if ((!s_ppParams) || (constantVar == -1))
+		return;
+
+	IMaterialVar* pPixelVar = s_ppParams[constantVar];
+	Assert( pPixelVar );
+
+	float val[4];
+	if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+	{
+		pPixelVar->GetVecValue( val, 4 );
+		val[0] = val[0] * 0.992f + 0.0078f;
+		val[1] = val[1] * 0.992f + 0.0078f;
+		val[2] = val[2] * 0.992f + 0.0078f;
+		val[3] = val[3] * 0.992f + 0.0078f;
+	}
+	else
+		val[0] = val[1] = val[2] = val[3] = pPixelVar->GetFloatValue() * 0.992f + 0.0078f;
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, val );	
+}
+
+void CBaseVSShader::SetVertexShaderConstant( int vertexReg, int constantVar )
+{
+	Assert( !IsSnapshotting() );
+	if ((!s_ppParams) || (constantVar == -1))
+		return;
+
+	IMaterialVar* pVertexVar = s_ppParams[constantVar];
+	Assert( pVertexVar );
+
+	float val[4];
+	if (pVertexVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+		pVertexVar->GetVecValue( val, 4 );
+	else
+		val[0] = val[1] = val[2] = val[3] = pVertexVar->GetFloatValue();
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, val );	
+}
+
+//-----------------------------------------------------------------------------
+// Sets normalized light color for pixel shaders.
+//-----------------------------------------------------------------------------
+void CBaseVSShader::SetPixelShaderLightColors( int pixelReg )
+{
+	int i;
+	int maxLights = s_pShaderAPI->GetMaxLights();
+	for( i = 0; i < maxLights; i++ )
+	{
+		const LightDesc_t & lightDesc = s_pShaderAPI->GetLight( i );
+		if( lightDesc.m_Type != MATERIAL_LIGHT_DISABLE )
+		{
+			Vector color( lightDesc.m_Color[0], lightDesc.m_Color[1], lightDesc.m_Color[2] );
+			VectorNormalize( color );
+			float val[4] = { color[0], color[1], color[2], 1.0f };
+			s_pShaderAPI->SetPixelShaderConstant( pixelReg + i, val, 1 );
+		}
+		else
+		{
+			float zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+			s_pShaderAPI->SetPixelShaderConstant( pixelReg + i, zero, 1 );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets vertex shader texture transforms
+//-----------------------------------------------------------------------------
+void CBaseVSShader::SetVertexShaderTextureTranslation( int vertexReg, int translationVar )
+{
+	float offset[2] = {0, 0};
+
+	IMaterialVar* pTranslationVar = s_ppParams[translationVar];
+	if (pTranslationVar)
+	{
+		if (pTranslationVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+			pTranslationVar->GetVecValue( offset, 2 );
+		else
+			offset[0] = offset[1] = pTranslationVar->GetFloatValue();
+	}
+
+	Vector4D translation[2];
+	translation[0].Init( 1.0f, 0.0f, 0.0f, offset[0] );
+	translation[1].Init( 0.0f, 1.0f, 0.0f, offset[1] );
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, translation[0].Base(), 2 ); 
+}
+
+void CBaseVSShader::SetVertexShaderTextureScale( int vertexReg, int scaleVar )
+{
+	float scale[2] = {1, 1};
+
+	IMaterialVar* pScaleVar = s_ppParams[scaleVar];
+	if (pScaleVar)
+	{
+		if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+			pScaleVar->GetVecValue( scale, 2 );
+		else if (pScaleVar->IsDefined())
+			scale[0] = scale[1] = pScaleVar->GetFloatValue();
+	}
+
+	Vector4D scaleMatrix[2];
+	scaleMatrix[0].Init( scale[0], 0.0f, 0.0f, 0.0f );
+	scaleMatrix[1].Init( 0.0f, scale[1], 0.0f, 0.0f );
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, scaleMatrix[0].Base(), 2 ); 
+}
+
+void CBaseVSShader::SetVertexShaderTextureTransform( int vertexReg, int transformVar )
+{
+	Vector4D transformation[2];
+	IMaterialVar* pTransformationVar = s_ppParams[transformVar];
+	if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))
+	{
+		const VMatrix &mat = pTransformationVar->GetMatrixValue();
+		transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] );
+		transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] );
+	}
+	else
+	{
+		transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f );
+		transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f );
+	}
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, transformation[0].Base(), 2 ); 
+}
+
+void CBaseVSShader::SetVertexShaderTextureScaledTransform( int vertexReg, int transformVar, int scaleVar )
+{
+	Vector4D transformation[2];
+	IMaterialVar* pTransformationVar = s_ppParams[transformVar];
+	if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))
+	{
+		const VMatrix &mat = pTransformationVar->GetMatrixValue();
+		transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] );
+		transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] );
+	}
+	else
+	{
+		transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f );
+		transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f );
+	}
+
+	Vector2D scale( 1, 1 );
+	IMaterialVar* pScaleVar = s_ppParams[scaleVar];
+	if (pScaleVar)
+	{
+		if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+			pScaleVar->GetVecValue( scale.Base(), 2 );
+		else if (pScaleVar->IsDefined())
+			scale[0] = scale[1] = pScaleVar->GetFloatValue();
+	}
+
+	// Apply the scaling
+	transformation[0][0] *= scale[0];
+	transformation[0][1] *= scale[1];
+	transformation[1][0] *= scale[0];
+	transformation[1][1] *= scale[1];
+	transformation[0][3] *= scale[0];
+	transformation[1][3] *= scale[1];
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, transformation[0].Base(), 2 ); 
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets pixel shader texture transforms
+//-----------------------------------------------------------------------------
+void CBaseVSShader::SetPixelShaderTextureTranslation( int pixelReg, int translationVar )
+{
+	float offset[2] = {0, 0};
+
+	IMaterialVar* pTranslationVar = s_ppParams[translationVar];
+	if (pTranslationVar)
+	{
+		if (pTranslationVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+			pTranslationVar->GetVecValue( offset, 2 );
+		else
+			offset[0] = offset[1] = pTranslationVar->GetFloatValue();
+	}
+
+	Vector4D translation[2];
+	translation[0].Init( 1.0f, 0.0f, 0.0f, offset[0] );
+	translation[1].Init( 0.0f, 1.0f, 0.0f, offset[1] );
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, translation[0].Base(), 2 ); 
+}
+
+void CBaseVSShader::SetPixelShaderTextureScale( int pixelReg, int scaleVar )
+{
+	float scale[2] = {1, 1};
+
+	IMaterialVar* pScaleVar = s_ppParams[scaleVar];
+	if (pScaleVar)
+	{
+		if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+			pScaleVar->GetVecValue( scale, 2 );
+		else if (pScaleVar->IsDefined())
+			scale[0] = scale[1] = pScaleVar->GetFloatValue();
+	}
+
+	Vector4D scaleMatrix[2];
+	scaleMatrix[0].Init( scale[0], 0.0f, 0.0f, 0.0f );
+	scaleMatrix[1].Init( 0.0f, scale[1], 0.0f, 0.0f );
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, scaleMatrix[0].Base(), 2 ); 
+}
+
+void CBaseVSShader::SetPixelShaderTextureTransform( int pixelReg, int transformVar )
+{
+	Vector4D transformation[2];
+	IMaterialVar* pTransformationVar = s_ppParams[transformVar];
+	if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))
+	{
+		const VMatrix &mat = pTransformationVar->GetMatrixValue();
+		transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] );
+		transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] );
+	}
+	else
+	{
+		transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f );
+		transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f );
+	}
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, transformation[0].Base(), 2 ); 
+}
+
+void CBaseVSShader::SetPixelShaderTextureScaledTransform( int pixelReg, int transformVar, int scaleVar )
+{
+	Vector4D transformation[2];
+	IMaterialVar* pTransformationVar = s_ppParams[transformVar];
+	if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))
+	{
+		const VMatrix &mat = pTransformationVar->GetMatrixValue();
+		transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] );
+		transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] );
+	}
+	else
+	{
+		transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f );
+		transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f );
+	}
+
+	Vector2D scale( 1, 1 );
+	IMaterialVar* pScaleVar = s_ppParams[scaleVar];
+	if (pScaleVar)
+	{
+		if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR)
+			pScaleVar->GetVecValue( scale.Base(), 2 );
+		else if (pScaleVar->IsDefined())
+			scale[0] = scale[1] = pScaleVar->GetFloatValue();
+	}
+
+	// Apply the scaling
+	transformation[0][0] *= scale[0];
+	transformation[0][1] *= scale[1];
+	transformation[1][0] *= scale[0];
+	transformation[1][1] *= scale[1];
+	transformation[0][3] *= scale[0];
+	transformation[1][3] *= scale[1];
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, transformation[0].Base(), 2 ); 
+}
+
+
+//-----------------------------------------------------------------------------
+// Moves a matrix into vertex shader constants 
+//-----------------------------------------------------------------------------
+void CBaseVSShader::SetVertexShaderMatrix3x4( int vertexReg, int matrixVar )
+{
+	IMaterialVar* pTranslationVar = s_ppParams[matrixVar];
+	if (pTranslationVar)
+	{
+		s_pShaderAPI->SetVertexShaderConstant( vertexReg, &pTranslationVar->GetMatrixValue( )[0][0], 3 ); 
+	}
+	else
+	{
+		VMatrix matrix;
+		MatrixSetIdentity( matrix );
+		s_pShaderAPI->SetVertexShaderConstant( vertexReg, &matrix[0][0], 3 ); 
+	}
+}
+
+void CBaseVSShader::SetVertexShaderMatrix4x4( int vertexReg, int matrixVar )
+{
+	IMaterialVar* pTranslationVar = s_ppParams[matrixVar];
+	if (pTranslationVar)
+	{
+		s_pShaderAPI->SetVertexShaderConstant( vertexReg, &pTranslationVar->GetMatrixValue( )[0][0], 4 ); 
+	}
+	else
+	{
+		VMatrix matrix;
+		MatrixSetIdentity( matrix );
+		s_pShaderAPI->SetVertexShaderConstant( vertexReg, &matrix[0][0], 4 ); 
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the view matrix into pixel shader constants
+//-----------------------------------------------------------------------------
+void CBaseVSShader::LoadViewMatrixIntoVertexShaderConstant( int vertexReg )
+{
+	VMatrix mat, transpose;
+	s_pShaderAPI->GetMatrix( MATERIAL_VIEW, mat.m[0] );
+
+	MatrixTranspose( mat, transpose );
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, transpose.m[0], 3 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the projection matrix into pixel shader constants
+//-----------------------------------------------------------------------------
+void CBaseVSShader::LoadProjectionMatrixIntoVertexShaderConstant( int vertexReg )
+{
+	VMatrix mat, transpose;
+	s_pShaderAPI->GetMatrix( MATERIAL_PROJECTION, mat.m[0] );
+
+	MatrixTranspose( mat, transpose );
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, transpose.m[0], 4 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the projection matrix into pixel shader constants
+//-----------------------------------------------------------------------------
+void CBaseVSShader::LoadModelViewMatrixIntoVertexShaderConstant( int vertexReg )
+{
+	VMatrix view, model, modelView, transpose;
+	s_pShaderAPI->GetMatrix( MATERIAL_MODEL, model.m[0] );
+	MatrixTranspose( model, model );
+	s_pShaderAPI->GetMatrix( MATERIAL_VIEW, view.m[0] );
+	MatrixTranspose( view, view );
+
+	MatrixMultiply( view, model, modelView );
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, modelView.m[0], 3 );
+}
+
+//-----------------------------------------------------------------------------
+// Loads a scale/offset version of the viewport transform into the specified constant.
+//-----------------------------------------------------------------------------
+void CBaseVSShader::LoadViewportTransformScaledIntoVertexShaderConstant( int vertexReg )
+{
+	ShaderViewport_t viewport;
+
+	s_pShaderAPI->GetViewports( &viewport, 1 );
+
+	int bbWidth = 0, 
+		bbHeight = 0;
+
+	s_pShaderAPI->GetBackBufferDimensions( bbWidth, bbHeight );
+
+	// (x, y, z, w) = (Width / bbWidth, Height / bbHeight, MinX / bbWidth, MinY / bbHeight)
+	Vector4D viewportTransform( 
+		1.0f * viewport.m_nWidth / bbWidth,
+		1.0f * viewport.m_nHeight / bbHeight,
+		1.0f * viewport.m_nTopLeftX / bbWidth, 
+		1.0f * viewport.m_nTopLeftY / bbHeight
+	);
+
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, viewportTransform.Base() );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Loads bump lightmap coordinates into the pixel shader
+//-----------------------------------------------------------------------------
+void CBaseVSShader::LoadBumpLightmapCoordinateAxes_PixelShader( int pixelReg )
+{
+	Vector4D basis[3];
+	for (int i = 0; i < 3; ++i)
+	{
+		memcpy( &basis[i], &g_localBumpBasis[i], 3 * sizeof(float) );
+		basis[i][3] = 0.0f;
+	}
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, (float*)basis, 3 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads bump lightmap coordinates into the pixel shader
+//-----------------------------------------------------------------------------
+void CBaseVSShader::LoadBumpLightmapCoordinateAxes_VertexShader( int vertexReg )
+{
+	Vector4D basis[3];
+
+	// transpose
+	int i;
+	for (i = 0; i < 3; ++i)
+	{
+		basis[i][0] = g_localBumpBasis[0][i];
+		basis[i][1] = g_localBumpBasis[1][i];
+		basis[i][2] = g_localBumpBasis[2][i];
+		basis[i][3] = 0.0f;
+	}
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg, (float*)basis, 3 );
+	for (i = 0; i < 3; ++i)
+	{
+		memcpy( &basis[i], &g_localBumpBasis[i], 3 * sizeof(float) );
+		basis[i][3] = 0.0f;
+	}
+	s_pShaderAPI->SetVertexShaderConstant( vertexReg + 3, (float*)basis, 3 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Helper methods for pixel shader overbrighting
+//-----------------------------------------------------------------------------
+void CBaseVSShader::EnablePixelShaderOverbright( int reg, bool bEnable, bool bDivideByTwo )
+{
+	// can't have other overbright values with pixel shaders as it stands.
+	float v[4];
+	if( bEnable )
+	{
+		v[0] = v[1] = v[2] = v[3] = bDivideByTwo ? OVERBRIGHT / 2.0f : OVERBRIGHT;
+	}
+	else
+	{
+		v[0] = v[1] = v[2] = v[3] = bDivideByTwo ? 1.0f / 2.0f : 1.0f;
+	}
+	s_pShaderAPI->SetPixelShaderConstant( reg, v, 1 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Helper for dealing with modulation
+//-----------------------------------------------------------------------------
+void CBaseVSShader::SetModulationVertexShaderDynamicState()
+{
+ 	float color[4] = { 1.0, 1.0, 1.0, 1.0 };
+	ComputeModulationColor( color );
+	s_pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_MODULATION_COLOR, color );
+}
+
+void CBaseVSShader::SetModulationPixelShaderDynamicState( int modulationVar )
+{
+	float color[4] = { 1.0, 1.0, 1.0, 1.0 };
+	ComputeModulationColor( color );
+	s_pShaderAPI->SetPixelShaderConstant( modulationVar, color );
+}
+
+void CBaseVSShader::SetModulationPixelShaderDynamicState_LinearColorSpace( int modulationVar )
+{
+	float color[4] = { 1.0, 1.0, 1.0, 1.0 };
+	ComputeModulationColor( color );
+	color[0] = color[0] > 1.0f ? color[0] : GammaToLinear( color[0] );
+	color[1] = color[1] > 1.0f ? color[1] : GammaToLinear( color[1] );
+	color[2] = color[2] > 1.0f ? color[2] : GammaToLinear( color[2] );
+
+	s_pShaderAPI->SetPixelShaderConstant( modulationVar, color );
+}
+
+void CBaseVSShader::SetModulationPixelShaderDynamicState_LinearColorSpace_LinearScale( int modulationVar, float flScale )
+{
+	float color[4] = { 1.0, 1.0, 1.0, 1.0 };
+	ComputeModulationColor( color );
+	color[0] = ( color[0] > 1.0f ? color[0] : GammaToLinear( color[0] ) ) * flScale;
+	color[1] = ( color[1] > 1.0f ? color[1] : GammaToLinear( color[1] ) ) * flScale;
+	color[2] = ( color[2] > 1.0f ? color[2] : GammaToLinear( color[2] ) ) * flScale;
+
+	s_pShaderAPI->SetPixelShaderConstant( modulationVar, color );
+}
+
+
+//-----------------------------------------------------------------------------
+// Converts a color + alpha into a vector4
+//-----------------------------------------------------------------------------
+void CBaseVSShader::ColorVarsToVector( int colorVar, int alphaVar, Vector4D &color )
+{
+	color.Init( 1.0, 1.0, 1.0, 1.0 ); 
+	if ( colorVar != -1 )
+	{
+		IMaterialVar* pColorVar = s_ppParams[colorVar];
+		if ( pColorVar->GetType() == MATERIAL_VAR_TYPE_VECTOR )
+		{
+			pColorVar->GetVecValue( color.Base(), 3 );
+		}
+		else
+		{
+			color[0] = color[1] = color[2] = pColorVar->GetFloatValue();
+		}
+	}
+	if ( alphaVar != -1 )
+	{
+		float flAlpha = s_ppParams[alphaVar]->GetFloatValue();
+		color[3] = clamp( flAlpha, 0.0f, 1.0f );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets a color + alpha into shader constants
+//-----------------------------------------------------------------------------
+void CBaseVSShader::SetColorVertexShaderConstant( int nVertexReg, int colorVar, int alphaVar )
+{
+	Vector4D color;
+	ColorVarsToVector( colorVar, alphaVar, color );
+	s_pShaderAPI->SetVertexShaderConstant( nVertexReg, color.Base() );
+}
+
+void CBaseVSShader::SetColorPixelShaderConstant( int nPixelReg, int colorVar, int alphaVar )
+{
+	Vector4D color;
+	ColorVarsToVector( colorVar, alphaVar, color );
+	s_pShaderAPI->SetPixelShaderConstant( nPixelReg, color.Base() );
+}
+
+#ifdef _DEBUG
+ConVar mat_envmaptintoverride( "mat_envmaptintoverride", "-1" );
+ConVar mat_envmaptintscale( "mat_envmaptintscale", "-1" );
+#endif
+
+//-----------------------------------------------------------------------------
+// Helpers for dealing with envmap tint
+//-----------------------------------------------------------------------------
+// set alphaVar to -1 to ignore it.
+void CBaseVSShader::SetEnvMapTintPixelShaderDynamicState( int pixelReg, int tintVar, int alphaVar, bool bConvertFromGammaToLinear )
+{
+	float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+	if( g_pConfig->bShowSpecular && mat_fullbright.GetInt() != 2 )
+	{
+		IMaterialVar* pAlphaVar = NULL;
+		if( alphaVar >= 0 )
+		{
+			pAlphaVar = s_ppParams[alphaVar];
+		}
+		if( pAlphaVar )
+		{
+			color[3] = pAlphaVar->GetFloatValue();
+		}
+
+		IMaterialVar* pTintVar = s_ppParams[tintVar];
+#ifdef _DEBUG
+		pTintVar->GetVecValue( color, 3 );
+
+		float envmapTintOverride = mat_envmaptintoverride.GetFloat();
+		float envmapTintScaleOverride = mat_envmaptintscale.GetFloat();
+
+		if( envmapTintOverride != -1.0f )
+		{
+			color[0] = color[1] = color[2] = envmapTintOverride;
+		}
+		if( envmapTintScaleOverride != -1.0f )
+		{
+			color[0] *= envmapTintScaleOverride;
+			color[1] *= envmapTintScaleOverride;
+			color[2] *= envmapTintScaleOverride;
+		}
+
+		if( bConvertFromGammaToLinear )
+		{
+			color[0] = color[0] > 1.0f ? color[0] : GammaToLinear( color[0] );
+			color[1] = color[1] > 1.0f ? color[1] : GammaToLinear( color[1] );
+			color[2] = color[2] > 1.0f ? color[2] : GammaToLinear( color[2] );
+		}
+#else
+		if( bConvertFromGammaToLinear )
+		{
+			pTintVar->GetLinearVecValue( color, 3 );
+		}
+		else
+		{
+			pTintVar->GetVecValue( color, 3 );
+		}
+#endif
+	}
+	else
+	{
+		color[0] = color[1] = color[2] = color[3] = 0.0f;
+	}
+	s_pShaderAPI->SetPixelShaderConstant( pixelReg, color, 1 );
+}
+
+void CBaseVSShader::SetAmbientCubeDynamicStateVertexShader( )
+{
+	s_pShaderAPI->SetVertexShaderStateAmbientLightCube();
+}
+
+float CBaseVSShader::GetAmbientLightCubeLuminance( )
+{
+	return s_pShaderAPI->GetAmbientLightCubeLuminance();
+}
+
+#ifndef GAME_SHADER_DLL
+const char *CBaseVSShader::UnlitGeneric_ComputePixelShaderName( bool bMask,
+																bool bEnvmap,
+																bool bBaseTexture,
+																bool bBaseAlphaEnvmapMask,
+																bool bDetail,
+																bool bDetailMultiplyMode,
+																bool bMaskBaseByDetailAlpha )
+{
+	static char const* s_pPixelShaders[] = 
+	{
+		"UnlitGeneric_NoTexture",
+		"UnlitGeneric",
+		"UnlitGeneric_EnvMapNoTexture",
+		"UnlitGeneric_EnvMap",
+		"UnlitGeneric_NoTexture",
+		"UnlitGeneric",
+		"UnlitGeneric_EnvMapMaskNoTexture",
+		"UnlitGeneric_EnvMapMask",
+
+		// Detail texture
+		// The other commented-out versions are used if we want to
+		// apply the detail *after* the environment map is added
+		"UnlitGeneric_DetailNoTexture",
+		"UnlitGeneric_Detail",
+		"UnlitGeneric_EnvMapNoTexture", //"UnlitGeneric_DetailEnvMapNoTexture",
+		"UnlitGeneric_DetailEnvMap",
+		"UnlitGeneric_DetailNoTexture",
+		"UnlitGeneric_Detail",
+		"UnlitGeneric_EnvMapMaskNoTexture", //"UnlitGeneric_DetailEnvMapMaskNoTexture",
+		"UnlitGeneric_DetailEnvMapMask",
+	};
+
+	// handle hud elements
+	if ( bDetail & bDetailMultiplyMode )
+		return "alphadist_ps11";
+
+	if ( bDetail & bMaskBaseByDetailAlpha )
+		return "UnlitGeneric_MaskBaseByDetailAlpha_ps11";
+
+	if (!bMask && bEnvmap && bBaseTexture && bBaseAlphaEnvmapMask)
+	{
+		if (!bDetail)
+			return "UnlitGeneric_BaseAlphaMaskedEnvMap";
+		else
+			return "UnlitGeneric_DetailBaseAlphaMaskedEnvMap";
+	}
+	else
+	{
+		int pshIndex = 0;
+		if (bBaseTexture)
+			pshIndex |= 0x1;
+		if (bEnvmap)
+			pshIndex |= 0x2;
+		if (bMask)
+			pshIndex |= 0x4;
+		if (bDetail)
+			pshIndex |= 0x8;
+		return s_pPixelShaders[pshIndex];
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets up hw morphing state for the vertex shader
+//-----------------------------------------------------------------------------
+void CBaseVSShader::SetHWMorphVertexShaderState( int nDimConst, int nSubrectConst, VertexTextureSampler_t morphSampler )
+{
+#ifndef _X360
+	if ( !s_pShaderAPI->IsHWMorphingEnabled() )
+		return;
+
+	int nMorphWidth, nMorphHeight;
+	s_pShaderAPI->GetStandardTextureDimensions( &nMorphWidth, &nMorphHeight, TEXTURE_MORPH_ACCUMULATOR );
+
+	int nDim = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_4TUPLE_COUNT );
+	float pMorphAccumSize[4] = { nMorphWidth, nMorphHeight, nDim, 0.0f };
+	s_pShaderAPI->SetVertexShaderConstant( nDimConst, pMorphAccumSize );
+
+	int nXOffset = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_X_OFFSET );
+	int nYOffset = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_Y_OFFSET );
+	int nWidth = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_SUBRECT_WIDTH );
+	int nHeight = s_pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_MORPH_ACCUMULATOR_SUBRECT_HEIGHT );
+	float pMorphAccumSubrect[4] = { nXOffset, nYOffset, nWidth, nHeight };
+	s_pShaderAPI->SetVertexShaderConstant( nSubrectConst, pMorphAccumSubrect );
+
+	s_pShaderAPI->BindStandardVertexTexture( morphSampler, TEXTURE_MORPH_ACCUMULATOR );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Vertex shader unlit generic pass
+//-----------------------------------------------------------------------------
+void CBaseVSShader::VertexShaderUnlitGenericPass( int baseTextureVar, int frameVar, 
+												  int baseTextureTransformVar, 
+												  int detailVar, int detailTransform,
+												  bool bDetailTransformIsScale,
+												  int envmapVar, int envMapFrameVar,
+												  int envmapMaskVar, int envmapMaskFrameVar, 
+												  int envmapMaskScaleVar, int envmapTintVar,
+												  int alphaTestReferenceVar,
+												  int nDetailBlendModeVar,
+												  int nOutlineVar,
+												  int nOutlineColorVar,
+												  int nOutlineStartVar,
+												  int nOutlineEndVar,
+												  int nSeparateDetailUVsVar )
+{
+	IMaterialVar** params = s_ppParams;
+
+	bool bBaseAlphaEnvmapMask = IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK);
+	bool bEnvmap = (envmapVar >= 0) && params[envmapVar]->IsTexture();
+	bool bMask = false;
+	if (bEnvmap && (envmapMaskVar >= 0))
+	{
+		bMask = params[envmapMaskVar]->IsTexture();
+	}
+	bool bDetail = (detailVar >= 0) && params[detailVar]->IsTexture(); 
+	bool bBaseTexture = (baseTextureVar >= 0) && params[baseTextureVar]->IsTexture();
+	bool bVertexColor = IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR);
+	bool bEnvmapCameraSpace = IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE);
+	bool bEnvmapSphere = IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE);
+
+	bool bDetailMultiply = ( nDetailBlendModeVar >= 0 ) && ( params[nDetailBlendModeVar]->GetIntValue() == 8 );
+	bool bMaskBaseByDetailAlpha = ( nDetailBlendModeVar >= 0 ) && ( params[nDetailBlendModeVar]->GetIntValue() == 9 );
+	bool bSeparateDetailUVs = ( nSeparateDetailUVsVar >= 0 ) && ( params[nSeparateDetailUVsVar]->GetIntValue() != 0 );
+
+	if (IsSnapshotting())
+	{
+		// Alpha test
+		s_pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
+
+		if( alphaTestReferenceVar != -1 && params[alphaTestReferenceVar]->GetFloatValue() > 0.0f )
+		{
+			s_pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[alphaTestReferenceVar]->GetFloatValue() );
+		}
+
+		// Base texture on stage 0
+		if (bBaseTexture)
+		{
+			s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		}
+
+		if (bDetail)
+		{
+			s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+		}
+
+		if (bEnvmap)
+		{
+			// envmap on stage 1
+			s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
+
+			// envmapmask on stage 2
+			if (bMask || bBaseAlphaEnvmapMask )
+				s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
+		}
+
+		if (bBaseTexture)
+			SetDefaultBlendingShadowState( baseTextureVar, true );
+		else if (bMask)
+			SetDefaultBlendingShadowState( envmapMaskVar, false );
+		else
+			SetDefaultBlendingShadowState();
+
+		int fmt = VERTEX_POSITION;
+		if( bEnvmap )
+			fmt |= VERTEX_NORMAL;
+		if ( bVertexColor )
+			fmt |= VERTEX_COLOR;
+
+		int numTexCoords = 1;
+		if( bSeparateDetailUVs )
+		{
+			numTexCoords = 2;
+		}
+
+		s_pShaderShadow->VertexShaderVertexFormat( fmt, numTexCoords, 0, 0 );
+		const char *pshName = UnlitGeneric_ComputePixelShaderName(
+			bMask,
+			bEnvmap,
+			bBaseTexture,
+			bBaseAlphaEnvmapMask,
+			bDetail,
+			bDetailMultiply,
+			bMaskBaseByDetailAlpha );
+		s_pShaderShadow->SetPixelShader( pshName );
+
+		// Compute the vertex shader index.
+		unlitgeneric_vs11_Static_Index vshIndex;
+		vshIndex.SetDETAIL( bDetail );
+		vshIndex.SetENVMAP( bEnvmap );
+		vshIndex.SetENVMAPCAMERASPACE( bEnvmap && bEnvmapCameraSpace );
+		vshIndex.SetENVMAPSPHERE( bEnvmap && bEnvmapSphere );
+		vshIndex.SetVERTEXCOLOR( bVertexColor );
+		vshIndex.SetSEPARATEDETAILUVS( bSeparateDetailUVs );
+		s_pShaderShadow->SetVertexShader( "unlitgeneric_vs11", vshIndex.GetIndex() );
+
+		DefaultFog();
+	}
+	else
+	{
+		if ( s_pShaderAPI->InFlashlightMode() ) // Not snapshotting && flashlight pass
+		{
+			Draw( false );
+			return;
+		}
+
+		if (bBaseTexture)
+		{
+			BindTexture( SHADER_SAMPLER0, baseTextureVar, frameVar );
+			SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, baseTextureTransformVar );
+		}
+
+		if (bDetail)
+		{
+			BindTexture( SHADER_SAMPLER3, detailVar, frameVar );
+
+			if (bDetailTransformIsScale)
+			{
+				SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, baseTextureTransformVar, detailTransform );
+			}
+			else
+			{
+				SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, detailTransform );
+			}
+		}
+
+		if (bEnvmap)
+		{
+			BindTexture( SHADER_SAMPLER1, envmapVar, envMapFrameVar );
+
+			if (bMask || bBaseAlphaEnvmapMask)
+			{
+				if (bMask)
+					BindTexture( SHADER_SAMPLER2, envmapMaskVar, envmapMaskFrameVar );
+				else
+					BindTexture( SHADER_SAMPLER2, baseTextureVar, frameVar );
+
+				SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, baseTextureTransformVar, envmapMaskScaleVar );
+			}
+
+			SetEnvMapTintPixelShaderDynamicState( 2, envmapTintVar, -1 );
+
+			if (bEnvmapSphere || IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE))
+			{
+				LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_VIEWMODEL );
+			}
+		}
+
+		SetModulationVertexShaderDynamicState();
+	
+		float flConsts[12]={ 0, 0, 0, 1, 				// color
+			0, 0, 0, 0,					// max
+			0, 0, 0, .5,				// min
+		};
+
+		// set up outline pixel shader constants
+		if ( bDetailMultiply && ( nOutlineVar != -1 ) && ( params[nOutlineVar]->GetIntValue() ) )
+		{
+			if ( nOutlineColorVar != -1 )
+				params[nOutlineColorVar]->GetVecValue( flConsts, 3 );
+			if ( nOutlineEndVar != -1 )
+				flConsts[7] = params[nOutlineEndVar]->GetFloatValue();
+			if ( nOutlineStartVar != -1 )
+				flConsts[11] = params[nOutlineStartVar]->GetFloatValue();
+		}
+
+		s_pShaderAPI->SetPixelShaderConstant( 0, flConsts, 3 );
+
+		// Compute the vertex shader index.
+		unlitgeneric_vs11_Dynamic_Index vshIndex;
+		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+		vshIndex.SetSKINNING( s_pShaderAPI->GetCurrentNumBones() > 0 );
+		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+	}
+
+	Draw();
+}
+
+
+void CBaseVSShader::DrawWorldBaseTexture( int baseTextureVar, int baseTextureTransformVar,
+									int frameVar, int colorVar, int alphaVar )
+{
+	if( IsSnapshotting() )
+	{
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		s_pShaderShadow->VertexShaderVertexFormat( 
+			VERTEX_POSITION, 1, 0, 0 );
+		s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BaseTexture" );
+		SetNormalBlendingShadowState();
+		lightmappedgeneric_basetexture_Static_Index vshIndex;
+		s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BaseTexture", vshIndex.GetIndex() );
+
+		FogToOOOverbright();
+	}
+	else
+	{
+		IMaterialVar** params = s_ppParams;
+		bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE );
+		if( bLightingOnly )
+		{
+			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );
+		}
+		else
+		{
+			BindTexture( SHADER_SAMPLER0, baseTextureVar, frameVar );
+		}
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, baseTextureTransformVar );
+		SetColorPixelShaderConstant( 0, colorVar, alphaVar );
+		lightmappedgeneric_basetexture_Dynamic_Index vshIndex;
+		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+	}
+	Draw();
+}
+
+void CBaseVSShader::DrawWorldBumpedDiffuseLighting( int bumpmapVar, int bumpFrameVar,
+													int bumpTransformVar, bool bMultiply,
+													bool bSSBump )
+{
+	if( IsSnapshotting() )
+	{
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+		if( bMultiply )
+		{
+			s_pShaderShadow->EnableBlending( true );
+			SingleTextureLightmapBlendMode();
+		}
+		s_pShaderShadow->VertexShaderVertexFormat( VERTEX_POSITION, 3, 0, 0 );
+
+		lightmappedgeneric_bumpmappedlightmap_Static_Index vshIndex;
+		s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedLightmap", vshIndex.GetIndex() );
+
+		if ( bSSBump )
+			s_pShaderShadow->SetPixelShader( "LightmappedGeneric_SSBumpmappedLightmap" );
+		else
+			s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedLightmap" );
+			FogToFogColor();
+	}
+	else
+	{
+		if( !g_pConfig->m_bFastNoBump )
+		{
+			BindTexture( SHADER_SAMPLER0, bumpmapVar, bumpFrameVar );
+		}
+		else
+		{
+			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_NORMALMAP_FLAT );
+		}
+		LoadBumpLightmapCoordinateAxes_PixelShader( 0 );
+		s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP_BUMPED );
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, bumpTransformVar );
+		SetModulationPixelShaderDynamicState( 3 );
+
+		lightmappedgeneric_bumpmappedlightmap_Dynamic_Index vshIndex;
+		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+	}
+	Draw();
+}
+
+void CBaseVSShader::DrawWorldBumpedDiffuseLighting_Base_ps14( int bumpmapVar, int bumpFrameVar,
+											  int bumpTransformVar, 
+											  int baseTextureVar, int baseTextureTransformVar, int frameVar )
+{
+	if( IsSnapshotting() )
+	{
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
+		s_pShaderShadow->VertexShaderVertexFormat( VERTEX_POSITION, 3, 0, 0 );
+
+		lightmappedgeneric_bumpmappedlightmap_base_ps14_Static_Index vshIndex;
+		s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedLightmap_Base_ps14", vshIndex.GetIndex() );
+
+		s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedLightmap_Base_ps14" );
+		FogToFogColor();
+	}
+	else
+	{
+		if( !g_pConfig->m_bFastNoBump )
+		{
+			BindTexture( SHADER_SAMPLER0, bumpmapVar, bumpFrameVar );
+		}
+		else
+		{
+			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_NORMALMAP_FLAT );
+		}
+		LoadBumpLightmapCoordinateAxes_PixelShader( 0 );
+		s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP_BUMPED );
+		BindTexture( SHADER_SAMPLER4, baseTextureVar, frameVar );
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, bumpTransformVar );
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, baseTextureTransformVar );
+		SetModulationPixelShaderDynamicState( 3 );
+
+		lightmappedgeneric_bumpmappedlightmap_base_ps14_Dynamic_Index vshIndex;
+		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+	}
+	Draw();
+}
+
+void CBaseVSShader::DrawWorldBumpedDiffuseLighting_Blend_ps14( int bumpmapVar, int bumpFrameVar,
+											int bumpTransformVar,
+											int baseTextureVar, int baseTextureTransformVar, 
+											int baseTextureFrameVar,
+											int baseTexture2Var, int baseTextureTransform2Var, 
+											int baseTextureFrame2Var)
+{
+	if( IsSnapshotting() )
+	{
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
+		s_pShaderShadow->VertexShaderVertexFormat( VERTEX_POSITION, 3, 0, 0 );
+
+		lightmappedgeneric_bumpmappedlightmap_blend_ps14_Static_Index vshIndex;
+		s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedLightmap_Blend_ps14", vshIndex.GetIndex() );
+
+		s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedLightmap_Blend_ps14" );
+		FogToFogColor();
+	}
+	else
+	{
+		if( !g_pConfig->m_bFastNoBump )
+		{
+			BindTexture( SHADER_SAMPLER0, bumpmapVar, bumpFrameVar );
+		}
+		else
+		{
+			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_NORMALMAP_FLAT );
+		}
+		LoadBumpLightmapCoordinateAxes_PixelShader( 0 );
+		s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP_BUMPED );
+		BindTexture( SHADER_SAMPLER4, baseTextureVar, baseTextureFrameVar );
+		BindTexture( SHADER_SAMPLER5, baseTexture2Var, baseTextureFrame2Var );
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, bumpTransformVar );
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, baseTextureTransformVar );
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, baseTextureTransform2Var );
+		SetModulationPixelShaderDynamicState( 3 );
+
+		lightmappedgeneric_bumpmappedlightmap_blend_ps14_Dynamic_Index vshIndex;
+		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+	}
+	Draw();
+}
+
+//#define USE_DEST_ALPHA
+#define USE_NORMALMAP_ALPHA
+
+void CBaseVSShader::DrawWorldBumpedSpecularLighting( int bumpmapVar, int envmapVar,
+											   int bumpFrameVar, int envmapFrameVar,
+											   int envmapTintVar, int alphaVar,
+											   int envmapContrastVar, int envmapSaturationVar,
+											   int bumpTransformVar, int fresnelReflectionVar,
+											   bool bBlend, bool bNoWriteZ )
+{
+	// + BUMPED CUBEMAP
+	if( IsSnapshotting() )
+	{
+		SetInitialShadowState( );
+		if ( bNoWriteZ )
+		{
+			s_pShaderShadow->EnableDepthWrites( false );
+		}
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )
+		{
+			s_pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
+		}
+		if( bBlend )
+		{
+			s_pShaderShadow->EnableBlending( true );
+			s_pShaderShadow->BlendFunc( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE );
+		}
+		// FIXME: Remove the normal (needed for tangent space gen)
+		s_pShaderShadow->VertexShaderVertexFormat( 
+			VERTEX_POSITION | VERTEX_NORMAL | VERTEX_TANGENT_S |
+			VERTEX_TANGENT_T, 1, 0, 0 );
+
+		IMaterialVar** params = s_ppParams;
+		bool bHasNormalMapAlphaEnvMapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK );
+
+		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )
+		{
+			lightmappedgeneric_bumpmappedenvmap_ps14_Static_Index vshIndex;
+			s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedEnvmap_ps14", vshIndex.GetIndex() );
+
+			int nPshIndex = bHasNormalMapAlphaEnvMapMask ? 1 : 0;
+			s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedEnvmap_ps14", nPshIndex );
+		}
+		else
+		{
+			lightmappedgeneric_bumpmappedenvmap_Static_Index vshIndex;
+			s_pShaderShadow->SetVertexShader( "LightmappedGeneric_BumpmappedEnvmap", vshIndex.GetIndex() );
+
+			int nPshIndex = bHasNormalMapAlphaEnvMapMask ? 1 : 0;
+			s_pShaderShadow->SetPixelShader( "LightmappedGeneric_BumpmappedEnvmap", nPshIndex );
+		}
+		FogToBlack();
+	}
+	else
+	{
+		IMaterialVar** params = s_ppParams;
+		s_pShaderAPI->SetDefaultState();
+		BindTexture( SHADER_SAMPLER0, bumpmapVar, bumpFrameVar );
+		BindTexture( SHADER_SAMPLER3, envmapVar, envmapFrameVar );
+
+		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )
+		{
+			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALIZATION_CUBEMAP );
+
+			lightmappedgeneric_bumpmappedenvmap_ps14_Dynamic_Index vshIndex;
+			vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+			s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+		}
+		else
+		{
+			lightmappedgeneric_bumpmappedenvmap_Dynamic_Index vshIndex;
+			vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+			s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+		}
+				
+		SetEnvMapTintPixelShaderDynamicState( 0, envmapTintVar, alphaVar );
+		// GR - fudge consts a bit to fix const/lerp issues
+		SetPixelShaderConstantFudge( 1, envmapContrastVar );
+		SetPixelShaderConstantFudge( 2, envmapSaturationVar );
+		float greyWeights[4] = { 0.299f, 0.587f, 0.114f, 0.0f };
+		s_pShaderAPI->SetPixelShaderConstant( 3, greyWeights );
+
+		// [ 0, 0 ,0, R(0) ]
+		float fresnel[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+		fresnel[3] = params[fresnelReflectionVar]->GetFloatValue();
+		s_pShaderAPI->SetPixelShaderConstant( 4, fresnel );
+		// [ 0, 0 ,0, 1-R(0) ]
+		fresnel[3] = 1.0f - fresnel[3];
+		s_pShaderAPI->SetPixelShaderConstant( 6, fresnel );
+
+		float one[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+		s_pShaderAPI->SetPixelShaderConstant( 5, one );
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, bumpTransformVar );
+	}
+	Draw();
+}
+
+void CBaseVSShader::DrawModelBumpedSpecularLighting( int bumpMapVar, int bumpMapFrameVar,
+											   int envMapVar, int envMapVarFrame,
+											   int envMapTintVar, int alphaVar,
+											   int envMapContrastVar, int envMapSaturationVar,
+											   int bumpTransformVar,
+											   bool bBlendSpecular, bool bNoWriteZ )
+{
+	IMaterialVar** params = s_ppParams;
+	
+	if( IsSnapshotting() )
+	{
+		SetInitialShadowState( );
+		if ( bNoWriteZ )
+		{
+			s_pShaderShadow->EnableDepthWrites( false );
+		}
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )
+		{
+			s_pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
+		}
+		s_pShaderShadow->EnableAlphaTest( false );
+		if( bBlendSpecular )
+		{
+			s_pShaderShadow->EnableBlending( true );
+			SetAdditiveBlendingShadowState( -1, false );
+		}
+		else
+		{
+			s_pShaderShadow->EnableBlending( false );
+			SetNormalBlendingShadowState( -1, false );
+		}
+				
+		s_pShaderShadow->VertexShaderVertexFormat( 
+			VERTEX_POSITION | VERTEX_NORMAL, 1, 0, 4 /* userDataSize */ );
+
+		bool bHasNormalMapAlphaEnvMapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK );
+
+		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )
+		{
+			vertexlitgeneric_envmappedbumpmap_nolighting_ps14_Static_Index vshIndex;
+			s_pShaderShadow->SetVertexShader( "VertexLitGeneric_EnvmappedBumpmap_NoLighting_ps14", vshIndex.GetIndex() );
+			if( bHasNormalMapAlphaEnvMapMask )
+			{
+				s_pShaderShadow->SetPixelShader( "VertexLitGeneric_EnvmappedBumpmapV2_MultByAlpha_ps14" );
+			}
+			else
+			{
+				s_pShaderShadow->SetPixelShader( "VertexLitGeneric_EnvmappedBumpmapV2_ps14" );
+			}
+		}
+		else
+		{
+			vertexlitgeneric_envmappedbumpmap_nolighting_Static_Index vshIndex;
+			s_pShaderShadow->SetVertexShader( "VertexLitGeneric_EnvmappedBumpmap_NoLighting", vshIndex.GetIndex() );
+			// This version does not multiply by lighting
+			// NOTE: We don't support multiplying by lighting for bumped specular stuff.
+			if( bHasNormalMapAlphaEnvMapMask )
+			{
+				s_pShaderShadow->SetPixelShader( "VertexLitGeneric_EnvmappedBumpmapV2_MultByAlpha" );
+			}
+			else
+			{
+				s_pShaderShadow->SetPixelShader( "VertexLitGeneric_EnvmappedBumpmapV2" );
+			}
+		}
+		FogToBlack();
+	}
+	else
+	{
+		s_pShaderAPI->SetDefaultState();
+		BindTexture( SHADER_SAMPLER0, bumpMapVar, bumpMapFrameVar );
+		BindTexture( SHADER_SAMPLER3, envMapVar, envMapVarFrame );
+		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )
+		{
+			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALIZATION_CUBEMAP );
+		}
+				
+		if( bBlendSpecular )
+		{
+			SetEnvMapTintPixelShaderDynamicState( 0, envMapTintVar, -1 );
+		}
+		else
+		{
+			SetEnvMapTintPixelShaderDynamicState( 0, envMapTintVar, alphaVar );
+		}
+		// GR - fudge consts a bit to fix const/lerp issues
+		SetPixelShaderConstantFudge( 1, envMapContrastVar );
+		SetPixelShaderConstantFudge( 2, envMapSaturationVar );
+		float greyWeights[4] = { 0.299f, 0.587f, 0.114f, 0.0f };
+		s_pShaderAPI->SetPixelShaderConstant( 3, greyWeights );
+		
+		// handle scrolling of bump texture
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, bumpTransformVar );
+
+		if( g_pHardwareConfig->SupportsPixelShaders_1_4() )
+		{
+			vertexlitgeneric_envmappedbumpmap_nolighting_ps14_Dynamic_Index vshIndex;
+			vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+			vshIndex.SetSKINNING( s_pShaderAPI->GetCurrentNumBones() > 0 );
+			s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+		}
+		else
+		{
+			vertexlitgeneric_envmappedbumpmap_nolighting_Dynamic_Index vshIndex;
+			vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+			vshIndex.SetSKINNING( s_pShaderAPI->GetCurrentNumBones() > 0 );
+			s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+		}
+	}
+	Draw();
+}
+
+void CBaseVSShader::DrawBaseTextureBlend( int baseTextureVar, int baseTextureTransformVar, 
+									 int baseTextureFrameVar,
+									 int baseTexture2Var, int baseTextureTransform2Var, 
+									 int baseTextureFrame2Var, int colorVar, int alphaVar )
+{
+	if( IsSnapshotting() )
+	{
+		SetInitialShadowState();
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
+		s_pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
+		s_pShaderShadow->DrawFlags( SHADER_DRAW_POSITION | SHADER_DRAW_TEXCOORD0 |
+			SHADER_DRAW_LIGHTMAP_TEXCOORD1 );
+		// FIXME: Remove the normal (needed for tangent space gen)
+		s_pShaderShadow->VertexShaderVertexFormat( 
+			VERTEX_POSITION, 2, 0, 0 );
+
+		lightmappedgeneric_basetextureblend_Static_Index vshIndex;
+		s_pShaderShadow->SetVertexShader( "lightmappedgeneric_basetextureblend", vshIndex.GetIndex() );
+
+		s_pShaderShadow->SetPixelShader( "lightmappedgeneric_basetextureblend", 0 );
+		FogToOOOverbright();
+	}
+	else
+	{
+		IMaterialVar** params = s_ppParams;
+		bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE );
+
+		s_pShaderAPI->SetDefaultState();
+		if( bLightingOnly )
+		{
+			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY );
+			s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );
+		}
+		else
+		{
+			BindTexture( SHADER_SAMPLER0, baseTextureVar, baseTextureFrameVar );
+			BindTexture( SHADER_SAMPLER1, baseTexture2Var, baseTextureFrame2Var );
+		}
+		s_pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_LIGHTMAP );
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, baseTextureTransformVar );
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, baseTextureTransform2Var );
+		SetColorPixelShaderConstant( 0, colorVar, alphaVar );
+		lightmappedgeneric_basetextureblend_Dynamic_Index vshIndex;
+		vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+		s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+	}
+	Draw();
+}
+
+void CBaseVSShader::DrawWorldBumpedUsingVertexShader( int baseTextureVar, int baseTextureTransformVar,
+													  int bumpmapVar, int bumpFrameVar, 
+													  int bumpTransformVar,
+													  int envmapMaskVar, int envmapMaskFrame,
+													  int envmapVar, 
+													  int envmapFrameVar,
+													  int envmapTintVar, int colorVar, int alphaVar,
+													  int envmapContrastVar, int envmapSaturationVar,
+													  int frameVar, int fresnelReflectionVar,
+													  bool doBaseTexture2,
+													  int baseTexture2Var, int baseTextureTransform2Var,
+													  int baseTextureFrame2Var,
+													  bool bSSBump
+												)
+{
+	IMaterialVar** params = s_ppParams;
+	// Draw base texture
+	bool bMultiplyDiffuseLighting = false;
+	bool bBlendSpecular = false;
+	
+	// Draw base texture(s)
+	if( doBaseTexture2 && params[baseTexture2Var]->IsTexture() && params[baseTextureVar]->IsTexture() )
+	{
+		DrawBaseTextureBlend( baseTextureVar, baseTextureTransformVar, frameVar,
+			baseTexture2Var, baseTextureTransform2Var, baseTextureFrame2Var, colorVar, alphaVar );
+		bMultiplyDiffuseLighting = true;
+		bBlendSpecular = true;
+	}
+	else if( params[baseTextureVar]->IsTexture() )
+	{
+		DrawWorldBaseTexture( baseTextureVar, baseTextureTransformVar, frameVar, colorVar, alphaVar );
+		bMultiplyDiffuseLighting = true;
+		bBlendSpecular = true;
+	}
+	else
+	{
+		// Just use color here
+	}
+
+	// Draw diffuse lighting
+	if( params[baseTextureVar]->IsTexture() || !params[envmapVar]->IsTexture() )
+	{
+		DrawWorldBumpedDiffuseLighting( bumpmapVar, bumpFrameVar, bumpTransformVar, 
+			bMultiplyDiffuseLighting, bSSBump );
+		bBlendSpecular = true;
+	}
+
+	// Add specular lighting
+	if( params[envmapVar]->IsTexture() )
+	{
+		DrawWorldBumpedSpecularLighting(
+			bumpmapVar, envmapVar,
+			bumpFrameVar, envmapFrameVar,
+			envmapTintVar, alphaVar,
+			envmapContrastVar, envmapSaturationVar,
+			bumpTransformVar, fresnelReflectionVar,
+			bBlendSpecular );
+	}
+}
+#endif // GAME_SHADER_DLL
+
+
+//-----------------------------------------------------------------------------
+// GR - translucency query
+//-----------------------------------------------------------------------------
+BlendType_t CBaseVSShader::EvaluateBlendRequirements( int textureVar, bool isBaseTexture,
+													  int detailTextureVar )
+{
+	// Either we've got a constant modulation
+	bool isTranslucent = IsAlphaModulating();
+
+	// Or we've got a vertex alpha
+	isTranslucent = isTranslucent || (CurrentMaterialVarFlags() & MATERIAL_VAR_VERTEXALPHA);
+
+	// Or we've got a texture alpha (for blending or alpha test)
+	isTranslucent = isTranslucent || ( TextureIsTranslucent( textureVar, isBaseTexture ) &&
+		                               !(CurrentMaterialVarFlags() & MATERIAL_VAR_ALPHATEST ) );
+
+	if ( ( detailTextureVar != -1 ) && ( ! isTranslucent ) )
+	{
+		isTranslucent = TextureIsTranslucent( detailTextureVar, isBaseTexture );
+	}
+
+	if ( CurrentMaterialVarFlags() & MATERIAL_VAR_ADDITIVE )
+	{	
+		return isTranslucent ? BT_BLENDADD : BT_ADD;	// Additive
+	}
+	else
+	{
+		return isTranslucent ? BT_BLEND : BT_NONE;		// Normal blending
+	}
+}
+
+#ifndef GAME_SHADER_DLL
+
+void CBaseVSShader::SetFlashlightVertexShaderConstants( bool bBump, int bumpTransformVar, bool bDetail, int detailScaleVar, bool bSetTextureTransforms )
+{
+	Assert( !IsSnapshotting() );
+
+	VMatrix worldToTexture;
+	const FlashlightState_t &flashlightState = s_pShaderAPI->GetFlashlightState( worldToTexture );
+
+	// Set the flashlight origin
+	float pos[4];
+	pos[0] = flashlightState.m_vecLightOrigin[0];
+	pos[1] = flashlightState.m_vecLightOrigin[1];
+	pos[2] = flashlightState.m_vecLightOrigin[2];
+	pos[3] = 1.0f / ( ( 0.6f * flashlightState.m_FarZ ) - flashlightState.m_FarZ );		// DX8 needs this
+
+	s_pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, pos, 1 );
+
+	s_pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, worldToTexture.Base(), 4 );
+
+	// Set the flashlight attenuation factors
+	float atten[4];
+	atten[0] = flashlightState.m_fConstantAtten;
+	atten[1] = flashlightState.m_fLinearAtten;
+	atten[2] = flashlightState.m_fQuadraticAtten;
+	atten[3] = flashlightState.m_FarZ;
+	s_pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, atten, 1 );
+
+	if ( bDetail )
+	{
+		SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_8, BASETEXTURETRANSFORM, detailScaleVar );
+	}
+
+	if( bSetTextureTransforms )
+	{
+		SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, BASETEXTURETRANSFORM );
+		if( !bDetail && bBump && bumpTransformVar != -1 )
+		{
+			SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_8, bumpTransformVar ); // aliased on top of detail transform
+		}
+	}
+}
+
+#if SUPPORT_DX8
+void CBaseVSShader::DrawFlashlight_dx80( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bBump,
+										int bumpmapVar, int bumpmapFrame, int bumpTransform, int flashlightTextureVar, int flashlightTextureFrameVar,
+										bool bLightmappedGeneric, bool bWorldVertexTransition, int nWorldVertexTransitionPassID, int baseTexture2Var,
+										int baseTexture2FrameVar, bool bTeeth, int nTeethForwardVar, int nTeethIllumFactorVar )
+{
+	// FLASHLIGHTFIXME: hack . . need to fix the vertex shader so that it can deal with and without bumps for vertexlitgeneric
+	if( !bLightmappedGeneric )
+	{
+		bBump = false;
+	}
+	if( pShaderShadow )
+	{
+		SetInitialShadowState();
+		pShaderShadow->EnableDepthWrites( false );
+
+		// Be sure not to write to dest alpha
+		pShaderShadow->EnableAlphaWrites( false );
+
+		// Never alpha test the flashlight pass
+		pShaderShadow->EnableAlphaTest( false );
+
+		if ( IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) )
+		{
+			// use zfunc zequals since alpha isn't guaranteed to 
+			// be the same on both the regular pass and the flashlight pass.
+			pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL );
+		}
+
+		// Alpha blend
+		if( bWorldVertexTransition )
+		{
+			// use separate alpha blend to make sure that we aren't adding alpha from source
+			if( nWorldVertexTransitionPassID == 0 )
+			{
+				EnableAlphaBlending( SHADER_BLEND_DST_ALPHA, SHADER_BLEND_ONE );
+			}
+			else
+			{
+				EnableAlphaBlending( SHADER_BLEND_ONE_MINUS_DST_ALPHA, SHADER_BLEND_ONE );
+			}
+		}
+		else
+		{
+			SetAdditiveBlendingShadowState( BASETEXTURE, true );
+		}
+		
+		pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
+		pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
+		pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+
+		if( bLightmappedGeneric )
+		{
+			bool bUsingVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
+			lightmappedgeneric_flashlight_vs11_Static_Index	vshIndex;
+			vshIndex.SetNORMALMAP( bBump );
+			vshIndex.SetWORLDVERTEXTRANSITION( bWorldVertexTransition );
+			vshIndex.SetVERTEXCOLOR( bUsingVertexColor );
+			pShaderShadow->SetVertexShader( "lightmappedgeneric_flashlight_vs11", vshIndex.GetIndex() );
+
+			unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
+			if( bBump )
+			{
+				flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T;
+			}
+			if ( bWorldVertexTransition || bUsingVertexColor )
+			{
+				flags |= VERTEX_COLOR;
+			}
+			pShaderShadow->VertexShaderVertexFormat( flags, 1, 0, 0 );
+		}
+		else
+		{
+			vertexlitgeneric_flashlight_vs11_Static_Index vshIndex;
+			vshIndex.SetTEETH( bTeeth );
+			pShaderShadow->SetVertexShader( "vertexlitgeneric_flashlight_vs11", vshIndex.GetIndex() );
+
+			unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
+			pShaderShadow->VertexShaderVertexFormat( flags, 1, 0, bBump ? 4 : 0 );
+		}
+
+		bool bNoCull = IS_FLAG_SET( MATERIAL_VAR_NOCULL );
+
+		flashlight_ps11_Static_Index	pshIndex;
+		pshIndex.SetNORMALMAP( bBump );
+		pshIndex.SetNOCULL( bNoCull );
+		pShaderShadow->SetPixelShader( "flashlight_ps11", pshIndex.GetIndex() );
+
+		FogToBlack();
+	}
+	else
+	{
+		// Specify that we have XYZ texcoords that need to be divided by W before the pixel shader.
+		// NOTE Tried to divide XY by Z, but doesn't work.
+		// The dx9.0c runtime says that we shouldn't have a non-zero dimension when using vertex and pixel shaders.
+		pShaderAPI->SetTextureTransformDimension( SHADER_TEXTURE_STAGE0, 0, true );
+		BindTexture( SHADER_SAMPLER0, flashlightTextureVar, flashlightTextureFrameVar );
+
+		if( bWorldVertexTransition && ( nWorldVertexTransitionPassID == 1 ) )
+		{
+			BindTexture( SHADER_SAMPLER1, baseTexture2Var, baseTexture2FrameVar );
+		}
+		else
+		{
+			if( params[BASETEXTURE]->IsTexture() )
+			{
+				BindTexture( SHADER_SAMPLER1, BASETEXTURE, FRAME );
+			}
+			else
+			{
+				pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );
+			}
+		}
+		pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_NORMALIZATION_CUBEMAP );
+		if( bBump )
+		{
+			BindTexture( SHADER_SAMPLER3, bumpmapVar, bumpmapFrame );
+		}
+		else
+		{
+			pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALIZATION_CUBEMAP );
+		}
+
+		if( bLightmappedGeneric )
+		{
+			lightmappedgeneric_flashlight_vs11_Dynamic_Index vshIndex;
+			vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+			pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+		}
+		else
+		{
+			vertexlitgeneric_flashlight_vs11_Dynamic_Index vshIndex;
+			vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+
+			if( bTeeth )
+			{
+				Assert( nTeethForwardVar >= 0 );
+				Assert( nTeethIllumFactorVar >= 0 );
+				Vector4D lighting;
+				params[nTeethForwardVar]->GetVecValue( lighting.Base(), 3 );
+				lighting[3] = params[nTeethIllumFactorVar]->GetFloatValue();
+				pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, lighting.Base() );
+			}
+
+			vshIndex.SetSKINNING( pShaderAPI->GetCurrentNumBones() > 0 );
+			pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+		}
+
+		flashlight_ps11_Dynamic_Index pshIndex;
+		pShaderAPI->SetPixelShaderIndex( pshIndex.GetIndex() );
+
+		SetFlashlightVertexShaderConstants( bBump, bumpTransform, false, -1, true );
+	}
+	Draw();
+}
+#endif // support_dx8
+
+#ifdef STDSHADER_DX9_DLL_EXPORT
+void CBaseVSShader::DrawFlashlight_dx90( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, 
+										IShaderShadow* pShaderShadow, DrawFlashlight_dx90_Vars_t &vars )
+{
+	// FLASHLIGHTFIXME: hack . . need to fix the vertex shader so that it can deal with and without bumps for vertexlitgeneric
+	if( !vars.m_bLightmappedGeneric )
+	{
+		vars.m_bBump = false;
+	}
+	bool bBump2 = vars.m_bWorldVertexTransition && vars.m_bBump && vars.m_nBumpmap2Var != -1 && params[vars.m_nBumpmap2Var]->IsTexture();
+	bool bSeamless = vars.m_fSeamlessScale != 0.0;
+	bool bDetail = vars.m_bLightmappedGeneric && (vars.m_nDetailVar != -1) && params[vars.m_nDetailVar]->IsDefined() && (vars.m_nDetailScale != -1);
+
+	int nDetailBlendMode = 0;
+	if ( bDetail )
+	{
+		nDetailBlendMode = GetIntParam( vars.m_nDetailTextureCombineMode, params );
+		nDetailBlendMode = nDetailBlendMode > 1 ? 1 : nDetailBlendMode;
+	}
+
+	if( pShaderShadow )
+	{
+		SetInitialShadowState();
+		pShaderShadow->EnableDepthWrites( false );
+		pShaderShadow->EnableAlphaWrites( false );
+
+		// Alpha blend
+		SetAdditiveBlendingShadowState( BASETEXTURE, true );
+
+		// Alpha test
+		pShaderShadow->EnableAlphaTest( IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) );
+		if ( vars.m_nAlphaTestReference != -1 && params[vars.m_nAlphaTestReference]->GetFloatValue() > 0.0f )
+		{
+			pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[vars.m_nAlphaTestReference]->GetFloatValue() );
+		}
+
+		// Spot sampler
+		pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
+		pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
+
+		// Base sampler
+		pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
+		pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );
+
+		// Normalizing cubemap sampler
+		pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
+
+		// Normalizing cubemap sampler2 or normal map sampler
+		pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
+
+		// RandomRotation sampler
+		pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
+
+		// Flashlight depth sampler
+		pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
+		pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER7 );
+
+		if( vars.m_bWorldVertexTransition )
+		{
+			// $basetexture2
+			pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
+			pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
+		}
+		if( bBump2 )
+		{
+			// Normalmap2 sampler
+			pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
+		}
+		if( bDetail )
+		{
+			pShaderShadow->EnableTexture( SHADER_SAMPLER8, true );				// detail sampler
+			if ( nDetailBlendMode != 0 ) //Not Mod2X
+				pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, true );
+		}
+		
+		pShaderShadow->EnableSRGBWrite( true );
+
+		if( vars.m_bLightmappedGeneric )
+		{
+			lightmappedgeneric_flashlight_vs20_Static_Index	vshIndex;
+			vshIndex.SetWORLDVERTEXTRANSITION( vars.m_bWorldVertexTransition );
+			vshIndex.SetNORMALMAP( vars.m_bBump );
+			vshIndex.SetSEAMLESS( bSeamless );
+			vshIndex.SetDETAIL( bDetail );
+			pShaderShadow->SetVertexShader( "lightmappedgeneric_flashlight_vs20", vshIndex.GetIndex() );
+
+			unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
+			if( vars.m_bBump )
+			{
+				flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T;
+			}
+			int numTexCoords = 1;
+			if( vars.m_bWorldVertexTransition )
+			{
+				flags |= VERTEX_COLOR;
+				numTexCoords = 2; // need lightmap texcoords to get alpha.
+			}
+			pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, 0 );
+		}
+		else
+		{
+			vertexlitgeneric_flashlight_vs11_Static_Index vshIndex;
+			vshIndex.SetTEETH( vars.m_bTeeth );
+			pShaderShadow->SetVertexShader( "vertexlitgeneric_flashlight_vs11", vshIndex.GetIndex() );
+
+			unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
+			int numTexCoords = 1;
+			pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, vars.m_bBump ? 4 : 0 );
+		}
+
+		int nBumpMapVariant = 0;
+		if ( vars.m_bBump )
+		{
+			nBumpMapVariant = ( vars.m_bSSBump ) ? 2 : 1;
+		}
+		if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
+		{
+			int nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode();
+
+			flashlight_ps20b_Static_Index	pshIndex;
+			pshIndex.SetNORMALMAP( nBumpMapVariant );
+			pshIndex.SetNORMALMAP2( bBump2 );
+			pshIndex.SetWORLDVERTEXTRANSITION( vars.m_bWorldVertexTransition );
+			pshIndex.SetSEAMLESS( bSeamless );
+			pshIndex.SetDETAILTEXTURE( bDetail );
+			pshIndex.SetDETAIL_BLEND_MODE( nDetailBlendMode );
+			pshIndex.SetFLASHLIGHTDEPTHFILTERMODE( nShadowFilterMode );
+			pShaderShadow->SetPixelShader( "flashlight_ps20b", pshIndex.GetIndex() );
+		}
+		else
+		{
+			flashlight_ps20_Static_Index	pshIndex;
+			pshIndex.SetNORMALMAP( nBumpMapVariant );
+			pshIndex.SetNORMALMAP2( bBump2 );
+			pshIndex.SetWORLDVERTEXTRANSITION( vars.m_bWorldVertexTransition );
+			pshIndex.SetSEAMLESS( bSeamless );
+			pshIndex.SetDETAILTEXTURE( bDetail );
+			pshIndex.SetDETAIL_BLEND_MODE( nDetailBlendMode );
+			pShaderShadow->SetPixelShader( "flashlight_ps20", pshIndex.GetIndex() );
+		}
+		FogToBlack();
+	}
+	else
+	{
+		VMatrix worldToTexture;
+		ITexture *pFlashlightDepthTexture;
+		FlashlightState_t flashlightState = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );
+
+		SetFlashLightColorFromState( flashlightState, pShaderAPI );
+
+		BindTexture( SHADER_SAMPLER0, flashlightState.m_pSpotlightTexture, flashlightState.m_nSpotlightTextureFrame );
+
+		if( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() && flashlightState.m_bEnableShadows )
+		{
+			BindTexture( SHADER_SAMPLER7, pFlashlightDepthTexture, 0 );
+			pShaderAPI->BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SHADOW_NOISE_2D );
+
+			// Tweaks associated with a given flashlight
+			float tweaks[4];
+			tweaks[0] = ShadowFilterFromState( flashlightState );
+			tweaks[1] = ShadowAttenFromState( flashlightState );
+			HashShadow2DJitter( flashlightState.m_flShadowJitterSeed, &tweaks[2], &tweaks[3] );
+			pShaderAPI->SetPixelShaderConstant( PSREG_ENVMAP_TINT__SHADOW_TWEAKS, tweaks, 1 );
+
+			// Dimensions of screen, used for screen-space noise map sampling
+			float vScreenScale[4] = {1280.0f / 32.0f, 720.0f / 32.0f, 0, 0};
+			int nWidth, nHeight;
+			pShaderAPI->GetBackBufferDimensions( nWidth, nHeight );
+			vScreenScale[0] = (float) nWidth  / 32.0f;
+			vScreenScale[1] = (float) nHeight / 32.0f;
+			pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_SCREEN_SCALE, vScreenScale, 1 );
+		}
+
+		if( params[BASETEXTURE]->IsTexture() && mat_fullbright.GetInt() != 2 )
+		{
+			BindTexture( SHADER_SAMPLER1, BASETEXTURE, FRAME );
+		}
+		else
+		{
+			pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );
+		}
+		if( vars.m_bWorldVertexTransition )
+		{
+			Assert( vars.m_nBaseTexture2Var >= 0 && vars.m_nBaseTexture2FrameVar >= 0 );
+			BindTexture( SHADER_SAMPLER4, vars.m_nBaseTexture2Var, vars.m_nBaseTexture2FrameVar );
+		}
+		pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_NORMALIZATION_CUBEMAP );
+		if( vars.m_bBump )
+		{
+			BindTexture( SHADER_SAMPLER3, vars.m_nBumpmapVar, vars.m_nBumpmapFrame );
+		}
+		else
+		{
+			pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALIZATION_CUBEMAP );
+		}
+
+		if( bDetail )
+		{
+			BindTexture( SHADER_SAMPLER8, vars.m_nDetailVar );
+		}
+
+		if( vars.m_bWorldVertexTransition )
+		{
+			if( bBump2 )
+			{
+				BindTexture( SHADER_SAMPLER6, vars.m_nBumpmap2Var, vars.m_nBumpmap2Frame );
+			}
+		}
+
+		if( vars.m_bLightmappedGeneric )
+		{
+			DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs20 );
+			SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+			SET_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_flashlight_vs20 );
+			if ( bSeamless )
+			{
+				float const0[4]={ vars.m_fSeamlessScale,0,0,0};
+				pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, const0 );
+			}
+
+			if ( bDetail )
+			{
+				float vDetailConstants[4] = {1,1,1,1};
+
+				if ( vars.m_nDetailTint != -1 )
+				{
+					params[vars.m_nDetailTint]->GetVecValue( vDetailConstants, 3 );
+				}
+
+				if ( vars.m_nDetailTextureBlendFactor != -1 )
+				{
+					vDetailConstants[3] = params[vars.m_nDetailTextureBlendFactor]->GetFloatValue();
+				}
+
+				pShaderAPI->SetPixelShaderConstant( 0, vDetailConstants, 1 );
+			}
+		}
+		else
+		{
+			vertexlitgeneric_flashlight_vs11_Dynamic_Index vshIndex;
+			vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
+			vshIndex.SetSKINNING( pShaderAPI->GetCurrentNumBones() > 0 );
+			pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
+
+			if( vars.m_bTeeth )
+			{
+				Assert( vars.m_nTeethForwardVar >= 0 );
+				Assert( vars.m_nTeethIllumFactorVar >= 0 );
+				Vector4D lighting;
+				params[vars.m_nTeethForwardVar]->GetVecValue( lighting.Base(), 3 );
+				lighting[3] = params[vars.m_nTeethIllumFactorVar]->GetFloatValue();
+				pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, lighting.Base() );
+			}
+		}
+
+		pShaderAPI->SetPixelShaderFogParams( PSREG_FOG_PARAMS );
+
+		float vEyePos_SpecExponent[4];
+		pShaderAPI->GetWorldSpaceCameraPosition( vEyePos_SpecExponent );
+		vEyePos_SpecExponent[3] = 0.0f;
+		pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vEyePos_SpecExponent, 1 );
+
+		if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
+		{
+			DECLARE_DYNAMIC_PIXEL_SHADER( flashlight_ps20b );
+			SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE,  pShaderAPI->GetPixelFogCombo() );
+			SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, flashlightState.m_bEnableShadows && ( pFlashlightDepthTexture != NULL ) );
+			SET_DYNAMIC_PIXEL_SHADER( flashlight_ps20b );
+		}
+		else
+		{
+			DECLARE_DYNAMIC_PIXEL_SHADER( flashlight_ps20 );
+			SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE,  pShaderAPI->GetPixelFogCombo() );
+			SET_DYNAMIC_PIXEL_SHADER( flashlight_ps20 );
+		}
+
+		float atten[4];										// Set the flashlight attenuation factors
+		atten[0] = flashlightState.m_fConstantAtten;
+		atten[1] = flashlightState.m_fLinearAtten;
+		atten[2] = flashlightState.m_fQuadraticAtten;
+		atten[3] = flashlightState.m_FarZ;
+		s_pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, atten, 1 );
+
+		SetFlashlightVertexShaderConstants( vars.m_bBump, vars.m_nBumpTransform, bDetail, vars.m_nDetailScale,  bSeamless ? false : true );
+	}
+	Draw();
+}
+
+#endif
+
+void CBaseVSShader::InitParamsUnlitGeneric_DX8(
+		int baseTextureVar,
+		int detailScaleVar,
+		int envmapOptionalVar,
+		int envmapVar,
+		int envmapTintVar, 
+		int envmapMaskScaleVar,
+		int nDetailBlendMode )
+{
+	IMaterialVar** params = s_ppParams;
+
+	SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING );
+
+	if( envmapTintVar >= 0 && !params[envmapTintVar]->IsDefined() )
+	{
+		params[envmapTintVar]->SetVecValue( 1.0f, 1.0f, 1.0f );
+	}
+
+	if( envmapMaskScaleVar >= 0 && !params[envmapMaskScaleVar]->IsDefined() )
+	{
+		params[envmapMaskScaleVar]->SetFloatValue( 1.0f );
+	}
+
+	if( detailScaleVar >= 0 && !params[detailScaleVar]->IsDefined() )
+	{
+		params[detailScaleVar]->SetFloatValue( 4.0f );
+	}
+
+	// No texture means no self-illum or env mask in base alpha
+	if ( baseTextureVar >= 0 && !params[baseTextureVar]->IsDefined() )
+	{
+		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 );
+	}
+
+	// Get rid of the envmap if it's optional for this dx level.
+	if( envmapOptionalVar >= 0 && params[envmapOptionalVar]->IsDefined() && params[envmapOptionalVar]->GetIntValue() )
+	{
+		if (envmapVar >= 0)
+		{
+			params[envmapVar]->SetUndefined();
+		}
+	}
+
+	// If mat_specular 0, then get rid of envmap
+	if( envmapVar >= 0 && baseTextureVar >= 0 && !g_pConfig->UseSpecular() && params[envmapVar]->IsDefined() && params[baseTextureVar]->IsDefined() )
+	{
+		params[envmapVar]->SetUndefined();
+	}
+}
+
+void CBaseVSShader::InitUnlitGeneric_DX8(
+		int baseTextureVar,
+		int detailVar,
+		int envmapVar,
+		int envmapMaskVar )
+{
+	IMaterialVar** params = s_ppParams;
+
+	if (baseTextureVar >= 0 && params[baseTextureVar]->IsDefined())
+	{
+		LoadTexture( baseTextureVar );
+
+		if (!params[baseTextureVar]->GetTextureValue()->IsTranslucent())
+		{
+			if (IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK))
+				CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK );
+		}
+	}
+
+	// Don't alpha test if the alpha channel is used for other purposes
+	if ( IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) )
+		CLEAR_FLAGS( MATERIAL_VAR_ALPHATEST );
+
+	// the second texture (if there is one)
+	if (detailVar >= 0 && params[detailVar]->IsDefined())
+	{
+		LoadTexture( detailVar );
+	}
+
+	if (envmapVar >= 0 && params[envmapVar]->IsDefined())
+	{
+		if( !IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) )
+			LoadCubeMap( envmapVar );
+		else
+			LoadTexture( envmapVar );
+
+		if( !g_pHardwareConfig->SupportsCubeMaps() )
+			SET_FLAGS(MATERIAL_VAR_ENVMAPSPHERE);
+
+		if (envmapMaskVar >= 0 && params[envmapMaskVar]->IsDefined())
+			LoadTexture( envmapMaskVar );
+	}
+}
+#endif // GAME_SHADER_DLL
+
+#endif // !_STATIC_LINKED || STDSHADER_DX8_DLL_EXPORT
+
+
+// Take 0..1 seed and map to (u, v) coordinate to be used in shadow filter jittering...
+void CBaseVSShader::HashShadow2DJitter( const float fJitterSeed, float *fU, float* fV )
+{
+	const int nTexRes = 32;
+	int nSeed = fmod (fJitterSeed, 1.0f) * nTexRes * nTexRes;
+
+	int nRow = nSeed / nTexRes;
+	int nCol = nSeed % nTexRes;
+
+	// Div and mod to get an individual texel in the fTexRes x fTexRes grid
+	*fU = nRow / (float) nTexRes;	// Row
+	*fV = nCol / (float) nTexRes;	// Column
+}
+
+
+void CBaseVSShader::DrawEqualDepthToDestAlpha( void )
+{
+#ifdef STDSHADER_DX9_DLL_EXPORT
+	if( g_pHardwareConfig->SupportsPixelShaders_2_b() )
+	{
+		bool bMakeActualDrawCall = false;
+		if( s_pShaderShadow )
+		{
+			s_pShaderShadow->EnableColorWrites( false );
+			s_pShaderShadow->EnableAlphaWrites( true );
+			s_pShaderShadow->EnableDepthWrites( false );
+			s_pShaderShadow->EnableAlphaTest( false );
+			s_pShaderShadow->EnableBlending( false );
+
+			s_pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL );
+
+			s_pShaderShadow->SetVertexShader( "depthtodestalpha_vs20", 0 );
+			s_pShaderShadow->SetPixelShader( "depthtodestalpha_ps20b", 0 );
+		}
+		if( s_pShaderAPI )
+		{
+			s_pShaderAPI->SetVertexShaderIndex( 0 );
+			s_pShaderAPI->SetPixelShaderIndex( 0 );
+
+			bMakeActualDrawCall = s_pShaderAPI->ShouldWriteDepthToDestAlpha();
+		}
+		Draw( bMakeActualDrawCall );
+	}
+#else
+	Assert( 0 ); //probably just needs a shader update to the latest
+#endif
+}