diff options
Diffstat (limited to 'mp/src/materialsystem/stdshaders')
33 files changed, 9711 insertions, 0 deletions
diff --git a/mp/src/materialsystem/stdshaders/BaseVSShader.cpp b/mp/src/materialsystem/stdshaders/BaseVSShader.cpp new file mode 100644 index 00000000..ba1f6e15 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/BaseVSShader.cpp @@ -0,0 +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
+}
diff --git a/mp/src/materialsystem/stdshaders/BaseVSShader.h b/mp/src/materialsystem/stdshaders/BaseVSShader.h new file mode 100644 index 00000000..2a38afb1 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/BaseVSShader.h @@ -0,0 +1,439 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+// This is what all vs/ps (dx8+) shaders inherit from.
+//===========================================================================//
+
+#ifndef BASEVSSHADER_H
+#define BASEVSSHADER_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "shaderlib/cshader.h"
+#include "shaderlib/BaseShader.h"
+#include "convar.h"
+#include <renderparm.h>
+
+#ifdef _X360
+#define SUPPORT_DX8 0
+#define SUPPORT_DX7 0
+#else
+#define SUPPORT_DX8 1
+#define SUPPORT_DX7 1
+#endif
+//-----------------------------------------------------------------------------
+// Helper macro for vertex shaders
+//-----------------------------------------------------------------------------
+#define BEGIN_VS_SHADER_FLAGS(_name, _help, _flags) __BEGIN_SHADER_INTERNAL( CBaseVSShader, _name, _help, _flags )
+#define BEGIN_VS_SHADER(_name,_help) __BEGIN_SHADER_INTERNAL( CBaseVSShader, _name, _help, 0 )
+
+
+// useful parameter initialization macro
+#define INIT_FLOAT_PARM( parm, value ) \
+ if ( !params[(parm)]->IsDefined() ) \
+ { \
+ params[(parm)]->SetFloatValue( (value) ); \
+ }
+
+// useful pixel shader declaration macro for ps20/20b c++ code
+#define SET_STATIC_PS2X_PIXEL_SHADER_NO_COMBOS( basename ) \
+ if( g_pHardwareConfig->SupportsPixelShaders_2_b() ) \
+ { \
+ DECLARE_STATIC_PIXEL_SHADER( basename##_ps20b ); \
+ SET_STATIC_PIXEL_SHADER( basename##_ps20b ); \
+ } \
+ else \
+ { \
+ DECLARE_STATIC_PIXEL_SHADER( basename##_ps20 ); \
+ SET_STATIC_PIXEL_SHADER( basename##_ps20 ); \
+ }
+
+#define SET_DYNAMIC_PS2X_PIXEL_SHADER_NO_COMBOS( basename ) \
+ if( g_pHardwareConfig->SupportsPixelShaders_2_b() ) \
+ { \
+ DECLARE_DYNAMIC_PIXEL_SHADER( basename##_ps20b ); \
+ SET_DYNAMIC_PIXEL_SHADER( basename##_ps20b ); \
+ } \
+ else \
+ { \
+ DECLARE_DYNAMIC_PIXEL_SHADER( basename##_ps20 ); \
+ SET_DYNAMIC_PIXEL_SHADER( basename##_ps20 ); \
+ }
+
+
+//-----------------------------------------------------------------------------
+// Base class for shaders, contains helper methods.
+//-----------------------------------------------------------------------------
+class CBaseVSShader : public CBaseShader
+{
+public:
+
+ // Loads bump lightmap coordinates into the pixel shader
+ void LoadBumpLightmapCoordinateAxes_PixelShader( int pixelReg );
+
+ // Loads bump lightmap coordinates into the vertex shader
+ void LoadBumpLightmapCoordinateAxes_VertexShader( int vertexReg );
+
+ // Pixel and vertex shader constants....
+ void SetPixelShaderConstant( int pixelReg, int constantVar );
+
+ // Pixel and vertex shader constants....
+ void SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar );
+
+ // This version will put constantVar into x,y,z, and constantVar2 into the w
+ void SetPixelShaderConstant( int pixelReg, int constantVar, int constantVar2 );
+ void SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar, int constantVar2 );
+
+ // Helpers for setting constants that need to be converted to linear space (from gamma space).
+ void SetVertexShaderConstantGammaToLinear( int var, float const* pVec, int numConst = 1, bool bForce = false );
+ void SetPixelShaderConstantGammaToLinear( int var, float const* pVec, int numConst = 1, bool bForce = false );
+
+ void SetVertexShaderConstant( int vertexReg, int constantVar );
+
+ // set rgb components of constant from a color parm and give an explicit w value
+ void SetPixelShaderConstant_W( int pixelReg, int constantVar, float fWValue );
+
+ // GR - fix for const/lerp issues
+ void SetPixelShaderConstantFudge( int pixelReg, int constantVar );
+
+ // Sets light direction for pixel shaders.
+ void SetPixelShaderLightColors( int pixelReg );
+
+ // Sets vertex shader texture transforms
+ void SetVertexShaderTextureTranslation( int vertexReg, int translationVar );
+ void SetVertexShaderTextureScale( int vertexReg, int scaleVar );
+ void SetVertexShaderTextureTransform( int vertexReg, int transformVar );
+ void SetVertexShaderTextureScaledTransform( int vertexReg,
+ int transformVar, int scaleVar );
+
+ // Set pixel shader texture transforms
+ void SetPixelShaderTextureTranslation( int pixelReg, int translationVar );
+ void SetPixelShaderTextureScale( int pixelReg, int scaleVar );
+ void SetPixelShaderTextureTransform( int pixelReg, int transformVar );
+ void SetPixelShaderTextureScaledTransform( int pixelReg,
+ int transformVar, int scaleVar );
+
+ // Moves a matrix into vertex shader constants
+ void SetVertexShaderMatrix3x4( int vertexReg, int matrixVar );
+ void SetVertexShaderMatrix4x4( int vertexReg, int matrixVar );
+
+ // Loads the view matrix into vertex shader constants
+ void LoadViewMatrixIntoVertexShaderConstant( int vertexReg );
+
+ // Loads the projection matrix into vertex shader constants
+ void LoadProjectionMatrixIntoVertexShaderConstant( int vertexReg );
+
+ // Loads the model->view matrix into vertex shader constants
+ void LoadModelViewMatrixIntoVertexShaderConstant( int vertexReg );
+
+ // Loads a scale/offset version of the viewport transform into the specified constant.
+ void LoadViewportTransformScaledIntoVertexShaderConstant( int vertexReg );
+
+ // Sets up ambient light cube...
+ void SetAmbientCubeDynamicStateVertexShader( );
+ float GetAmbientLightCubeLuminance( );
+
+ // Helpers for dealing with envmaptint
+ void SetEnvMapTintPixelShaderDynamicState( int pixelReg, int tintVar, int alphaVar, bool bConvertFromGammaToLinear = false );
+
+ // Helper methods for pixel shader overbrighting
+ void EnablePixelShaderOverbright( int reg, bool bEnable, bool bDivideByTwo );
+
+ // Helper for dealing with modulation
+ void SetModulationVertexShaderDynamicState();
+ void SetModulationPixelShaderDynamicState( int modulationVar );
+ void SetModulationPixelShaderDynamicState_LinearColorSpace( int modulationVar );
+ void SetModulationPixelShaderDynamicState_LinearColorSpace_LinearScale( int modulationVar, float flScale );
+
+ // Sets a color + alpha into shader constants
+ void SetColorVertexShaderConstant( int nVertexReg, int colorVar, int alphaVar );
+ void SetColorPixelShaderConstant( int nPixelReg, int colorVar, int alphaVar );
+
+
+#ifndef GAME_SHADER_DLL
+ //
+ // Standard shader passes!
+ //
+
+ void InitParamsUnlitGeneric_DX8(
+ int baseTextureVar,
+ int detailScaleVar,
+ int envmapOptionalVar,
+ int envmapVar,
+ int envmapTintVar,
+ int envmapMaskScaleVar,
+ int nDetailBlendMode );
+
+ void InitUnlitGeneric_DX8(
+ int baseTextureVar,
+ int detailVar,
+ int envmapVar,
+ int envmapMaskVar );
+
+ // Dx8 Unlit Generic pass
+ void 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
+ );
+
+ // Helpers for drawing world bump mapped stuff.
+ void DrawModelBumpedSpecularLighting( int bumpMapVar, int bumpMapFrameVar,
+ int envMapVar, int envMapVarFrame,
+ int envMapTintVar, int alphaVar,
+ int envMapContrastVar, int envMapSaturationVar,
+ int bumpTransformVar,
+ bool bBlendSpecular, bool bNoWriteZ = false );
+ void 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 = false );
+
+ const char *UnlitGeneric_ComputeVertexShaderName( bool bMask,
+ bool bEnvmap,
+ bool bBaseTexture,
+ bool bBaseAlphaEnvmapMask,
+ bool bDetail,
+ bool bVertexColor,
+ bool bEnvmapCameraSpace,
+ bool bEnvmapSphere );
+
+ const char *UnlitGeneric_ComputePixelShaderName( bool bMask,
+ bool bEnvmap,
+ bool bBaseTexture,
+ bool bBaseAlphaEnvmapMask,
+ bool bDetail,
+ bool bMultiplyDetail,
+ bool bMaskBaseByDetailAlpha );
+
+ void DrawWorldBaseTexture( int baseTextureVar, int baseTextureTransformVar, int frameVar, int colorVar, int alphaVar );
+ void DrawWorldBumpedDiffuseLighting( int bumpmapVar, int bumpFrameVar,
+ int bumpTransformVar, bool bMultiply, bool bSSBump );
+ void DrawWorldBumpedSpecularLighting( int envmapMaskVar, int envmapMaskFrame,
+ int bumpmapVar, int envmapVar,
+ int bumpFrameVar, int envmapFrameVar,
+ int envmapTintVar, int alphaVar,
+ int envmapContrastVar, int envmapSaturationVar,
+ int bumpTransformVar, int fresnelReflectionVar,
+ bool bBlend );
+ void DrawBaseTextureBlend( int baseTextureVar, int baseTextureTransformVar,
+ int baseTextureFrameVar,
+ int baseTexture2Var, int baseTextureTransform2Var,
+ int baseTextureFrame2Var, int colorVar, int alphaVar );
+ void DrawWorldBumpedDiffuseLighting_Base_ps14( int bumpmapVar, int bumpFrameVar,
+ int bumpTransformVar, int baseTextureVar, int baseTextureTransformVar, int frameVar );
+ void DrawWorldBumpedDiffuseLighting_Blend_ps14( int bumpmapVar, int bumpFrameVar, int bumpTransformVar,
+ int baseTextureVar, int baseTextureTransformVar, int baseTextureFrameVar,
+ int baseTexture2Var, int baseTextureTransform2Var, int baseTextureFrame2Var);
+ void 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
+ );
+
+ // Sets up hw morphing state for the vertex shader
+ void SetHWMorphVertexShaderState( int nDimConst, int nSubrectConst, VertexTextureSampler_t morphSampler );
+
+ // Computes the shader index for vertex lit materials
+ int ComputeVertexLitShaderIndex( bool bVertexLitGeneric, bool hasBump, bool hasEnvmap, bool hasVertexColor, bool bHasNormal ) const;
+
+ // Helper for setting up flashlight constants
+ void SetFlashlightVertexShaderConstants( bool bBump, int bumpTransformVar, bool bDetail, int detailScaleVar, bool bSetTextureTransforms );
+
+#if SUPPORT_DX8
+ void 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=false, int nTeethForwardVar=0, int nTeethIllumFactorVar=0 );
+#endif
+
+ struct DrawFlashlight_dx90_Vars_t
+ {
+ DrawFlashlight_dx90_Vars_t()
+ {
+ // set all ints to -1
+ memset( this, 0xFF, sizeof(DrawFlashlight_dx90_Vars_t) );
+ // set all bools to a default value.
+ m_bBump = false;
+ m_bLightmappedGeneric = false;
+ m_bWorldVertexTransition = false;
+ m_bTeeth = false;
+ m_bSSBump = false;
+ m_fSeamlessScale = 0.0;
+ }
+ bool m_bBump;
+ bool m_bLightmappedGeneric;
+ bool m_bWorldVertexTransition;
+ bool m_bTeeth;
+ int m_nBumpmapVar;
+ int m_nBumpmapFrame;
+ int m_nBumpTransform;
+ int m_nFlashlightTextureVar;
+ int m_nFlashlightTextureFrameVar;
+ int m_nBaseTexture2Var;
+ int m_nBaseTexture2FrameVar;
+ int m_nBumpmap2Var;
+ int m_nBumpmap2Frame;
+ int m_nBump2Transform;
+ int m_nDetailVar;
+ int m_nDetailScale;
+ int m_nDetailTextureCombineMode;
+ int m_nDetailTextureBlendFactor;
+ int m_nDetailTint;
+ int m_nTeethForwardVar;
+ int m_nTeethIllumFactorVar;
+ int m_nAlphaTestReference;
+ bool m_bSSBump;
+ float m_fSeamlessScale; // 0.0 = not seamless
+ };
+ void DrawFlashlight_dx90( IMaterialVar** params,
+ IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, DrawFlashlight_dx90_Vars_t &vars );
+#endif // GAME_SHADER_DLL
+
+ BlendType_t EvaluateBlendRequirements( int textureVar, bool isBaseTexture, int detailTextureVar = -1 );
+
+ void HashShadow2DJitter( const float fJitterSeed, float *fU, float* fV );
+
+ //Alpha tested materials can end up leaving garbage in the dest alpha buffer if they write depth.
+ //This pass fills in the areas that passed the alpha test with depth in dest alpha
+ //by writing only equal depth pixels and only if we should be writing depth to dest alpha
+ void DrawEqualDepthToDestAlpha( void );
+
+private:
+ // Helper methods for VertexLitGenericPass
+// void UnlitGenericShadowState( int baseTextureVar, int detailVar, int envmapVar, int envmapMaskVar, bool doSkin );
+ void UnlitGenericDynamicState( int baseTextureVar, int frameVar, int baseTextureTransformVar,
+ int detailVar, int detailTransform, bool bDetailTransformIsScale, int envmapVar,
+ int envMapFrameVar, int envmapMaskVar, int envmapMaskFrameVar,
+ int envmapMaskScaleVar, int envmapTintVar );
+
+ // Converts a color + alpha into a vector4
+ void ColorVarsToVector( int colorVar, int alphaVar, Vector4D &color );
+
+};
+
+FORCEINLINE void SetFlashLightColorFromState( FlashlightState_t const &state, IShaderDynamicAPI *pShaderAPI, int nPSRegister=28, bool bFlashlightNoLambert=false )
+{
+ // Old code
+ //float flToneMapScale = ( pShaderAPI->GetToneMappingScaleLinear() ).x;
+ //float flFlashlightScale = 1.0f / flToneMapScale;
+
+ // Fix to old code to keep flashlight from ever getting brighter than 1.0
+ //float flToneMapScale = ( pShaderAPI->GetToneMappingScaleLinear() ).x;
+ //if ( flToneMapScale < 1.0f )
+ // flToneMapScale = 1.0f;
+ //float flFlashlightScale = 1.0f / flToneMapScale;
+
+ // Force flashlight to 25% bright always
+ float flFlashlightScale = 0.25f;
+
+ if ( !g_pHardwareConfig->GetHDREnabled() )
+ {
+ // Non-HDR path requires 2.0 flashlight
+ flFlashlightScale = 2.0f;
+ }
+
+ // DX10 requires some hackery due to sRGB/blend ordering change from DX9
+ if ( g_pHardwareConfig->UsesSRGBCorrectBlending() )
+ {
+ flFlashlightScale *= 2.5f; // Magic number that works well on the NVIDIA 8800
+ }
+
+ // Generate pixel shader constant
+ float const *pFlashlightColor = state.m_Color;
+ float vPsConst[4] = { flFlashlightScale * pFlashlightColor[0], flFlashlightScale * pFlashlightColor[1], flFlashlightScale * pFlashlightColor[2], pFlashlightColor[3] };
+ vPsConst[3] = bFlashlightNoLambert ? 2.0f : 0.0f; // This will be added to N.L before saturate to force a 1.0 N.L term
+
+ // Red flashlight for testing
+ //vPsConst[0] = 0.5f; vPsConst[1] = 0.0f; vPsConst[2] = 0.0f;
+
+ pShaderAPI->SetPixelShaderConstant( nPSRegister, ( float * )vPsConst );
+}
+
+FORCEINLINE float ShadowAttenFromState( FlashlightState_t const &state )
+{
+ // DX10 requires some hackery due to sRGB/blend ordering change from DX9, which makes the shadows too light
+ if ( g_pHardwareConfig->UsesSRGBCorrectBlending() )
+ return state.m_flShadowAtten * 0.1f; // magic number
+
+ return state.m_flShadowAtten;
+}
+
+FORCEINLINE float ShadowFilterFromState( FlashlightState_t const &state )
+{
+ // We developed shadow maps at 1024, so we expect the penumbra size to have been tuned relative to that
+ return state.m_flShadowFilterSize / 1024.0f;
+}
+
+
+// convenient material variable access functions for helpers to use.
+FORCEINLINE bool IsTextureSet( int nVar, IMaterialVar **params )
+{
+ return ( nVar != -1 ) && ( params[nVar]->IsTexture() );
+}
+
+FORCEINLINE bool IsBoolSet( int nVar, IMaterialVar **params )
+{
+ return ( nVar != -1 ) && ( params[nVar]->GetIntValue() );
+}
+
+FORCEINLINE int GetIntParam( int nVar, IMaterialVar **params, int nDefaultValue = 0 )
+{
+ return ( nVar != -1 ) ? ( params[nVar]->GetIntValue() ) : nDefaultValue;
+}
+
+FORCEINLINE float GetFloatParam( int nVar, IMaterialVar **params, float flDefaultValue = 0.0 )
+{
+ return ( nVar != -1 ) ? ( params[nVar]->GetFloatValue() ) : flDefaultValue;
+}
+
+FORCEINLINE void InitFloatParam( int nIndex, IMaterialVar **params, float flValue )
+{
+ if ( (nIndex != -1) && !params[nIndex]->IsDefined() )
+ {
+ params[nIndex]->SetFloatValue( flValue );
+ }
+}
+
+FORCEINLINE void InitIntParam( int nIndex, IMaterialVar **params, int nValue )
+{
+ if ( (nIndex != -1) && !params[nIndex]->IsDefined() )
+ {
+ params[nIndex]->SetIntValue( nValue );
+ }
+}
+
+
+class ConVar;
+
+#ifdef _DEBUG
+extern ConVar mat_envmaptintoverride;
+extern ConVar mat_envmaptintscale;
+#endif
+
+
+#endif // BASEVSSHADER_H
diff --git a/mp/src/materialsystem/stdshaders/buildhl2mpshaders.bat b/mp/src/materialsystem/stdshaders/buildhl2mpshaders.bat new file mode 100644 index 00000000..58b0cd26 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/buildhl2mpshaders.bat @@ -0,0 +1,21 @@ +@echo off
+setlocal
+
+rem ================================
+rem ==== MOD PATH CONFIGURATIONS ===
+
+rem == Set the absolute path to your mod's game directory here ==
+set GAMEDIR=%cd%\..\..\..\game\mod_hl2mp
+
+rem == Set the relative or absolute path to Source SDK Base 2013 Singleplayer\bin ==
+set SDKBINDIR=C:\SteamBetaLibrary\SteamApps\common\Source SDK Base 2013 Singleplayer\bin
+
+rem == Set the Path to your mod's root source code ==
+rem This should already be correct, accepts relative paths only!
+set SOURCEDIR=..\..
+
+rem ==== MOD PATH CONFIGURATIONS END ===
+rem ====================================
+
+
+call buildsdkshaders.bat
diff --git a/mp/src/materialsystem/stdshaders/buildsdkshaders.bat b/mp/src/materialsystem/stdshaders/buildsdkshaders.bat new file mode 100644 index 00000000..eeaa5b8c --- /dev/null +++ b/mp/src/materialsystem/stdshaders/buildsdkshaders.bat @@ -0,0 +1,40 @@ +@echo off
+setlocal
+
+rem Use dynamic shaders to build .inc files only
+rem set dynamic_shaders=1
+rem == Setup path to nmake.exe, from vc 2005 common tools directory ==
+call "%VS100COMNTOOLS%vsvars32.bat"
+
+
+set TTEXE=..\..\devtools\bin\timeprecise.exe
+if not exist %TTEXE% goto no_ttexe
+goto no_ttexe_end
+
+:no_ttexe
+set TTEXE=time /t
+:no_ttexe_end
+
+
+rem echo.
+rem echo ~~~~~~ buildsdkshaders %* ~~~~~~
+%TTEXE% -cur-Q
+set tt_all_start=%ERRORLEVEL%
+set tt_all_chkpt=%tt_start%
+
+set BUILD_SHADER=call buildshaders.bat
+set ARG_EXTRA=
+
+%BUILD_SHADER% stdshader_dx9_20b -game %GAMEDIR% -source %SOURCEDIR%
+%BUILD_SHADER% stdshader_dx9_30 -game %GAMEDIR% -source %SOURCEDIR% -dx9_30 -force30
+
+
+rem echo.
+if not "%dynamic_shaders%" == "1" (
+ rem echo Finished full buildallshaders %*
+) else (
+ rem echo Finished dynamic buildallshaders %*
+)
+
+rem %TTEXE% -diff %tt_all_start% -cur
+rem echo.
diff --git a/mp/src/materialsystem/stdshaders/buildshaders.bat b/mp/src/materialsystem/stdshaders/buildshaders.bat new file mode 100644 index 00000000..64859912 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/buildshaders.bat @@ -0,0 +1,209 @@ +@echo off
+
+set TTEXE=..\..\devtools\bin\timeprecise.exe
+if not exist %TTEXE% goto no_ttexe
+goto no_ttexe_end
+
+:no_ttexe
+set TTEXE=time /t
+:no_ttexe_end
+
+echo.
+echo ==================== buildshaders %* ==================
+%TTEXE% -cur-Q
+set tt_start=%ERRORLEVEL%
+set tt_chkpt=%tt_start%
+
+
+REM ****************
+REM usage: buildshaders <shaderProjectName>
+REM ****************
+
+setlocal
+set arg_filename=%1
+set shadercompilecommand=shadercompile.exe
+set targetdir=shaders
+set SrcDirBase=..\..
+set shaderDir=shaders
+set SDKArgs=
+set SHADERINCPATH=vshtmp9/... fxctmp9/...
+
+
+if "%1" == "" goto usage
+set inputbase=%1
+
+set DIRECTX_SDK_VER=pc09.00
+set DIRECTX_SDK_BIN_DIR=dx9sdk\utilities
+
+if /i "%6" == "-dx9_30" goto dx_sdk_dx9_30
+goto dx_sdk_end
+:dx_sdk_dx9_30
+ set DIRECTX_SDK_VER=pc09.30
+ set DIRECTX_SDK_BIN_DIR=dx10sdk\utilities\dx9_30
+ goto dx_sdk_end
+:dx_sdk_end
+
+if /i "%7" == "-force30" goto set_force30_arg
+goto set_force_end
+:set_force30_arg
+ set DIRECTX_FORCE_MODEL=30
+ goto set_force_end
+:set_force_end
+
+if /i "%2" == "-game" goto set_mod_args
+goto build_shaders
+
+REM ****************
+REM USAGE
+REM ****************
+:usage
+echo.
+echo "usage: buildshaders <shaderProjectName> [-game] [gameDir if -game was specified] [-source sourceDir]"
+echo " gameDir is where gameinfo.txt is (where it will store the compiled shaders)."
+echo " sourceDir is where the source code is (where it will find scripts and compilers)."
+echo "ex : buildshaders myshaders"
+echo "ex : buildshaders myshaders -game c:\steam\steamapps\sourcemods\mymod -source c:\mymod\src"
+goto :end
+
+REM ****************
+REM MOD ARGS - look for -game or the vproject environment variable
+REM ****************
+:set_mod_args
+
+if not exist "%SDKBINDIR%\shadercompile.exe" goto NoShaderCompile
+set ChangeToDir=%SDKBINDIR%
+
+if /i "%4" NEQ "-source" goto NoSourceDirSpecified
+set SrcDirBase=%~5
+
+REM ** use the -game parameter to tell us where to put the files
+set targetdir=%~3\shaders
+set SDKArgs=-nompi -nop4 -game "%~3"
+
+if not exist "%~3\gameinfo.txt" goto InvalidGameDirectory
+goto build_shaders
+
+REM ****************
+REM ERRORS
+REM ****************
+:InvalidGameDirectory
+echo -
+echo Error: "%~3" is not a valid game directory.
+echo (The -game directory must have a gameinfo.txt file)
+echo -
+goto end
+
+:NoSourceDirSpecified
+echo ERROR: If you specify -game on the command line, you must specify -source.
+goto usage
+goto end
+
+:NoShaderCompile
+echo -
+echo - ERROR: shadercompile.exe doesn't exist in %SDKBINDIR%
+echo -
+goto end
+
+REM ****************
+REM BUILD SHADERS
+REM ****************
+:build_shaders
+
+rem echo --------------------------------
+rem echo %inputbase%
+rem echo --------------------------------
+REM make sure that target dirs exist
+REM files will be built in these targets and copied to their final destination
+if not exist %shaderDir% mkdir %shaderDir%
+if not exist %shaderDir%\fxc mkdir %shaderDir%\fxc
+if not exist %shaderDir%\vsh mkdir %shaderDir%\vsh
+if not exist %shaderDir%\psh mkdir %shaderDir%\psh
+REM Nuke some files that we will add to later.
+if exist filelist.txt del /f /q filelist.txt
+if exist filestocopy.txt del /f /q filestocopy.txt
+if exist filelistgen.txt del /f /q filelistgen.txt
+if exist inclist.txt del /f /q inclist.txt
+if exist vcslist.txt del /f /q vcslist.txt
+
+REM ****************
+REM Generate a makefile for the shader project
+REM ****************
+perl "%SrcDirBase%\devtools\bin\updateshaders.pl" -source "%SrcDirBase%" %inputbase%
+
+
+REM ****************
+REM Run the makefile, generating minimal work/build list for fxc files, go ahead and compile vsh and psh files.
+REM ****************
+rem nmake /S /C -f makefile.%inputbase% clean > clean.txt 2>&1
+echo Building inc files, asm vcs files, and VMPI worklist for %inputbase%...
+nmake /S /C -f makefile.%inputbase%
+
+REM ****************
+REM Copy the inc files to their target
+REM ****************
+if exist "inclist.txt" (
+ echo Publishing shader inc files to target...
+ perl %SrcDirBase%\devtools\bin\copyshaderincfiles.pl inclist.txt
+)
+
+REM ****************
+REM Add the executables to the worklist.
+REM ****************
+if /i "%DIRECTX_SDK_VER%" == "pc09.00" (
+ rem echo "Copy extra files for dx 9 std
+)
+if /i "%DIRECTX_SDK_VER%" == "pc09.30" (
+ echo %SrcDirBase%\devtools\bin\d3dx9_33.dll >> filestocopy.txt
+)
+
+echo %SrcDirBase%\%DIRECTX_SDK_BIN_DIR%\dx_proxy.dll >> filestocopy.txt
+
+echo %SDKBINDIR%\shadercompile.exe >> filestocopy.txt
+echo %SDKBINDIR%\shadercompile_dll.dll >> filestocopy.txt
+echo %SDKBINDIR%\vstdlib.dll >> filestocopy.txt
+echo %SDKBINDIR%\tier0.dll >> filestocopy.txt
+
+REM ****************
+REM Cull duplicate entries in work/build list
+REM ****************
+if exist filestocopy.txt type filestocopy.txt | perl "%SrcDirBase%\devtools\bin\uniqifylist.pl" > uniquefilestocopy.txt
+if exist filelistgen.txt if not "%dynamic_shaders%" == "1" (
+ echo Generating action list...
+ copy filelistgen.txt filelist.txt >nul
+)
+
+REM ****************
+REM Execute distributed process on work/build list
+REM ****************
+
+set shader_path_cd=%cd%
+if exist "filelist.txt" if exist "uniquefilestocopy.txt" if not "%dynamic_shaders%" == "1" (
+ echo Running distributed shader compilation...
+
+ cd /D %ChangeToDir%
+ echo %shadercompilecommand% %SDKArgs% -shaderpath "%shader_path_cd:/=\%" -allowdebug
+ %shadercompilecommand% %SDKArgs% -shaderpath "%shader_path_cd:/=\%" -allowdebug
+ cd /D %shader_path_cd%
+)
+
+REM ****************
+REM PC Shader copy
+REM Publish the generated files to the output dir using XCOPY
+REM This batch file may have been invoked standalone or slaved (master does final smart mirror copy)
+REM ****************
+:DoXCopy
+if not "%dynamic_shaders%" == "1" (
+if not exist "%targetdir%" md "%targetdir%"
+if not "%targetdir%"=="%shaderDir%" xcopy %shaderDir%\*.* "%targetdir%" /e /y
+)
+goto end
+
+REM ****************
+REM END
+REM ****************
+:end
+
+
+%TTEXE% -diff %tt_start%
+echo.
+
diff --git a/mp/src/materialsystem/stdshaders/clean.bat b/mp/src/materialsystem/stdshaders/clean.bat new file mode 100644 index 00000000..eec63804 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/clean.bat @@ -0,0 +1,33 @@ +@echo off
+setlocal
+
+if /i "%1" == "-game" goto CleanGameDir
+
+rem Clean out hl2
+if exist ..\..\..\game\hl2\shaders rd /s /q ..\..\..\game\hl2\shaders
+goto CleanOtherStuff
+
+:CleanGameDir
+set __GameDir=%~2
+if not exist "%__GameDir%\gameinfo.txt" goto MissingGameInfo
+if exist "%__GameDir%\shaders" rd /s /q "%2\shaders"
+goto CleanOtherStuff
+
+:CleanOtherStuff
+if exist debug_dx9 rd /s /q debug_dx9
+
+if exist fxctmp9 rd /s /q fxctmp9
+if exist vshtmp9 rd /s /q vshtmp9
+if exist pshtmp9 rd /s /q pshtmp9
+if exist fxctmp9_tmp rd /s /q fxctmp9_tmp
+if exist vshtmp9_tmp rd /s /q vshtmp9_tmp
+if exist pshtmp9_tmp rd /s /q pshtmp9_tmp
+if exist shaders rd /s /q shaders
+goto end
+
+:MissingGameInfo
+echo Invalid -game parameter specified (no "%__GameDir%\gameinfo.txt" exists).
+goto end
+
+
+:end
\ No newline at end of file diff --git a/mp/src/materialsystem/stdshaders/cleantemps.bat b/mp/src/materialsystem/stdshaders/cleantemps.bat new file mode 100644 index 00000000..51478ee4 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/cleantemps.bat @@ -0,0 +1,12 @@ +@echo off
+setlocal
+
+if exist fxctmp9_tmp rd /s /q fxctmp9_tmp
+if exist vshtmp9_tmp rd /s /q vshtmp9_tmp
+if exist pshtmp9_tmp rd /s /q pshtmp9_tmp
+
+if exist fxctmp9_360_tmp rd /s /q fxctmp9_360_tmp
+if exist vshtmp9_360_tmp rd /s /q vshtmp9_360_tmp
+if exist pshtmp9_360_tmp rd /s /q pshtmp9_360_tmp
+
+if exist shaders rd /s /q shaders
diff --git a/mp/src/materialsystem/stdshaders/commandbuilder.h b/mp/src/materialsystem/stdshaders/commandbuilder.h new file mode 100644 index 00000000..13a68ede --- /dev/null +++ b/mp/src/materialsystem/stdshaders/commandbuilder.h @@ -0,0 +1,407 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+// Utility class for building command buffers into memory
+//===========================================================================//
+
+#ifndef COMMANDBUILDER_H
+#define COMMANDBUILDER_H
+
+#ifndef COMMANDBUFFER_H
+#include "shaderapi/commandbuffer.h"
+#endif
+
+#include "BaseVSShader.h"
+#include "shaderapi/ishaderapi.h"
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+extern ConVar my_mat_fullbright;
+
+template<int N> class CFixedCommandStorageBuffer
+{
+public:
+ uint8 m_Data[N];
+
+ uint8 *m_pDataOut;
+#ifdef DBGFLAG_ASSERT
+ size_t m_nNumBytesRemaining;
+#endif
+
+ FORCEINLINE CFixedCommandStorageBuffer( void )
+ {
+ m_pDataOut = m_Data;
+#ifdef DBGFLAG_ASSERT
+ m_nNumBytesRemaining = N;
+#endif
+
+ }
+
+ FORCEINLINE void EnsureCapacity( size_t sz )
+ {
+ Assert( m_nNumBytesRemaining >= sz );
+ }
+
+ template<class T> FORCEINLINE void Put( T const &nValue )
+ {
+ EnsureCapacity( sizeof( T ) );
+ *( reinterpret_cast<T *>( m_pDataOut ) ) = nValue;
+ m_pDataOut += sizeof( nValue );
+#ifdef DBGFLAG_ASSERT
+ m_nNumBytesRemaining -= sizeof( nValue );
+#endif
+ }
+
+ FORCEINLINE void PutInt( int nValue )
+ {
+ Put( nValue );
+ }
+
+ FORCEINLINE void PutFloat( float nValue )
+ {
+ Put( nValue );
+ }
+
+ FORCEINLINE void PutPtr( void * pPtr )
+ {
+ Put( pPtr );
+ }
+
+ FORCEINLINE void PutMemory( const void *pMemory, size_t nBytes )
+ {
+ EnsureCapacity( nBytes );
+ memcpy( m_pDataOut, pMemory, nBytes );
+ m_pDataOut += nBytes;
+ }
+
+ FORCEINLINE uint8 *Base( void )
+ {
+ return m_Data;
+ }
+
+ FORCEINLINE void Reset( void )
+ {
+ m_pDataOut = m_Data;
+#ifdef DBGFLAG_ASSERT
+ m_nNumBytesRemaining = N;
+#endif
+ }
+
+ FORCEINLINE size_t Size( void ) const
+ {
+ return m_pDataOut - m_Data;
+ }
+
+};
+
+template<class S> class CCommandBufferBuilder
+{
+public:
+ S m_Storage;
+
+ FORCEINLINE void End( void )
+ {
+ m_Storage.PutInt( CBCMD_END );
+ }
+
+
+ FORCEINLINE IMaterialVar *Param( int nVar ) const
+ {
+ return CBaseShader::s_ppParams[nVar];
+ }
+
+ FORCEINLINE void SetPixelShaderConstants( int nFirstConstant, int nConstants )
+ {
+ m_Storage.PutInt( CBCMD_SET_PIXEL_SHADER_FLOAT_CONST );
+ m_Storage.PutInt( nFirstConstant );
+ m_Storage.PutInt( nConstants );
+ }
+
+ FORCEINLINE void OutputConstantData( float const *pSrcData )
+ {
+ m_Storage.PutFloat( pSrcData[0] );
+ m_Storage.PutFloat( pSrcData[1] );
+ m_Storage.PutFloat( pSrcData[2] );
+ m_Storage.PutFloat( pSrcData[3] );
+ }
+
+ FORCEINLINE void OutputConstantData4( float flVal0, float flVal1, float flVal2, float flVal3 )
+ {
+ m_Storage.PutFloat( flVal0 );
+ m_Storage.PutFloat( flVal1 );
+ m_Storage.PutFloat( flVal2 );
+ m_Storage.PutFloat( flVal3 );
+ }
+
+ FORCEINLINE void SetPixelShaderConstant( int nFirstConstant, float const *pSrcData, int nNumConstantsToSet )
+ {
+ SetPixelShaderConstants( nFirstConstant, nNumConstantsToSet );
+ m_Storage.PutMemory( pSrcData, 4 * sizeof( float ) * nNumConstantsToSet );
+ }
+
+ FORCEINLINE void SetPixelShaderConstant( int nFirstConstant, int nVar )
+ {
+ SetPixelShaderConstant( nFirstConstant, Param( nVar )->GetVecValue() );
+ }
+
+ void SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar )
+ {
+ float val[4];
+ Param(constantVar)->GetVecValue( val, 3 );
+ 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] );
+ val[3] = 1.0;
+ SetPixelShaderConstant( pixelReg, val );
+ }
+
+ FORCEINLINE void SetPixelShaderConstant( int nFirstConstant, float const *pSrcData )
+ {
+ SetPixelShaderConstants( nFirstConstant, 1 );
+ OutputConstantData( pSrcData );
+ }
+
+ FORCEINLINE void SetPixelShaderConstant4( int nFirstConstant, float flVal0, float flVal1, float flVal2, float flVal3 )
+ {
+ SetPixelShaderConstants( nFirstConstant, 1 );
+ OutputConstantData4( flVal0, flVal1, flVal2, flVal3 );
+ }
+
+ FORCEINLINE void SetPixelShaderConstant_W( int pixelReg, int constantVar, float fWValue )
+ {
+ if ( constantVar != -1 )
+ {
+ float val[3];
+ Param(constantVar)->GetVecValue( val, 3);
+ SetPixelShaderConstant4( pixelReg, val[0], val[1], val[2], fWValue );
+ }
+ }
+
+ FORCEINLINE void SetVertexShaderConstant( int nFirstConstant, float const *pSrcData )
+ {
+ m_Storage.PutInt( CBCMD_SET_VERTEX_SHADER_FLOAT_CONST );
+ m_Storage.PutInt( nFirstConstant );
+ m_Storage.PutInt( 1 );
+ OutputConstantData( pSrcData );
+ }
+
+ FORCEINLINE void SetVertexShaderConstant( int nFirstConstant, float const *pSrcData, int nConsts )
+ {
+ m_Storage.PutInt( CBCMD_SET_VERTEX_SHADER_FLOAT_CONST );
+ m_Storage.PutInt( nFirstConstant );
+ m_Storage.PutInt( nConsts );
+ m_Storage.PutMemory( pSrcData, 4 * nConsts * sizeof( float ) );
+ }
+
+
+ FORCEINLINE void SetVertexShaderConstant4( int nFirstConstant, float flVal0, float flVal1, float flVal2, float flVal3 )
+ {
+ m_Storage.PutInt( CBCMD_SET_VERTEX_SHADER_FLOAT_CONST );
+ m_Storage.PutInt( nFirstConstant );
+ m_Storage.PutInt( 1 );
+ m_Storage.PutFloat( flVal0 );
+ m_Storage.PutFloat( flVal1 );
+ m_Storage.PutFloat( flVal2 );
+ m_Storage.PutFloat( flVal3 );
+ }
+
+ void SetVertexShaderTextureTransform( int vertexReg, int transformVar )
+ {
+ Vector4D transformation[2];
+ IMaterialVar* pTransformationVar = Param( 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 );
+ }
+ SetVertexShaderConstant( vertexReg, transformation[0].Base(), 2 );
+ }
+
+
+ void SetVertexShaderTextureScaledTransform( int vertexReg, int transformVar, int scaleVar )
+ {
+ Vector4D transformation[2];
+ IMaterialVar* pTransformationVar = Param( 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 = Param( 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];
+ SetVertexShaderConstant( vertexReg, transformation[0].Base(), 2 );
+ }
+
+ FORCEINLINE void SetEnvMapTintPixelShaderDynamicState( int pixelReg, int tintVar )
+ {
+ if( g_pConfig->bShowSpecular && my_mat_fullbright.GetInt() != 2 )
+ {
+ SetPixelShaderConstant( pixelReg, Param( tintVar)->GetVecValue() );
+ }
+ else
+ {
+ SetPixelShaderConstant4( pixelReg, 0.0, 0.0, 0.0, 0.0 );
+ }
+ }
+
+ FORCEINLINE void SetEnvMapTintPixelShaderDynamicStateGammaToLinear( int pixelReg, int tintVar, float flAlphaValue = 1.0 )
+ {
+ if( ( tintVar != -1 ) && g_pConfig->bShowSpecular && my_mat_fullbright.GetInt() != 2 )
+ {
+ float color[4];
+ color[3] = flAlphaValue;
+ Param( tintVar)->GetLinearVecValue( color, 3 );
+ SetPixelShaderConstant( pixelReg, color );
+ }
+ else
+ {
+ SetPixelShaderConstant4( pixelReg, 0.0, 0.0, 0.0, flAlphaValue );
+ }
+ }
+
+ FORCEINLINE void StoreEyePosInPixelShaderConstant( int nConst )
+ {
+ m_Storage.PutInt( CBCMD_STORE_EYE_POS_IN_PSCONST );
+ m_Storage.PutInt( nConst );
+ }
+
+ FORCEINLINE void CommitPixelShaderLighting( int nConst )
+ {
+ m_Storage.PutInt( CBCMD_COMMITPIXELSHADERLIGHTING );
+ m_Storage.PutInt( nConst );
+ }
+
+ FORCEINLINE void SetPixelShaderStateAmbientLightCube( int nConst )
+ {
+ m_Storage.PutInt( CBCMD_SETPIXELSHADERSTATEAMBIENTLIGHTCUBE );
+ m_Storage.PutInt( nConst );
+ }
+
+ FORCEINLINE void SetAmbientCubeDynamicStateVertexShader( void )
+ {
+ m_Storage.PutInt( CBCMD_SETAMBIENTCUBEDYNAMICSTATEVERTEXSHADER );
+ }
+
+ FORCEINLINE void SetPixelShaderFogParams( int nReg )
+ {
+ m_Storage.PutInt( CBCMD_SETPIXELSHADERFOGPARAMS );
+ m_Storage.PutInt( nReg );
+ }
+
+ FORCEINLINE void BindStandardTexture( Sampler_t nSampler, StandardTextureId_t nTextureId )
+ {
+ m_Storage.PutInt( CBCMD_BIND_STANDARD_TEXTURE );
+ m_Storage.PutInt( nSampler );
+ m_Storage.PutInt( nTextureId );
+ }
+
+
+ FORCEINLINE void BindTexture( Sampler_t nSampler, ShaderAPITextureHandle_t hTexture )
+ {
+ Assert( hTexture != INVALID_SHADERAPI_TEXTURE_HANDLE );
+ if ( hTexture != INVALID_SHADERAPI_TEXTURE_HANDLE )
+ {
+ m_Storage.PutInt( CBCMD_BIND_SHADERAPI_TEXTURE_HANDLE );
+ m_Storage.PutInt( nSampler );
+ m_Storage.PutInt( hTexture );
+ }
+ }
+
+ FORCEINLINE void BindTexture( CBaseVSShader *pShader, Sampler_t nSampler, int nTextureVar, int nFrameVar )
+ {
+ ShaderAPITextureHandle_t hTexture = pShader->GetShaderAPITextureBindHandle( nTextureVar, nFrameVar );
+ BindTexture( nSampler, hTexture );
+ }
+
+ FORCEINLINE void BindMultiTexture( CBaseVSShader *pShader, Sampler_t nSampler1, Sampler_t nSampler2, int nTextureVar, int nFrameVar )
+ {
+ ShaderAPITextureHandle_t hTexture = pShader->GetShaderAPITextureBindHandle( nTextureVar, nFrameVar, 0 );
+ BindTexture( nSampler1, hTexture );
+ hTexture = pShader->GetShaderAPITextureBindHandle( nTextureVar, nFrameVar, 1 );
+ BindTexture( nSampler2, hTexture );
+ }
+
+ FORCEINLINE void SetPixelShaderIndex( int nIndex )
+ {
+ m_Storage.PutInt( CBCMD_SET_PSHINDEX );
+ m_Storage.PutInt( nIndex );
+ }
+
+ FORCEINLINE void SetVertexShaderIndex( int nIndex )
+ {
+ m_Storage.PutInt( CBCMD_SET_VSHINDEX );
+ m_Storage.PutInt( nIndex );
+ }
+
+ FORCEINLINE void SetDepthFeatheringPixelShaderConstant( int iConstant, float fDepthBlendScale )
+ {
+ m_Storage.PutInt( CBCMD_SET_DEPTH_FEATHERING_CONST );
+ m_Storage.PutInt( iConstant );
+ m_Storage.PutFloat( fDepthBlendScale );
+ }
+
+ FORCEINLINE void Goto( uint8 *pCmdBuf )
+ {
+ m_Storage.PutInt( CBCMD_JUMP );
+ m_Storage.PutPtr( pCmdBuf );
+ }
+
+ FORCEINLINE void Call( uint8 *pCmdBuf )
+ {
+ m_Storage.PutInt( CBCMD_JSR );
+ m_Storage.PutPtr( pCmdBuf );
+ }
+
+ FORCEINLINE void Reset( void )
+ {
+ m_Storage.Reset();
+ }
+
+ FORCEINLINE size_t Size( void ) const
+ {
+ return m_Storage.Size();
+ }
+
+ FORCEINLINE uint8 *Base( void )
+ {
+ return m_Storage.Base();
+ }
+
+
+
+};
+
+
+#endif // commandbuilder_h
diff --git a/mp/src/materialsystem/stdshaders/common_flashlight_fxc.h b/mp/src/materialsystem/stdshaders/common_flashlight_fxc.h new file mode 100644 index 00000000..f9256a59 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/common_flashlight_fxc.h @@ -0,0 +1,821 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Common pixel shader code specific to flashlights
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#ifndef COMMON_FLASHLIGHT_FXC_H_
+#define COMMON_FLASHLIGHT_FXC_H_
+
+#include "common_ps_fxc.h"
+
+
+// JasonM - TODO: remove this simpleton version
+float DoShadow( sampler DepthSampler, float4 texCoord )
+{
+ const float g_flShadowBias = 0.0005f;
+ float2 uoffset = float2( 0.5f/512.f, 0.0f );
+ float2 voffset = float2( 0.0f, 0.5f/512.f );
+ float3 projTexCoord = texCoord.xyz / texCoord.w;
+ float4 flashlightDepth = float4( tex2D( DepthSampler, projTexCoord + uoffset + voffset ).x,
+ tex2D( DepthSampler, projTexCoord + uoffset - voffset ).x,
+ tex2D( DepthSampler, projTexCoord - uoffset + voffset ).x,
+ tex2D( DepthSampler, projTexCoord - uoffset - voffset ).x );
+
+# if ( defined( REVERSE_DEPTH_ON_X360 ) )
+ {
+ flashlightDepth = 1.0f - flashlightDepth;
+ }
+# endif
+
+ float shadowed = 0.0f;
+ float z = texCoord.z/texCoord.w;
+ float4 dz = float4(z,z,z,z) - (flashlightDepth + float4( g_flShadowBias, g_flShadowBias, g_flShadowBias, g_flShadowBias));
+ float4 shadow = float4(0.25f,0.25f,0.25f,0.25f);
+
+ if( dz.x <= 0.0f )
+ shadowed += shadow.x;
+ if( dz.y <= 0.0f )
+ shadowed += shadow.y;
+ if( dz.z <= 0.0f )
+ shadowed += shadow.z;
+ if( dz.w <= 0.0f )
+ shadowed += shadow.w;
+
+ return shadowed;
+}
+
+
+float DoShadowNvidiaRAWZOneTap( sampler DepthSampler, const float4 shadowMapPos )
+{
+ float ooW = 1.0f / shadowMapPos.w; // 1 / w
+ float3 shadowMapCenter_objDepth = shadowMapPos.xyz * ooW; // Do both projections at once
+
+ float2 shadowMapCenter = shadowMapCenter_objDepth.xy; // Center of shadow filter
+ float objDepth = shadowMapCenter_objDepth.z; // Object depth in shadow space
+
+ float fDepth = dot(tex2D(DepthSampler, shadowMapCenter).arg, float3(0.996093809371817670572857294849, 0.0038909914428586627756752238080039, 1.5199185323666651467481343000015e-5));
+
+ return fDepth > objDepth;
+}
+
+
+float DoShadowNvidiaRAWZ( sampler DepthSampler, const float4 shadowMapPos )
+{
+ float fE = 1.0f / 512.0f; // Epsilon
+
+ float ooW = 1.0f / shadowMapPos.w; // 1 / w
+ float3 shadowMapCenter_objDepth = shadowMapPos.xyz * ooW; // Do both projections at once
+
+ float2 shadowMapCenter = shadowMapCenter_objDepth.xy; // Center of shadow filter
+ float objDepth = shadowMapCenter_objDepth.z; // Object depth in shadow space
+
+ float4 vDepths;
+ vDepths.x = dot(tex2D(DepthSampler, shadowMapCenter + float2( fE, fE )).arg, float3(0.996093809371817670572857294849, 0.0038909914428586627756752238080039, 1.5199185323666651467481343000015e-5));
+ vDepths.y = dot(tex2D(DepthSampler, shadowMapCenter + float2( -fE, fE )).arg, float3(0.996093809371817670572857294849, 0.0038909914428586627756752238080039, 1.5199185323666651467481343000015e-5));
+ vDepths.z = dot(tex2D(DepthSampler, shadowMapCenter + float2( fE, -fE )).arg, float3(0.996093809371817670572857294849, 0.0038909914428586627756752238080039, 1.5199185323666651467481343000015e-5));
+ vDepths.w = dot(tex2D(DepthSampler, shadowMapCenter + float2( -fE, -fE )).arg, float3(0.996093809371817670572857294849, 0.0038909914428586627756752238080039, 1.5199185323666651467481343000015e-5));
+
+ return dot(vDepths > objDepth.xxxx, float4(0.25, 0.25, 0.25, 0.25));
+}
+
+
+float DoShadowNvidiaCheap( sampler DepthSampler, const float4 shadowMapPos )
+{
+ float fTexelEpsilon = 1.0f / 1024.0f;
+
+ float ooW = 1.0f / shadowMapPos.w; // 1 / w
+ float3 shadowMapCenter_objDepth = shadowMapPos.xyz * ooW; // Do both projections at once
+
+ float2 shadowMapCenter = shadowMapCenter_objDepth.xy; // Center of shadow filter
+ float objDepth = shadowMapCenter_objDepth.z; // Object depth in shadow space
+
+ float4 vTaps;
+ vTaps.x = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTexelEpsilon, fTexelEpsilon), objDepth, 1 ) ).x;
+ vTaps.y = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTexelEpsilon, fTexelEpsilon), objDepth, 1 ) ).x;
+ vTaps.z = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTexelEpsilon, -fTexelEpsilon), objDepth, 1 ) ).x;
+ vTaps.w = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTexelEpsilon, -fTexelEpsilon), objDepth, 1 ) ).x;
+
+ return dot(vTaps, float4(0.25, 0.25, 0.25, 0.25));
+}
+
+float DoShadowNvidiaPCF3x3Box( sampler DepthSampler, const float4 shadowMapPos )
+{
+ float fTexelEpsilon = 1.0f / 1024.0f;
+
+ float ooW = 1.0f / shadowMapPos.w; // 1 / w
+ float3 shadowMapCenter_objDepth = shadowMapPos.xyz * ooW; // Do both projections at once
+
+ float2 shadowMapCenter = shadowMapCenter_objDepth.xy; // Center of shadow filter
+ float objDepth = shadowMapCenter_objDepth.z; // Object depth in shadow space
+
+ float4 vOneTaps;
+ vOneTaps.x = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTexelEpsilon, fTexelEpsilon ), objDepth, 1 ) ).x;
+ vOneTaps.y = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTexelEpsilon, fTexelEpsilon ), objDepth, 1 ) ).x;
+ vOneTaps.z = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTexelEpsilon, -fTexelEpsilon ), objDepth, 1 ) ).x;
+ vOneTaps.w = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTexelEpsilon, -fTexelEpsilon ), objDepth, 1 ) ).x;
+ float flOneTaps = dot( vOneTaps, float4(1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f));
+
+ float4 vTwoTaps;
+ vTwoTaps.x = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTexelEpsilon, 0 ), objDepth, 1 ) ).x;
+ vTwoTaps.y = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTexelEpsilon, 0 ), objDepth, 1 ) ).x;
+ vTwoTaps.z = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( 0, -fTexelEpsilon ), objDepth, 1 ) ).x;
+ vTwoTaps.w = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( 0, -fTexelEpsilon ), objDepth, 1 ) ).x;
+ float flTwoTaps = dot( vTwoTaps, float4(1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f, 1.0f / 9.0f));
+
+ float flCenterTap = tex2Dproj( DepthSampler, float4( shadowMapCenter, objDepth, 1 ) ).x * (1.0f / 9.0f);
+
+ // Sum all 9 Taps
+ return flOneTaps + flTwoTaps + flCenterTap;
+}
+
+
+//
+// 1 4 7 4 1
+// 4 20 33 20 4
+// 7 33 55 33 7
+// 4 20 33 20 4
+// 1 4 7 4 1
+//
+float DoShadowNvidiaPCF5x5Gaussian( sampler DepthSampler, const float4 shadowMapPos )
+{
+ float fEpsilon = 1.0f / 512.0f;
+ float fTwoEpsilon = 2.0f * fEpsilon;
+
+ float ooW = 1.0f / shadowMapPos.w; // 1 / w
+ float3 shadowMapCenter_objDepth = shadowMapPos.xyz * ooW; // Do both projections at once
+
+ float2 shadowMapCenter = shadowMapCenter_objDepth.xy; // Center of shadow filter
+ float objDepth = shadowMapCenter_objDepth.z; // Object depth in shadow space
+
+ float4 vOneTaps;
+ vOneTaps.x = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTwoEpsilon, fTwoEpsilon ), objDepth, 1 ) ).x;
+ vOneTaps.y = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTwoEpsilon, fTwoEpsilon ), objDepth, 1 ) ).x;
+ vOneTaps.z = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTwoEpsilon, -fTwoEpsilon ), objDepth, 1 ) ).x;
+ vOneTaps.w = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTwoEpsilon, -fTwoEpsilon ), objDepth, 1 ) ).x;
+ float flOneTaps = dot( vOneTaps, float4(1.0f / 331.0f, 1.0f / 331.0f, 1.0f / 331.0f, 1.0f / 331.0f));
+
+ float4 vSevenTaps;
+ vSevenTaps.x = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTwoEpsilon, 0 ), objDepth, 1 ) ).x;
+ vSevenTaps.y = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTwoEpsilon, 0 ), objDepth, 1 ) ).x;
+ vSevenTaps.z = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( 0, -fTwoEpsilon ), objDepth, 1 ) ).x;
+ vSevenTaps.w = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( 0, -fTwoEpsilon ), objDepth, 1 ) ).x;
+ float flSevenTaps = dot( vSevenTaps, float4( 7.0f / 331.0f, 7.0f / 331.0f, 7.0f / 331.0f, 7.0f / 331.0f ) );
+
+ float4 vFourTapsA, vFourTapsB;
+ vFourTapsA.x = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTwoEpsilon, fEpsilon ), objDepth, 1 ) ).x;
+ vFourTapsA.y = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fEpsilon, fTwoEpsilon ), objDepth, 1 ) ).x;
+ vFourTapsA.z = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fEpsilon, fTwoEpsilon ), objDepth, 1 ) ).x;
+ vFourTapsA.w = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTwoEpsilon, fEpsilon ), objDepth, 1 ) ).x;
+ vFourTapsB.x = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fTwoEpsilon, -fEpsilon ), objDepth, 1 ) ).x;
+ vFourTapsB.y = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fEpsilon, -fTwoEpsilon ), objDepth, 1 ) ).x;
+ vFourTapsB.z = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fEpsilon, -fTwoEpsilon ), objDepth, 1 ) ).x;
+ vFourTapsB.w = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fTwoEpsilon, -fEpsilon ), objDepth, 1 ) ).x;
+ float flFourTapsA = dot( vFourTapsA, float4( 4.0f / 331.0f, 4.0f / 331.0f, 4.0f / 331.0f, 4.0f / 331.0f ) );
+ float flFourTapsB = dot( vFourTapsB, float4( 4.0f / 331.0f, 4.0f / 331.0f, 4.0f / 331.0f, 4.0f / 331.0f ) );
+
+ float4 v20Taps;
+ v20Taps.x = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fEpsilon, fEpsilon ), objDepth, 1 ) ).x;
+ v20Taps.y = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fEpsilon, fEpsilon ), objDepth, 1 ) ).x;
+ v20Taps.z = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fEpsilon, -fEpsilon ), objDepth, 1 ) ).x;
+ v20Taps.w = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fEpsilon, -fEpsilon ), objDepth, 1 ) ).x;
+ float fl20Taps = dot( v20Taps, float4(20.0f / 331.0f, 20.0f / 331.0f, 20.0f / 331.0f, 20.0f / 331.0f));
+
+ float4 v33Taps;
+ v33Taps.x = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( fEpsilon, 0 ), objDepth, 1 ) ).x;
+ v33Taps.y = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( -fEpsilon, 0 ), objDepth, 1 ) ).x;
+ v33Taps.z = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( 0, -fEpsilon ), objDepth, 1 ) ).x;
+ v33Taps.w = tex2Dproj( DepthSampler, float4( shadowMapCenter + float2( 0, -fEpsilon ), objDepth, 1 ) ).x;
+ float fl33Taps = dot( v33Taps, float4(33.0f / 331.0f, 33.0f / 331.0f, 33.0f / 331.0f, 33.0f / 331.0f));
+
+ float flCenterTap = tex2Dproj( DepthSampler, float4( shadowMapCenter, objDepth, 1 ) ).x * (55.0f / 331.0f);
+
+ // Sum all 25 Taps
+ return flOneTaps + flSevenTaps + +flFourTapsA + flFourTapsB + fl20Taps + fl33Taps + flCenterTap;
+}
+
+
+float DoShadowATICheap( sampler DepthSampler, const float4 shadowMapPos )
+{
+ float2 shadowMapCenter = shadowMapPos.xy/shadowMapPos.w;
+ float objDepth = shadowMapPos.z / shadowMapPos.w;
+ float fSampleDepth = tex2D( DepthSampler, shadowMapCenter ).x;
+
+ objDepth = min( objDepth, 0.99999 ); //HACKHACK: On 360, surfaces at or past the far flashlight plane have an abrupt cutoff. This is temp until a smooth falloff is implemented
+
+ return fSampleDepth > objDepth;
+}
+
+
+// Poisson disc, randomly rotated at different UVs
+float DoShadowPoisson16Sample( sampler DepthSampler, sampler RandomRotationSampler, const float3 vProjCoords, const float2 vScreenPos, const float4 vShadowTweaks, bool bNvidiaHardwarePCF, bool bFetch4 )
+{
+ float2 vPoissonOffset[8] = { float2( 0.3475f, 0.0042f ),
+ float2( 0.8806f, 0.3430f ),
+ float2( -0.0041f, -0.6197f ),
+ float2( 0.0472f, 0.4964f ),
+ float2( -0.3730f, 0.0874f ),
+ float2( -0.9217f, -0.3177f ),
+ float2( -0.6289f, 0.7388f ),
+ float2( 0.5744f, -0.7741f ) };
+
+ float flScaleOverMapSize = vShadowTweaks.x * 2; // Tweak parameters to shader
+ float2 vNoiseOffset = vShadowTweaks.zw;
+ float4 vLightDepths = 0, accum = 0.0f;
+ float2 rotOffset = 0;
+
+ float2 shadowMapCenter = vProjCoords.xy; // Center of shadow filter
+ float objDepth = min( vProjCoords.z, 0.99999 ); // Object depth in shadow space
+
+ // 2D Rotation Matrix setup
+ float3 RMatTop = 0, RMatBottom = 0;
+#if defined(SHADER_MODEL_PS_2_0) || defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)
+ RMatTop.xy = tex2D( RandomRotationSampler, cFlashlightScreenScale.xy * (vScreenPos * 0.5 + 0.5) + vNoiseOffset) * 2.0 - 1.0;
+ RMatBottom.xy = float2(-1.0, 1.0) * RMatTop.yx; // 2x2 rotation matrix in 4-tuple
+#endif
+
+ RMatTop *= flScaleOverMapSize; // Scale up kernel while accounting for texture resolution
+ RMatBottom *= flScaleOverMapSize;
+
+ RMatTop.z = shadowMapCenter.x; // To be added in d2adds generated below
+ RMatBottom.z = shadowMapCenter.y;
+
+ float fResult = 0.0f;
+
+ if ( bNvidiaHardwarePCF )
+ {
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[0].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[0].xy) + RMatBottom.z;
+ vLightDepths.x += tex2Dproj( DepthSampler, float4(rotOffset, objDepth, 1) ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[1].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[1].xy) + RMatBottom.z;
+ vLightDepths.y += tex2Dproj( DepthSampler, float4(rotOffset, objDepth, 1) ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[2].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[2].xy) + RMatBottom.z;
+ vLightDepths.z += tex2Dproj( DepthSampler, float4(rotOffset, objDepth, 1) ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[3].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[3].xy) + RMatBottom.z;
+ vLightDepths.w += tex2Dproj( DepthSampler, float4(rotOffset, objDepth, 1) ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[4].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[4].xy) + RMatBottom.z;
+ vLightDepths.x += tex2Dproj( DepthSampler, float4(rotOffset, objDepth, 1) ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[5].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[5].xy) + RMatBottom.z;
+ vLightDepths.y += tex2Dproj( DepthSampler, float4(rotOffset, objDepth, 1) ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[6].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[6].xy) + RMatBottom.z;
+ vLightDepths.z += tex2Dproj( DepthSampler, float4(rotOffset, objDepth, 1) ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[7].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[7].xy) + RMatBottom.z;
+ vLightDepths.w += tex2Dproj( DepthSampler, float4(rotOffset, objDepth, 1) ).x;
+
+ fResult = dot( vLightDepths, float4( 0.25, 0.25, 0.25, 0.25) );
+ }
+ else if ( bFetch4 )
+ {
+/*
+
+TODO: Fix this contact hardening stuff
+
+ float flNumCloserSamples = 1;
+ float flAccumulatedCloserSamples = objDepth;
+ float4 vBlockerDepths;
+
+ // First, search for blockers
+ for( int j=0; j<8; j++ )
+ {
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[j].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[j].xy) + RMatBottom.z;
+ vBlockerDepths = tex2D( DepthSampler, rotOffset.xy );
+
+ // Which samples are closer than the pixel we're rendering?
+ float4 vCloserSamples = (vBlockerDepths < objDepth.xxxx ); // Binary comparison results
+ flNumCloserSamples += dot( vCloserSamples, float4(1, 1, 1, 1) ); // How many samples are closer than receiver?
+ flAccumulatedCloserSamples += dot (vCloserSamples, vBlockerDepths ); // Total depths from samples closer than receiver
+ }
+
+ float flBlockerDepth = flAccumulatedCloserSamples / flNumCloserSamples;
+ float flContactHardeningScale = (objDepth - flBlockerDepth) / flBlockerDepth;
+
+ // Scale the kernel
+ RMatTop.xy *= flContactHardeningScale;
+ RMatBottom.xy *= flContactHardeningScale;
+*/
+
+ for( int i=0; i<8; i++ )
+ {
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[i].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[i].xy) + RMatBottom.z;
+ vLightDepths = tex2D( DepthSampler, rotOffset.xy );
+ accum += (vLightDepths > objDepth.xxxx);
+ }
+
+ fResult = dot( accum, float4( 1.0f/32.0f, 1.0f/32.0f, 1.0f/32.0f, 1.0f/32.0f) );
+ }
+ else // ATI vanilla hardware shadow mapping
+ {
+ for( int i=0; i<2; i++ )
+ {
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[4*i+0].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[4*i+0].xy) + RMatBottom.z;
+ vLightDepths.x = tex2D( DepthSampler, rotOffset.xy ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[4*i+1].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[4*i+1].xy) + RMatBottom.z;
+ vLightDepths.y = tex2D( DepthSampler, rotOffset.xy ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[4*i+2].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[4*i+2].xy) + RMatBottom.z;
+ vLightDepths.z = tex2D( DepthSampler, rotOffset.xy ).x;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[4*i+3].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[4*i+3].xy) + RMatBottom.z;
+ vLightDepths.w = tex2D( DepthSampler, rotOffset.xy ).x;
+
+ accum += (vLightDepths > objDepth.xxxx);
+ }
+
+ fResult = dot( accum, float4( 0.125, 0.125, 0.125, 0.125) );
+ }
+
+ return fResult;
+}
+
+#if defined( _X360 )
+
+// Poisson disc, randomly rotated at different UVs
+float DoShadow360Simple( sampler DepthSampler, const float3 vProjCoords )
+{
+ float fLOD;
+ float2 shadowMapCenter = vProjCoords.xy; // Center of shadow filter
+ float objDepth = min( vProjCoords.z, 0.99999 ); // Object depth in shadow space
+
+#if defined( REVERSE_DEPTH_ON_X360 )
+ objDepth = 1.0f - objDepth;
+#endif
+
+ float4 vSampledDepths, vWeights;
+
+ asm {
+ getCompTexLOD2D fLOD.x, shadowMapCenter.xy, DepthSampler, AnisoFilter=max16to1
+ setTexLOD fLOD.x
+
+ tfetch2D vSampledDepths.x___, shadowMapCenter, DepthSampler, OffsetX = -0.5, OffsetY = -0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepths._x__, shadowMapCenter, DepthSampler, OffsetX = 0.5, OffsetY = -0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepths.__x_, shadowMapCenter, DepthSampler, OffsetX = -0.5, OffsetY = 0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepths.___x, shadowMapCenter, DepthSampler, OffsetX = 0.5, OffsetY = 0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+
+ getWeights2D vWeights, shadowMapCenter.xy, DepthSampler, MagFilter=linear, MinFilter=linear, UseComputedLOD=false, UseRegisterLOD=true
+ };
+
+ vWeights = float4( (1-vWeights.x)*(1-vWeights.y), vWeights.x*(1-vWeights.y), (1-vWeights.x)*vWeights.y, vWeights.x*vWeights.y );
+
+#if defined( REVERSE_DEPTH_ON_X360 )
+ float4 vCompare = (vSampledDepths < objDepth.xxxx);
+#else
+ float4 vCompare = (vSampledDepths > objDepth.xxxx);
+#endif
+
+ return dot( vCompare, vWeights );
+}
+
+
+float Do360PCFFetch( sampler DepthSampler, float2 tc, float objDepth )
+{
+ float fLOD;
+ float4 vSampledDepths, vWeights;
+
+ asm {
+ getCompTexLOD2D fLOD.x, tc.xy, DepthSampler, AnisoFilter=max16to1
+ setTexLOD fLOD.x
+
+ tfetch2D vSampledDepths.x___, tc, DepthSampler, OffsetX = -0.5, OffsetY = -0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepths._x__, tc, DepthSampler, OffsetX = 0.5, OffsetY = -0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepths.__x_, tc, DepthSampler, OffsetX = -0.5, OffsetY = 0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepths.___x, tc, DepthSampler, OffsetX = 0.5, OffsetY = 0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+
+ getWeights2D vWeights, tc.xy, DepthSampler, MagFilter=linear, MinFilter=linear, UseComputedLOD=false, UseRegisterLOD=true
+ };
+
+ vWeights = float4( (1-vWeights.x)*(1-vWeights.y), vWeights.x*(1-vWeights.y), (1-vWeights.x)*vWeights.y, vWeights.x*vWeights.y );
+
+#if defined( REVERSE_DEPTH_ON_X360 )
+ float4 vCompare = (vSampledDepths < objDepth.xxxx);
+#else
+ float4 vCompare = (vSampledDepths > objDepth.xxxx);
+#endif
+
+ return dot( vCompare, vWeights );
+}
+
+
+
+float Do360NearestFetch( sampler DepthSampler, float2 tc, float objDepth )
+{
+ float fLOD;
+ float4 vSampledDepth;
+
+ asm {
+ getCompTexLOD2D fLOD.x, tc.xy, DepthSampler, AnisoFilter=max16to1
+ setTexLOD fLOD.x
+
+ tfetch2D vSampledDepth.x___, tc, DepthSampler, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ };
+
+#if defined( REVERSE_DEPTH_ON_X360 )
+ return (vSampledDepth.x < objDepth.x);
+#else
+ return (vSampledDepth.x > objDepth.x);
+#endif
+
+}
+
+
+float AmountShadowed_8Tap_360( sampler DepthSampler, float2 tc, float objDepth )
+{
+ float fLOD;
+ float4 vSampledDepthsA, vSampledDepthsB;
+
+ // Optimal 8 rooks pattern to get an idea about whether we're at a penumbra or not
+ // From [Kallio07] "Scanline Edge-Flag Algorithm for Antialiasing"
+ //
+ // +---+---+---+---+---+---+---+---+
+ // | | | | | | o | | |
+ // +---+---+---+---+---+---+---+---+
+ // | o | | | | | | | |
+ // +---+---+---+---+---+---+---+---+
+ // | | | | o | | | | |
+ // +---+---+---+---+---+---+---+---+
+ // | | | | | | | o | |
+ // +---+---+---+---+---+---+---+---+
+ // | | o | | | | | | |
+ // +---+---+---+---+---+---+---+---+
+ // | | | | | o | | | |
+ // +---+---+---+---+---+---+---+---+
+ // | | | | | | | | o |
+ // +---+---+---+---+---+---+---+---+
+ // | | | o | | | | | |
+ // +---+---+---+---+---+---+---+---+
+ //
+ asm {
+ getCompTexLOD2D fLOD.x, tc.xy, DepthSampler, AnisoFilter=max16to1
+ setTexLOD fLOD.x
+
+ tfetch2D vSampledDepthsA.x___, tc, DepthSampler, OffsetX = -2.0, OffsetY = -1.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepthsA._x__, tc, DepthSampler, OffsetX = -1.5, OffsetY = 0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepthsA.__x_, tc, DepthSampler, OffsetX = -1.0, OffsetY = 2.0, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepthsA.___x, tc, DepthSampler, OffsetX = -0.5, OffsetY = -1.0, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+
+ tfetch2D vSampledDepthsB.x___, tc, DepthSampler, OffsetX = 0.5, OffsetY = 1.0, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepthsB._x__, tc, DepthSampler, OffsetX = 1.0, OffsetY = -2.0, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepthsB.__x_, tc, DepthSampler, OffsetX = 1.5, OffsetY = -0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepthsB.___x, tc, DepthSampler, OffsetX = 2.0, OffsetY = 1.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ };
+
+#if defined( REVERSE_DEPTH_ON_X360 )
+ float4 vCompareA = (vSampledDepthsA < objDepth.xxxx);
+ float4 vCompareB = (vSampledDepthsB < objDepth.xxxx);
+#else
+ float4 vCompareA = (vSampledDepthsA > objDepth.xxxx);
+ float4 vCompareB = (vSampledDepthsB > objDepth.xxxx);
+#endif
+
+ return dot( vCompareA, float4(0.125,0.125,0.125,0.125) ) + dot( vCompareB, float4(0.125,0.125,0.125,0.125) );
+}
+
+
+float AmountShadowed_4Tap_360( sampler DepthSampler, float2 tc, float objDepth )
+{
+ float fLOD;
+ float4 vSampledDepths;
+
+ // Rotated grid pattern to get an idea about whether we're at a penumbra or not
+ asm {
+ getCompTexLOD2D fLOD.x, tc.xy, DepthSampler, AnisoFilter=max16to1
+ setTexLOD fLOD.x
+
+ tfetch2D vSampledDepths.x___, tc, DepthSampler, OffsetX = -1.0, OffsetY = 0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepths._x__, tc, DepthSampler, OffsetX = -0.5, OffsetY = -1.0, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepths.__x_, tc, DepthSampler, OffsetX = 0.5, OffsetY = 1.0, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ tfetch2D vSampledDepths.___x, tc, DepthSampler, OffsetX = 1.0, OffsetY = -0.5, UseComputedLOD=false, UseRegisterLOD=true, MagFilter = point, MinFilter = point
+ };
+
+#if defined( REVERSE_DEPTH_ON_X360 )
+ float4 vCompare = (vSampledDepths < objDepth.xxxx);
+#else
+ float4 vCompare = (vSampledDepths > objDepth.xxxx);
+#endif
+
+ return dot( vCompare, float4(0.25,0.25,0.25,0.25) );
+}
+
+// Poisson disc, randomly rotated at different UVs
+float DoShadowPoisson360( sampler DepthSampler, sampler RandomRotationSampler, const float3 vProjCoords, const float2 vScreenPos, const float4 vShadowTweaks )
+{
+ float2 vPoissonOffset[8] = { float2( 0.3475f, 0.0042f ), float2( 0.8806f, 0.3430f ),
+ float2( -0.0041f, -0.6197f ), float2( 0.0472f, 0.4964f ),
+ float2( -0.3730f, 0.0874f ), float2( -0.9217f, -0.3177f ),
+ float2( -0.6289f, 0.7388f ), float2( 0.5744f, -0.7741f ) };
+
+ float2 shadowMapCenter = vProjCoords.xy; // Center of shadow filter
+ float objDepth = min( vProjCoords.z, 0.99999 ); // Object depth in shadow space
+
+#if defined( REVERSE_DEPTH_ON_X360 )
+ objDepth = 1.0f - objDepth;
+#endif
+
+ float fAmountShadowed = AmountShadowed_4Tap_360( DepthSampler, shadowMapCenter, objDepth );
+
+ if ( fAmountShadowed >= 1.0f ) // Fully in light
+ {
+ return 1.0f;
+ }
+ else // Do the expensive filtering since we're at least partially shadowed
+ {
+ float flScaleOverMapSize = 1.7f / 512.0f; // Tweak parameters to shader
+
+ // 2D Rotation Matrix setup
+ float3 RMatTop = 0, RMatBottom = 0;
+#if defined(SHADER_MODEL_PS_2_0) || defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)
+ RMatTop.xy = tex2D( RandomRotationSampler, cFlashlightScreenScale.xy * (vScreenPos * 0.5 + 0.5)) * 2.0 - 1.0;
+ RMatBottom.xy = float2(-1.0, 1.0) * RMatTop.yx; // 2x2 rotation matrix in 4-tuple
+#endif
+
+ RMatTop *= flScaleOverMapSize; // Scale up kernel while accounting for texture resolution
+ RMatBottom *= flScaleOverMapSize;
+ RMatTop.z = shadowMapCenter.x; // To be added in d2adds generated below
+ RMatBottom.z = shadowMapCenter.y;
+ float2 rotOffset = float2(0,0);
+ float4 vAccum = 0;
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[0].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[0].xy) + RMatBottom.z;
+ vAccum.x = Do360NearestFetch( DepthSampler, rotOffset, objDepth );
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[1].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[1].xy) + RMatBottom.z;
+ vAccum.y = Do360NearestFetch( DepthSampler, rotOffset, objDepth );
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[2].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[2].xy) + RMatBottom.z;
+ vAccum.z = Do360NearestFetch( DepthSampler, rotOffset, objDepth );
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[3].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[3].xy) + RMatBottom.z;
+ vAccum.w = Do360NearestFetch( DepthSampler, rotOffset, objDepth );
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[4].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[4].xy) + RMatBottom.z;
+ vAccum.x += Do360NearestFetch( DepthSampler, rotOffset, objDepth );
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[5].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[5].xy) + RMatBottom.z;
+ vAccum.y += Do360NearestFetch( DepthSampler, rotOffset, objDepth );
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[6].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[6].xy) + RMatBottom.z;
+ vAccum.z += Do360NearestFetch( DepthSampler, rotOffset, objDepth );
+
+ rotOffset.x = dot (RMatTop.xy, vPoissonOffset[7].xy) + RMatTop.z;
+ rotOffset.y = dot (RMatBottom.xy, vPoissonOffset[7].xy) + RMatBottom.z;
+ vAccum.w += Do360NearestFetch( DepthSampler, rotOffset, objDepth );
+
+ return dot( vAccum, float4( 0.25, 0.25, 0.25, 0.25) );
+ }
+}
+
+#endif // _X360
+
+
+float DoFlashlightShadow( sampler DepthSampler, sampler RandomRotationSampler, float3 vProjCoords, float2 vScreenPos, int nShadowLevel, float4 vShadowTweaks, bool bAllowHighQuality )
+{
+ float flShadow = 1.0f;
+
+#if !defined( _X360 ) //PC
+ if( nShadowLevel == NVIDIA_PCF_POISSON )
+ flShadow = DoShadowPoisson16Sample( DepthSampler, RandomRotationSampler, vProjCoords, vScreenPos, vShadowTweaks, true, false );
+ else if( nShadowLevel == ATI_NOPCF )
+ flShadow = DoShadowPoisson16Sample( DepthSampler, RandomRotationSampler, vProjCoords, vScreenPos, vShadowTweaks, false, false );
+ else if( nShadowLevel == ATI_NO_PCF_FETCH4 )
+ flShadow = DoShadowPoisson16Sample( DepthSampler, RandomRotationSampler, vProjCoords, vScreenPos, vShadowTweaks, false, true );
+
+ return flShadow;
+#else
+
+ // Compile-time switch for shaders which allow high quality modes on 360
+ if ( bAllowHighQuality )
+ {
+ // Static control flow switch for shadow quality. Some non-interactive sequences use the high quality path
+ if ( g_bHighQualityShadows )
+ {
+ flShadow = DoShadowPoisson360( DepthSampler, RandomRotationSampler, vProjCoords, vScreenPos, vShadowTweaks );
+ }
+ else
+ {
+ flShadow = DoShadow360Simple( DepthSampler, vProjCoords );
+ }
+ }
+ else
+ {
+ flShadow = DoShadow360Simple( DepthSampler, vProjCoords );
+ }
+
+ return flShadow;
+
+#endif
+}
+
+float3 SpecularLight( const float3 vWorldNormal, const float3 vLightDir, const float fSpecularExponent,
+ const float3 vEyeDir, const bool bDoSpecularWarp, in sampler specularWarpSampler, float fFresnel )
+{
+ float3 result = float3(0.0f, 0.0f, 0.0f);
+
+ //float3 vReflect = reflect( -vEyeDir, vWorldNormal );
+ float3 vReflect = 2 * vWorldNormal * dot( vWorldNormal , vEyeDir ) - vEyeDir; // Reflect view through normal
+ float3 vSpecular = saturate(dot( vReflect, vLightDir )); // L.R (use half-angle instead?)
+ vSpecular = pow( vSpecular.x, fSpecularExponent ); // Raise to specular power
+
+ // Optionally warp as function of scalar specular and fresnel
+ if ( bDoSpecularWarp )
+ vSpecular *= tex2D( specularWarpSampler, float2(vSpecular.x, fFresnel) ); // Sample at { (L.R)^k, fresnel }
+
+ return vSpecular;
+}
+
+void DoSpecularFlashlight( float3 flashlightPos, float3 worldPos, float4 flashlightSpacePosition, float3 worldNormal,
+ float3 attenuationFactors, float farZ, sampler FlashlightSampler, sampler FlashlightDepthSampler, sampler RandomRotationSampler,
+ int nShadowLevel, bool bDoShadows, bool bAllowHighQuality, const float2 vScreenPos, const float fSpecularExponent, const float3 vEyeDir,
+ const bool bDoSpecularWarp, sampler specularWarpSampler, float fFresnel, float4 vShadowTweaks,
+
+ // Outputs of this shader...separate shadowed diffuse and specular from the flashlight
+ out float3 diffuseLighting, out float3 specularLighting )
+{
+ float3 vProjCoords = flashlightSpacePosition.xyz / flashlightSpacePosition.w;
+ float3 flashlightColor = float3(1,1,1);
+
+#if ( defined( _X360 ) )
+
+ float3 ltz = vProjCoords.xyz < float3( 0.0f, 0.0f, 0.0f );
+ float3 gto = vProjCoords.xyz > float3( 1.0f, 1.0f, 1.0f );
+
+ [branch]
+ if ( dot(ltz + gto, float3(1,1,1)) > 0 )
+ {
+ clip(-1);
+ diffuseLighting = specularLighting = float3(0,0,0);
+ return;
+ }
+ else
+ {
+ flashlightColor = tex2D( FlashlightSampler, vProjCoords );
+
+ [branch]
+ if ( dot(flashlightColor.xyz, float3(1,1,1)) <= 0 )
+ {
+ clip(-1);
+ diffuseLighting = specularLighting = float3(0,0,0);
+ return;
+ }
+ }
+#else
+ flashlightColor = tex2D( FlashlightSampler, vProjCoords );
+#endif
+
+
+#if defined(SHADER_MODEL_PS_2_0) || defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)
+ flashlightColor *= cFlashlightColor.xyz; // Flashlight color
+#endif
+
+ float3 delta = flashlightPos - worldPos;
+ float3 L = normalize( delta );
+ float distSquared = dot( delta, delta );
+ float dist = sqrt( distSquared );
+
+ float endFalloffFactor = RemapValClamped( dist, farZ, 0.6f * farZ, 0.0f, 1.0f );
+
+ // Attenuation for light and to fade out shadow over distance
+ float fAtten = saturate( dot( attenuationFactors, float3( 1.0f, 1.0f/dist, 1.0f/distSquared ) ) );
+
+ // Shadowing and coloring terms
+#if (defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0))
+ if ( bDoShadows )
+ {
+ float flShadow = DoFlashlightShadow( FlashlightDepthSampler, RandomRotationSampler, vProjCoords, vScreenPos, nShadowLevel, vShadowTweaks, bAllowHighQuality );
+ float flAttenuated = lerp( flShadow, 1.0f, vShadowTweaks.y ); // Blend between fully attenuated and not attenuated
+ flShadow = saturate( lerp( flAttenuated, flShadow, fAtten ) ); // Blend between shadow and above, according to light attenuation
+ flashlightColor *= flShadow; // Shadow term
+ }
+#endif
+
+ diffuseLighting = fAtten;
+#if defined(SHADER_MODEL_PS_2_0) || defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)
+ diffuseLighting *= saturate( dot( L.xyz, worldNormal.xyz ) + flFlashlightNoLambertValue ); // Lambertian term
+#else
+ diffuseLighting *= saturate( dot( L.xyz, worldNormal.xyz ) ); // Lambertian (not Half-Lambert) term
+#endif
+ diffuseLighting *= flashlightColor;
+ diffuseLighting *= endFalloffFactor;
+
+ // Specular term (masked by diffuse)
+ specularLighting = diffuseLighting * SpecularLight ( worldNormal, L, fSpecularExponent, vEyeDir, bDoSpecularWarp, specularWarpSampler, fFresnel );
+}
+
+// Diffuse only version
+float3 DoFlashlight( float3 flashlightPos, float3 worldPos, float4 flashlightSpacePosition, float3 worldNormal,
+ float3 attenuationFactors, float farZ, sampler FlashlightSampler, sampler FlashlightDepthSampler,
+ sampler RandomRotationSampler, int nShadowLevel, bool bDoShadows, bool bAllowHighQuality,
+ const float2 vScreenPos, bool bClip, float4 vShadowTweaks = float4(3/1024.0f, 0.0005f, 0.0f, 0.0f), bool bHasNormal = true )
+{
+ float3 vProjCoords = flashlightSpacePosition.xyz / flashlightSpacePosition.w;
+ float3 flashlightColor = float3(1,1,1);
+
+#if ( defined( _X360 ) )
+
+ float3 ltz = vProjCoords.xyz < float3( 0.0f, 0.0f, 0.0f );
+ float3 gto = vProjCoords.xyz > float3( 1.0f, 1.0f, 1.0f );
+
+ [branch]
+ if ( dot(ltz + gto, float3(1,1,1)) > 0 )
+ {
+ if ( bClip )
+ {
+ clip(-1);
+ }
+ return float3(0,0,0);
+ }
+ else
+ {
+ flashlightColor = tex2D( FlashlightSampler, vProjCoords );
+
+ [branch]
+ if ( dot(flashlightColor.xyz, float3(1,1,1)) <= 0 )
+ {
+ if ( bClip )
+ {
+ clip(-1);
+ }
+ return float3(0,0,0);
+ }
+ }
+#else
+ flashlightColor = tex2D( FlashlightSampler, vProjCoords );
+#endif
+
+#if defined(SHADER_MODEL_PS_2_0) || defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)
+ flashlightColor *= cFlashlightColor.xyz; // Flashlight color
+#endif
+
+ float3 delta = flashlightPos - worldPos;
+ float3 L = normalize( delta );
+ float distSquared = dot( delta, delta );
+ float dist = sqrt( distSquared );
+
+ float endFalloffFactor = RemapValClamped( dist, farZ, 0.6f * farZ, 0.0f, 1.0f );
+
+ // Attenuation for light and to fade out shadow over distance
+ float fAtten = saturate( dot( attenuationFactors, float3( 1.0f, 1.0f/dist, 1.0f/distSquared ) ) );
+
+ // Shadowing and coloring terms
+#if (defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0))
+ if ( bDoShadows )
+ {
+ float flShadow = DoFlashlightShadow( FlashlightDepthSampler, RandomRotationSampler, vProjCoords, vScreenPos, nShadowLevel, vShadowTweaks, bAllowHighQuality );
+ float flAttenuated = lerp( flShadow, 1.0f, vShadowTweaks.y ); // Blend between fully attenuated and not attenuated
+ flShadow = saturate( lerp( flAttenuated, flShadow, fAtten ) ); // Blend between shadow and above, according to light attenuation
+ flashlightColor *= flShadow; // Shadow term
+ }
+#endif
+
+ float3 diffuseLighting = fAtten;
+
+ float flLDotWorldNormal;
+ if ( bHasNormal )
+ {
+ flLDotWorldNormal = dot( L.xyz, worldNormal.xyz );
+ }
+ else
+ {
+ flLDotWorldNormal = 1.0f;
+ }
+
+#if defined(SHADER_MODEL_PS_2_0) || defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)
+ diffuseLighting *= saturate( flLDotWorldNormal + flFlashlightNoLambertValue ); // Lambertian term
+#else
+ diffuseLighting *= saturate( flLDotWorldNormal ); // Lambertian (not Half-Lambert) term
+#endif
+
+ diffuseLighting *= flashlightColor;
+ diffuseLighting *= endFalloffFactor;
+
+ return diffuseLighting;
+}
+
+#endif //#ifndef COMMON_FLASHLIGHT_FXC_H_
diff --git a/mp/src/materialsystem/stdshaders/common_fxc.h b/mp/src/materialsystem/stdshaders/common_fxc.h new file mode 100644 index 00000000..b81c9a46 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/common_fxc.h @@ -0,0 +1,326 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#ifndef COMMON_FXC_H_
+#define COMMON_FXC_H_
+
+#include "common_pragmas.h"
+#include "common_hlsl_cpp_consts.h"
+
+#ifdef NV3X
+# define HALF half
+# define HALF2 half2
+# define HALF3 half3
+# define HALF4 half4
+# define HALF3x3 half3x3
+# define HALF3x4 half3x4
+# define HALF4x3 half4x3
+# define HALF_CONSTANT( _constant ) ((HALF)_constant)
+#else
+# define HALF float
+# define HALF2 float2
+# define HALF3 float3
+# define HALF4 float4
+# define HALF3x3 float3x3
+# define HALF3x4 float3x4
+# define HALF4x3 float4x3
+# define HALF_CONSTANT( _constant ) _constant
+#endif
+
+// This is where all common code for both vertex and pixel shaders.
+#define OO_SQRT_3 0.57735025882720947f
+static const HALF3 bumpBasis[3] = {
+ HALF3( 0.81649661064147949f, 0.0f, OO_SQRT_3 ),
+ HALF3( -0.40824833512306213f, 0.70710676908493042f, OO_SQRT_3 ),
+ HALF3( -0.40824821591377258f, -0.7071068286895752f, OO_SQRT_3 )
+};
+static const HALF3 bumpBasisTranspose[3] = {
+ HALF3( 0.81649661064147949f, -0.40824833512306213f, -0.40824833512306213f ),
+ HALF3( 0.0f, 0.70710676908493042f, -0.7071068286895752f ),
+ HALF3( OO_SQRT_3, OO_SQRT_3, OO_SQRT_3 )
+};
+
+#if defined( _X360 )
+#define REVERSE_DEPTH_ON_X360 //uncomment to use D3DFMT_D24FS8 with an inverted depth viewport for better performance. Keep this in sync with the same named #define in public/shaderapi/shareddefs.h
+//Note that the reversal happens in the viewport. So ONLY reading back from a depth texture should be affected. Projected math is unaffected.
+#endif
+
+HALF3 CalcReflectionVectorNormalized( HALF3 normal, HALF3 eyeVector )
+{
+ // FIXME: might be better of normalizing with a normalizing cube map and
+ // get rid of the dot( normal, normal )
+ // compute reflection vector r = 2 * ((n dot v)/(n dot n)) n - v
+ return 2.0 * ( dot( normal, eyeVector ) / dot( normal, normal ) ) * normal - eyeVector;
+}
+
+HALF3 CalcReflectionVectorUnnormalized( HALF3 normal, HALF3 eyeVector )
+{
+ // FIXME: might be better of normalizing with a normalizing cube map and
+ // get rid of the dot( normal, normal )
+ // compute reflection vector r = 2 * ((n dot v)/(n dot n)) n - v
+ // multiply all values through by N.N. uniformly scaling reflection vector won't affect result
+ // since it is used in a cubemap lookup
+ return (2.0*(dot( normal, eyeVector ))*normal) - (dot( normal, normal )*eyeVector);
+}
+
+float3 HuePreservingColorClamp( float3 c )
+{
+ // Get the max of all of the color components and a specified maximum amount
+ float maximum = max( max( c.x, c.y ), max( c.z, 1.0f ) );
+
+ return (c / maximum);
+}
+
+HALF3 HuePreservingColorClamp( HALF3 c, HALF maxVal )
+{
+ // Get the max of all of the color components and a specified maximum amount
+ float maximum = max( max( c.x, c.y ), max( c.z, maxVal ) );
+ return (c * ( maxVal / maximum ) );
+}
+
+#if (AA_CLAMP==1)
+HALF2 ComputeLightmapCoordinates( HALF4 Lightmap1and2Coord, HALF2 Lightmap3Coord )
+{
+ HALF2 result = saturate(Lightmap1and2Coord.xy) * Lightmap1and2Coord.wz * 0.99;
+ result += Lightmap3Coord;
+ return result;
+}
+
+void ComputeBumpedLightmapCoordinates( HALF4 Lightmap1and2Coord, HALF2 Lightmap3Coord,
+ out HALF2 bumpCoord1,
+ out HALF2 bumpCoord2,
+ out HALF2 bumpCoord3 )
+{
+ HALF2 result = saturate(Lightmap1and2Coord.xy) * Lightmap1and2Coord.wz * 0.99;
+ result += Lightmap3Coord;
+ bumpCoord1 = result + HALF2(Lightmap1and2Coord.z, 0);
+ bumpCoord2 = result + 2*HALF2(Lightmap1and2Coord.z, 0);
+ bumpCoord3 = result + 3*HALF2(Lightmap1and2Coord.z, 0);
+}
+#else
+HALF2 ComputeLightmapCoordinates( HALF4 Lightmap1and2Coord, HALF2 Lightmap3Coord )
+{
+ return Lightmap1and2Coord.xy;
+}
+
+void ComputeBumpedLightmapCoordinates( HALF4 Lightmap1and2Coord, HALF2 Lightmap3Coord,
+ out HALF2 bumpCoord1,
+ out HALF2 bumpCoord2,
+ out HALF2 bumpCoord3 )
+{
+ bumpCoord1 = Lightmap1and2Coord.xy;
+ bumpCoord2 = Lightmap1and2Coord.wz; // reversed order!!!
+ bumpCoord3 = Lightmap3Coord.xy;
+}
+#endif
+
+// Versions of matrix multiply functions which force HLSL compiler to explictly use DOTs,
+// not giving it the option of using MAD expansion. In a perfect world, the compiler would
+// always pick the best strategy, and these shouldn't be needed.. but.. well.. umm..
+//
+// lorenmcq
+
+float3 mul3x3(float3 v, float3x3 m)
+{
+#if !defined( _X360 )
+ return float3(dot(v, transpose(m)[0]), dot(v, transpose(m)[1]), dot(v, transpose(m)[2]));
+#else
+ // xbox360 fxc.exe (new back end) borks with transposes, generates bad code
+ return mul( v, m );
+#endif
+}
+
+float3 mul4x3(float4 v, float4x3 m)
+{
+#if !defined( _X360 )
+ return float3(dot(v, transpose(m)[0]), dot(v, transpose(m)[1]), dot(v, transpose(m)[2]));
+#else
+ // xbox360 fxc.exe (new back end) borks with transposes, generates bad code
+ return mul( v, m );
+#endif
+}
+
+float3 DecompressHDR( float4 input )
+{
+ return input.rgb * input.a * MAX_HDR_OVERBRIGHT;
+}
+
+float4 CompressHDR( float3 input )
+{
+ // FIXME: want to use min so that we clamp to white, but what happens if we
+ // have an albedo component that's less than 1/MAX_HDR_OVERBRIGHT?
+ // float fMax = max( max( color.r, color.g ), color.b );
+ float4 output;
+ float fMax = min( min( input.r, input.g ), input.b );
+ if( fMax > 1.0f )
+ {
+ float oofMax = 1.0f / fMax;
+ output.rgb = oofMax * input.rgb;
+ output.a = min( fMax / MAX_HDR_OVERBRIGHT, 1.0f );
+ }
+ else
+ {
+ output.rgb = input.rgb;
+ output.a = 0.0f;
+ }
+ return output;
+}
+
+
+float3 LinearToGamma( const float3 f3linear )
+{
+ return pow( f3linear, 1.0f / 2.2f );
+}
+
+float4 LinearToGamma( const float4 f4linear )
+{
+ return float4( pow( f4linear.xyz, 1.0f / 2.2f ), f4linear.w );
+}
+
+float LinearToGamma( const float f1linear )
+{
+ return pow( f1linear, 1.0f / 2.2f );
+}
+
+float3 GammaToLinear( const float3 gamma )
+{
+ return pow( gamma, 2.2f );
+}
+
+float4 GammaToLinear( const float4 gamma )
+{
+ return float4( pow( gamma.xyz, 2.2f ), gamma.w );
+}
+
+float GammaToLinear( const float gamma )
+{
+ return pow( gamma, 2.2f );
+}
+
+// These two functions use the actual sRGB math
+float SrgbGammaToLinear( float flSrgbGammaValue )
+{
+ float x = saturate( flSrgbGammaValue );
+ return ( x <= 0.04045f ) ? ( x / 12.92f ) : ( pow( ( x + 0.055f ) / 1.055f, 2.4f ) );
+}
+
+float SrgbLinearToGamma( float flLinearValue )
+{
+ float x = saturate( flLinearValue );
+ return ( x <= 0.0031308f ) ? ( x * 12.92f ) : ( 1.055f * pow( x, ( 1.0f / 2.4f ) ) ) - 0.055f;
+}
+
+// These twofunctions use the XBox 360's exact piecewise linear algorithm
+float X360GammaToLinear( float fl360GammaValue )
+{
+ float flLinearValue;
+
+ fl360GammaValue = saturate( fl360GammaValue );
+ if ( fl360GammaValue < ( 96.0f / 255.0f ) )
+ {
+ if ( fl360GammaValue < ( 64.0f / 255.0f ) )
+ {
+ flLinearValue = fl360GammaValue * 255.0f;
+ }
+ else
+ {
+ flLinearValue = fl360GammaValue * ( 255.0f * 2.0f ) - 64.0f;
+ flLinearValue += floor( flLinearValue * ( 1.0f / 512.0f ) );
+ }
+ }
+ else
+ {
+ if( fl360GammaValue < ( 192.0f / 255.0f ) )
+ {
+ flLinearValue = fl360GammaValue * ( 255.0f * 4.0f ) - 256.0f;
+ flLinearValue += floor( flLinearValue * ( 1.0f / 256.0f ) );
+ }
+ else
+ {
+ flLinearValue = fl360GammaValue * ( 255.0f * 8.0f ) - 1024.0f;
+ flLinearValue += floor( flLinearValue * ( 1.0f / 128.0f ) );
+ }
+ }
+
+ flLinearValue *= 1.0f / 1023.0f;
+
+ flLinearValue = saturate( flLinearValue );
+ return flLinearValue;
+}
+
+float X360LinearToGamma( float flLinearValue )
+{
+ float fl360GammaValue;
+
+ flLinearValue = saturate( flLinearValue );
+ if ( flLinearValue < ( 128.0f / 1023.0f ) )
+ {
+ if ( flLinearValue < ( 64.0f / 1023.0f ) )
+ {
+ fl360GammaValue = flLinearValue * ( 1023.0f * ( 1.0f / 255.0f ) );
+ }
+ else
+ {
+ fl360GammaValue = flLinearValue * ( ( 1023.0f / 2.0f ) * ( 1.0f / 255.0f ) ) + ( 32.0f / 255.0f );
+ }
+ }
+ else
+ {
+ if ( flLinearValue < ( 512.0f / 1023.0f ) )
+ {
+ fl360GammaValue = flLinearValue * ( ( 1023.0f / 4.0f ) * ( 1.0f / 255.0f ) ) + ( 64.0f / 255.0f );
+ }
+ else
+ {
+ fl360GammaValue = flLinearValue * ( ( 1023.0f /8.0f ) * ( 1.0f / 255.0f ) ) + ( 128.0f /255.0f ); // 1.0 -> 1.0034313725490196078431372549016
+ if ( fl360GammaValue > 1.0f )
+ {
+ fl360GammaValue = 1.0f;
+ }
+ }
+ }
+
+ fl360GammaValue = saturate( fl360GammaValue );
+ return fl360GammaValue;
+}
+
+float SrgbGammaTo360Gamma( float flSrgbGammaValue )
+{
+ float flLinearValue = SrgbGammaToLinear( flSrgbGammaValue );
+ float fl360GammaValue = X360LinearToGamma( flLinearValue );
+ return fl360GammaValue;
+}
+
+float3 Vec3WorldToTangent( float3 iWorldVector, float3 iWorldNormal, float3 iWorldTangent, float3 iWorldBinormal )
+{
+ float3 vTangentVector;
+ vTangentVector.x = dot( iWorldVector.xyz, iWorldTangent.xyz );
+ vTangentVector.y = dot( iWorldVector.xyz, iWorldBinormal.xyz );
+ vTangentVector.z = dot( iWorldVector.xyz, iWorldNormal.xyz );
+ return vTangentVector.xyz; // Return without normalizing
+}
+
+float3 Vec3WorldToTangentNormalized( float3 iWorldVector, float3 iWorldNormal, float3 iWorldTangent, float3 iWorldBinormal )
+{
+ return normalize( Vec3WorldToTangent( iWorldVector, iWorldNormal, iWorldTangent, iWorldBinormal ) );
+}
+
+float3 Vec3TangentToWorld( float3 iTangentVector, float3 iWorldNormal, float3 iWorldTangent, float3 iWorldBinormal )
+{
+ float3 vWorldVector;
+ vWorldVector.xyz = iTangentVector.x * iWorldTangent.xyz;
+ vWorldVector.xyz += iTangentVector.y * iWorldBinormal.xyz;
+ vWorldVector.xyz += iTangentVector.z * iWorldNormal.xyz;
+ return vWorldVector.xyz; // Return without normalizing
+}
+
+float3 Vec3TangentToWorldNormalized( float3 iTangentVector, float3 iWorldNormal, float3 iWorldTangent, float3 iWorldBinormal )
+{
+ return normalize( Vec3TangentToWorld( iTangentVector, iWorldNormal, iWorldTangent, iWorldBinormal ) );
+}
+
+#endif //#ifndef COMMON_FXC_H_
diff --git a/mp/src/materialsystem/stdshaders/common_fxc2.h b/mp/src/materialsystem/stdshaders/common_fxc2.h new file mode 100644 index 00000000..7ee8b48c --- /dev/null +++ b/mp/src/materialsystem/stdshaders/common_fxc2.h @@ -0,0 +1,19 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#ifndef COMMON_FXC2_H_
+#define COMMON_FXC2_H_
+
+// This file is here so you can add new utility functions without
+// changing common_fxc.h and causing a recompile of the entire universe.
+
+float LinearToMonochrome ( float3 r )
+{
+ return dot( r, float3( 0.299f, 0.587f, 0.114f ) );
+}
+
+#endif //#ifndef COMMON_FXC2_H_
diff --git a/mp/src/materialsystem/stdshaders/common_hlsl_cpp_consts.h b/mp/src/materialsystem/stdshaders/common_hlsl_cpp_consts.h new file mode 100644 index 00000000..523feee4 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/common_hlsl_cpp_consts.h @@ -0,0 +1,27 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#ifndef COMMON_HLSL_CONSTS_H_
+#define COMMON_HLSL_CONSTS_H_
+
+#ifdef NV3X
+ #define PSHADER_VECT_SCALE 20.0
+ #define VSHADER_VECT_SCALE (1.0 / (PSHADER_VECT_SCALE) )
+#else
+ #define PSHADER_VECT_SCALE 1.0
+ #define VSHADER_VECT_SCALE 1.0
+#endif
+
+// GR - HDR luminance maps to 0..n range
+// IMPORTANT: Keep the same value as in materialsystem_global.h
+// HDRFIXME: Make this a pixel shader constant?
+#define MAX_HDR_OVERBRIGHT 16.0f
+
+#define LINEAR_FOG_COLOR 29
+#define TONE_MAPPING_SCALE_PSH_CONSTANT 30
+
+#endif //#ifndef COMMON_HLSL_CONSTS_H_
diff --git a/mp/src/materialsystem/stdshaders/common_lightmappedgeneric_fxc.h b/mp/src/materialsystem/stdshaders/common_lightmappedgeneric_fxc.h new file mode 100644 index 00000000..e82bdf65 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/common_lightmappedgeneric_fxc.h @@ -0,0 +1,202 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+
+
+#if defined( _X360 )
+
+void GetBaseTextureAndNormal( sampler base, sampler base2, sampler bump, bool bBase2, bool bBump, float3 coords, float3 vWeights,
+ out float4 vResultBase, out float4 vResultBase2, out float4 vResultBump )
+{
+ vResultBase = 0;
+ vResultBase2 = 0;
+ vResultBump = 0;
+
+ if ( !bBump )
+ {
+ vResultBump = float4(0, 0, 1, 1);
+ }
+
+#if SEAMLESS
+
+ vWeights = max( vWeights - 0.3, 0 );
+
+ vWeights *= 1.0f / dot( vWeights, float3(1,1,1) );
+
+ [branch]
+ if (vWeights.x > 0)
+ {
+ vResultBase += vWeights.x * tex2D( base, coords.zy );
+
+ if ( bBase2 )
+ {
+ vResultBase2 += vWeights.x * tex2D( base2, coords.zy );
+ }
+
+ if ( bBump )
+ {
+ vResultBump += vWeights.x * tex2D( bump, coords.zy );
+ }
+ }
+
+ [branch]
+ if (vWeights.y > 0)
+ {
+ vResultBase += vWeights.y * tex2D( base, coords.xz );
+
+ if ( bBase2 )
+ {
+ vResultBase2 += vWeights.y * tex2D( base2, coords.xz );
+ }
+ if ( bBump )
+ {
+ vResultBump += vWeights.y * tex2D( bump, coords.xz );
+ }
+ }
+
+ [branch]
+ if (vWeights.z > 0)
+ {
+ vResultBase += vWeights.z * tex2D( base, coords.xy );
+ if ( bBase2 )
+ {
+ vResultBase2 += vWeights.z * tex2D( base2, coords.xy );
+ }
+
+ if ( bBump )
+ {
+ vResultBump += vWeights.z * tex2D( bump, coords.xy );
+ }
+ }
+
+#else // not seamless
+
+ vResultBase = tex2D( base, coords.xy );
+
+ if ( bBase2 )
+ {
+ vResultBase2 = tex2D( base2, coords.xy );
+ }
+
+ if ( bBump )
+ {
+ vResultBump = tex2D( bump, coords.xy );
+ }
+
+#endif
+
+
+}
+
+#else // PC
+
+void GetBaseTextureAndNormal( sampler base, sampler base2, sampler bump, bool bBase2, bool bBump, float3 coords, float3 vWeights,
+ out float4 vResultBase, out float4 vResultBase2, out float4 vResultBump )
+{
+ vResultBase = 0;
+ vResultBase2 = 0;
+ vResultBump = 0;
+
+ if ( !bBump )
+ {
+ vResultBump = float4(0, 0, 1, 1);
+ }
+
+#if SEAMLESS
+
+ vResultBase += vWeights.x * tex2D( base, coords.zy );
+ if ( bBase2 )
+ {
+ vResultBase2 += vWeights.x * tex2D( base2, coords.zy );
+ }
+ if ( bBump )
+ {
+ vResultBump += vWeights.x * tex2D( bump, coords.zy );
+ }
+
+ vResultBase += vWeights.y * tex2D( base, coords.xz );
+ if ( bBase2 )
+ {
+ vResultBase2 += vWeights.y * tex2D( base2, coords.xz );
+ }
+ if ( bBump )
+ {
+ vResultBump += vWeights.y * tex2D( bump, coords.xz );
+ }
+
+ vResultBase += vWeights.z * tex2D( base, coords.xy );
+ if ( bBase2 )
+ {
+ vResultBase2 += vWeights.z * tex2D( base2, coords.xy );
+ }
+ if ( bBump )
+ {
+ vResultBump += vWeights.z * tex2D( bump, coords.xy );
+ }
+
+#else // not seamless
+
+ vResultBase = tex2D( base, coords.xy );
+ if ( bBase2 )
+ {
+ vResultBase2 = tex2D( base2, coords.xy );
+ }
+ if ( bBump )
+ {
+ vResultBump = tex2D( bump, coords.xy );
+ }
+#endif
+
+}
+
+#endif
+
+
+
+
+float3 LightMapSample( sampler LightmapSampler, float2 vTexCoord )
+{
+# if ( !defined( _X360 ) || !defined( USE_32BIT_LIGHTMAPS_ON_360 ) )
+ {
+ float3 sample = tex2D( LightmapSampler, vTexCoord );
+
+ return sample;
+ }
+# else
+ {
+# if 0 //1 for cheap sampling, 0 for accurate scaling from the individual samples
+ {
+ float4 sample = tex2D( LightmapSampler, vTexCoord );
+
+ return sample.rgb * sample.a;
+ }
+# else
+ {
+ float4 Weights;
+ float4 samples_0; //no arrays allowed in inline assembly
+ float4 samples_1;
+ float4 samples_2;
+ float4 samples_3;
+
+ asm {
+ tfetch2D samples_0, vTexCoord.xy, LightmapSampler, OffsetX = -0.5, OffsetY = -0.5, MinFilter=point, MagFilter=point, MipFilter=keep, UseComputedLOD=false
+ tfetch2D samples_1, vTexCoord.xy, LightmapSampler, OffsetX = 0.5, OffsetY = -0.5, MinFilter=point, MagFilter=point, MipFilter=keep, UseComputedLOD=false
+ tfetch2D samples_2, vTexCoord.xy, LightmapSampler, OffsetX = -0.5, OffsetY = 0.5, MinFilter=point, MagFilter=point, MipFilter=keep, UseComputedLOD=false
+ tfetch2D samples_3, vTexCoord.xy, LightmapSampler, OffsetX = 0.5, OffsetY = 0.5, MinFilter=point, MagFilter=point, MipFilter=keep, UseComputedLOD=false
+
+ getWeights2D Weights, vTexCoord.xy, LightmapSampler
+ };
+
+ Weights = float4( (1-Weights.x)*(1-Weights.y), Weights.x*(1-Weights.y), (1-Weights.x)*Weights.y, Weights.x*Weights.y );
+
+ float3 result;
+ result.rgb = samples_0.rgb * (samples_0.a * Weights.x);
+ result.rgb += samples_1.rgb * (samples_1.a * Weights.y);
+ result.rgb += samples_2.rgb * (samples_2.a * Weights.z);
+ result.rgb += samples_3.rgb * (samples_3.a * Weights.w);
+
+ return result;
+ }
+# endif
+ }
+# endif
+}
+
diff --git a/mp/src/materialsystem/stdshaders/common_pragmas.h b/mp/src/materialsystem/stdshaders/common_pragmas.h new file mode 100644 index 00000000..50b61ff0 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/common_pragmas.h @@ -0,0 +1,38 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Common shader compiler pragmas
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#ifndef COMMON_PRAGMAS_H_
+#define COMMON_PRAGMAS_H_
+
+//
+// Validated shader models:
+//
+// SHADER_MODEL_VS_1_1
+// SHADER_MODEL_VS_2_0
+// SHADER_MODEL_VS_3_0
+//
+// SHADER_MODEL_PS_1_1
+// SHADER_MODEL_PS_1_4
+// SHADER_MODEL_PS_2_0
+// SHADER_MODEL_PS_2_B
+// SHADER_MODEL_PS_3_0
+//
+//
+//
+// Platforms:
+//
+// PC
+// _X360
+//
+
+// Special pragmas silencing common warnings
+#pragma warning ( disable : 3557 ) // warning X3557: Loop only executes for N iteration(s), forcing loop to unroll
+#pragma warning ( disable : 3595 ) // warning X3595: Microcode Compiler possible performance issue: pixel shader input semantic ___ is unused
+#pragma warning ( disable : 3596 ) // warning X3596: Microcode Compiler possible performance issue: pixel shader input semantic ___ is unused
+#pragma warning ( disable : 4702 ) // warning X4702: complement opportunity missed because input result WAS clamped from 0 to 1
+
+#endif //#ifndef COMMON_PRAGMAS_H_
diff --git a/mp/src/materialsystem/stdshaders/common_ps_fxc.h b/mp/src/materialsystem/stdshaders/common_ps_fxc.h new file mode 100644 index 00000000..d4a47ea5 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/common_ps_fxc.h @@ -0,0 +1,804 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Common pixel shader code
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#ifndef COMMON_PS_FXC_H_
+#define COMMON_PS_FXC_H_
+
+#include "common_fxc.h"
+
+// Put global skip commands here. . make sure and check that the appropriate vars are defined
+// so these aren't used on the wrong shaders!
+
+// --------------------------------------------------------------------------------
+// HDR should never be enabled if we don't aren't running in float or integer HDR mode.
+// SKIP: defined $HDRTYPE && defined $HDRENABLED && !$HDRTYPE && $HDRENABLED
+// --------------------------------------------------------------------------------
+// We don't ever write water fog to dest alpha if we aren't doing water fog.
+// SKIP: defined $PIXELFOGTYPE && defined $WRITEWATERFOGTODESTALPHA && ( $PIXELFOGTYPE != 1 ) && $WRITEWATERFOGTODESTALPHA
+// --------------------------------------------------------------------------------
+// We don't need fog in the pixel shader if we aren't in float fog mode2
+// NOSKIP: defined $HDRTYPE && defined $HDRENABLED && defined $PIXELFOGTYPE && $HDRTYPE != HDR_TYPE_FLOAT && $FOGTYPE != 0
+// --------------------------------------------------------------------------------
+// We don't do HDR and LIGHTING_PREVIEW at the same time since it's running LDR in hammer.
+// SKIP: defined $LIGHTING_PREVIEW && defined $HDRTYPE && $LIGHTING_PREVIEW && $HDRTYPE != 0
+// --------------------------------------------------------------------------------
+// Ditch all fastpath attempts if we are doing LIGHTING_PREVIEW.
+// SKIP: defined $LIGHTING_PREVIEW && defined $FASTPATHENVMAPTINT && $LIGHTING_PREVIEW && $FASTPATHENVMAPTINT
+// SKIP: defined $LIGHTING_PREVIEW && defined $FASTPATHENVMAPCONTRAST && $LIGHTING_PREVIEW && $FASTPATHENVMAPCONTRAST
+// SKIP: defined $LIGHTING_PREVIEW && defined $FASTPATH && $LIGHTING_PREVIEW && $FASTPATH
+// --------------------------------------------------------------------------------
+// Ditch flashlight depth when flashlight is disabled
+// SKIP: ($FLASHLIGHT || $FLASHLIGHTSHADOWS) && $LIGHTING_PREVIEW
+// --------------------------------------------------------------------------------
+
+// System defined pixel shader constants
+
+#if defined( _X360 )
+const bool g_bHighQualityShadows : register( b0 );
+#endif
+
+// NOTE: w == 1.0f / (Dest alpha compressed depth range).
+const float4 g_LinearFogColor : register( c29 );
+#define OO_DESTALPHA_DEPTH_RANGE (g_LinearFogColor.w)
+
+// Linear and gamma light scale values
+const float4 cLightScale : register( c30 );
+#define LINEAR_LIGHT_SCALE (cLightScale.x)
+#define LIGHT_MAP_SCALE (cLightScale.y)
+#define ENV_MAP_SCALE (cLightScale.z)
+#define GAMMA_LIGHT_SCALE (cLightScale.w)
+
+// Flashlight constants
+#if defined(SHADER_MODEL_PS_2_0) || defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)
+ const float4 cFlashlightColor : register( c28 );
+ const float4 cFlashlightScreenScale : register( c31 ); // .zw are currently unused
+ #define flFlashlightNoLambertValue cFlashlightColor.w // This is either 0.0 or 2.0
+#endif
+
+#define HDR_INPUT_MAP_SCALE 16.0f
+
+#define TONEMAP_SCALE_NONE 0
+#define TONEMAP_SCALE_LINEAR 1
+#define TONEMAP_SCALE_GAMMA 2
+
+#define PIXEL_FOG_TYPE_NONE -1 //MATERIAL_FOG_NONE is handled by PIXEL_FOG_TYPE_RANGE, this is for explicitly disabling fog in the shader
+#define PIXEL_FOG_TYPE_RANGE 0 //range+none packed together in ps2b. Simply none in ps20 (instruction limits)
+#define PIXEL_FOG_TYPE_HEIGHT 1
+
+// If you change these, make the corresponding change in hardwareconfig.cpp
+#define NVIDIA_PCF_POISSON 0
+#define ATI_NOPCF 1
+#define ATI_NO_PCF_FETCH4 2
+
+struct LPREVIEW_PS_OUT
+{
+ float4 color : COLOR0;
+ float4 normal : COLOR1;
+ float4 position : COLOR2;
+ float4 flags : COLOR3;
+};
+
+/*
+// unused
+HALF Luminance( HALF3 color )
+{
+ return dot( color, HALF3( HALF_CONSTANT(0.30f), HALF_CONSTANT(0.59f), HALF_CONSTANT(0.11f) ) );
+}
+*/
+
+/*
+// unused
+HALF LuminanceScaled( HALF3 color )
+{
+ return dot( color, HALF3( HALF_CONSTANT(0.30f) / MAX_HDR_OVERBRIGHT, HALF_CONSTANT(0.59f) / MAX_HDR_OVERBRIGHT, HALF_CONSTANT(0.11f) / MAX_HDR_OVERBRIGHT ) );
+}
+*/
+
+/*
+// unused
+HALF AvgColor( HALF3 color )
+{
+ return dot( color, HALF3( HALF_CONSTANT(0.33333f), HALF_CONSTANT(0.33333f), HALF_CONSTANT(0.33333f) ) );
+}
+*/
+
+/*
+// unused
+HALF4 DiffuseBump( sampler lightmapSampler,
+ float2 lightmapTexCoord1,
+ float2 lightmapTexCoord2,
+ float2 lightmapTexCoord3,
+ HALF3 normal )
+{
+ HALF3 lightmapColor1 = tex2D( lightmapSampler, lightmapTexCoord1 );
+ HALF3 lightmapColor2 = tex2D( lightmapSampler, lightmapTexCoord2 );
+ HALF3 lightmapColor3 = tex2D( lightmapSampler, lightmapTexCoord3 );
+
+ HALF3 diffuseLighting;
+ diffuseLighting = saturate( dot( normal, bumpBasis[0] ) ) * lightmapColor1 +
+ saturate( dot( normal, bumpBasis[1] ) ) * lightmapColor2 +
+ saturate( dot( normal, bumpBasis[2] ) ) * lightmapColor3;
+
+ return HALF4( diffuseLighting, LuminanceScaled( diffuseLighting ) );
+}
+*/
+
+
+/*
+// unused
+HALF Fresnel( HALF3 normal,
+ HALF3 eye,
+ HALF2 scaleBias )
+{
+ HALF fresnel = HALF_CONSTANT(1.0f) - dot( normal, eye );
+ fresnel = pow( fresnel, HALF_CONSTANT(5.0f) );
+
+ return fresnel * scaleBias.x + scaleBias.y;
+}
+*/
+
+/*
+// unused
+HALF4 GetNormal( sampler normalSampler,
+ float2 normalTexCoord )
+{
+ HALF4 normal = tex2D( normalSampler, normalTexCoord );
+ normal.rgb = HALF_CONSTANT(2.0f) * normal.rgb - HALF_CONSTANT(1.0f);
+
+ return normal;
+}
+*/
+
+// Needs to match NormalDecodeMode_t enum in imaterialsystem.h
+#define NORM_DECODE_NONE 0
+#define NORM_DECODE_ATI2N 1
+#define NORM_DECODE_ATI2N_ALPHA 2
+
+float4 DecompressNormal( sampler NormalSampler, float2 tc, int nDecompressionMode, sampler AlphaSampler )
+{
+ float4 normalTexel = tex2D( NormalSampler, tc );
+ float4 result;
+
+ if ( nDecompressionMode == NORM_DECODE_NONE )
+ {
+ result = float4(normalTexel.xyz * 2.0f - 1.0f, normalTexel.a );
+ }
+ else if ( nDecompressionMode == NORM_DECODE_ATI2N )
+ {
+ result.xy = normalTexel.xy * 2.0f - 1.0f;
+ result.z = sqrt( 1.0f - dot(result.xy, result.xy) );
+ result.a = 1.0f;
+ }
+ else // ATI2N plus ATI1N for alpha
+ {
+ result.xy = normalTexel.xy * 2.0f - 1.0f;
+ result.z = sqrt( 1.0f - dot(result.xy, result.xy) );
+ result.a = tex2D( AlphaSampler, tc ).x; // Note that this comes in on the X channel
+ }
+
+ return result;
+}
+
+float4 DecompressNormal( sampler NormalSampler, float2 tc, int nDecompressionMode )
+{
+ return DecompressNormal( NormalSampler, tc, nDecompressionMode, NormalSampler );
+}
+
+
+HALF3 NormalizeWithCubemap( sampler normalizeSampler, HALF3 input )
+{
+// return texCUBE( normalizeSampler, input ) * 2.0f - 1.0f;
+ return texCUBE( normalizeSampler, input );
+}
+
+/*
+HALF4 EnvReflect( sampler envmapSampler,
+ sampler normalizeSampler,
+ HALF3 normal,
+ float3 eye,
+ HALF2 fresnelScaleBias )
+{
+ HALF3 normEye = NormalizeWithCubemap( normalizeSampler, eye );
+ HALF fresnel = Fresnel( normal, normEye, fresnelScaleBias );
+ HALF3 reflect = CalcReflectionVectorUnnormalized( normal, eye );
+ return texCUBE( envmapSampler, reflect );
+}
+*/
+
+float CalcWaterFogAlpha( const float flWaterZ, const float flEyePosZ, const float flWorldPosZ, const float flProjPosZ, const float flFogOORange )
+{
+// float flDepthFromWater = flWaterZ - flWorldPosZ + 2.0f; // hackity hack . .this is for the DF_FUDGE_UP in view_scene.cpp
+ float flDepthFromWater = flWaterZ - flWorldPosZ;
+
+ // if flDepthFromWater < 0, then set it to 0
+ // This is the equivalent of moving the vert to the water surface if it's above the water surface
+ // We'll do this with the saturate at the end instead.
+// flDepthFromWater = max( 0.0f, flDepthFromWater );
+
+ // Calculate the ratio of water fog to regular fog (ie. how much of the distance from the viewer
+ // to the vert is actually underwater.
+ float flDepthFromEye = flEyePosZ - flWorldPosZ;
+ float f = saturate(flDepthFromWater * (1.0/flDepthFromEye));
+
+ // $tmp.w is now the distance that we see through water.
+ return saturate(f * flProjPosZ * flFogOORange);
+}
+
+float CalcRangeFog( const float flProjPosZ, const float flFogStartOverRange, const float flFogMaxDensity, const float flFogOORange )
+{
+#if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) //Minimum requirement of ps2b
+ return saturate( min( flFogMaxDensity, (flProjPosZ * flFogOORange) - flFogStartOverRange ) );
+#else
+ return 0.0f; //ps20 shaders will never have range fog enabled because too many ran out of slots.
+#endif
+}
+
+float CalcPixelFogFactor( int iPIXELFOGTYPE, const float4 fogParams, const float flEyePosZ, const float flWorldPosZ, const float flProjPosZ )
+{
+ float retVal;
+ if ( iPIXELFOGTYPE == PIXEL_FOG_TYPE_NONE )
+ {
+ retVal = 0.0f;
+ }
+ if ( iPIXELFOGTYPE == PIXEL_FOG_TYPE_RANGE ) //range fog, or no fog depending on fog parameters
+ {
+ retVal = CalcRangeFog( flProjPosZ, fogParams.x, fogParams.z, fogParams.w );
+ }
+ else if ( iPIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT ) //height fog
+ {
+ retVal = CalcWaterFogAlpha( fogParams.y, flEyePosZ, flWorldPosZ, flProjPosZ, fogParams.w );
+ }
+
+ return retVal;
+}
+
+//g_FogParams not defined by default, but this is the same layout for every shader that does define it
+#define g_FogEndOverRange g_FogParams.x
+#define g_WaterZ g_FogParams.y
+#define g_FogMaxDensity g_FogParams.z
+#define g_FogOORange g_FogParams.w
+
+float3 BlendPixelFog( const float3 vShaderColor, float pixelFogFactor, const float3 vFogColor, const int iPIXELFOGTYPE )
+{
+ if( iPIXELFOGTYPE == PIXEL_FOG_TYPE_RANGE ) //either range fog or no fog depending on fog parameters and whether this is ps20 or ps2b
+ {
+# if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) //Minimum requirement of ps2b
+ pixelFogFactor = saturate( pixelFogFactor );
+ return lerp( vShaderColor.rgb, vFogColor.rgb, pixelFogFactor * pixelFogFactor ); //squaring the factor will get the middle range mixing closer to hardware fog
+# else
+ return vShaderColor;
+# endif
+ }
+ else if( iPIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT )
+ {
+ return lerp( vShaderColor.rgb, vFogColor.rgb, saturate( pixelFogFactor ) );
+ }
+ else if( iPIXELFOGTYPE == PIXEL_FOG_TYPE_NONE )
+ {
+ return vShaderColor;
+ }
+}
+
+
+#if ((defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)) && ( CONVERT_TO_SRGB != 0 ) )
+sampler1D GammaTableSampler : register( s15 );
+
+float3 SRGBOutput( const float3 vShaderColor )
+{
+ //On ps2b capable hardware we always have the linear->gamma conversion table texture in sampler s15.
+ float3 result;
+ result.r = tex1D( GammaTableSampler, vShaderColor.r ).r;
+ result.g = tex1D( GammaTableSampler, vShaderColor.g ).r;
+ result.b = tex1D( GammaTableSampler, vShaderColor.b ).r;
+ return result;
+}
+
+#else
+
+float3 SRGBOutput( const float3 vShaderColor )
+{
+ return vShaderColor; //ps 1.1, 1.4, and 2.0 never do srgb conversion in the pixel shader
+}
+
+#endif
+
+
+float SoftParticleDepth( float flDepth )
+{
+ return flDepth * OO_DESTALPHA_DEPTH_RANGE;
+}
+
+
+float DepthToDestAlpha( const float flProjZ )
+{
+#if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) //Minimum requirement of ps2b
+ return SoftParticleDepth( flProjZ );
+#else
+ return 1.0f;
+#endif
+}
+
+
+float4 FinalOutput( const float4 vShaderColor, float pixelFogFactor, const int iPIXELFOGTYPE, const int iTONEMAP_SCALE_TYPE, const bool bWriteDepthToDestAlpha = false, const float flProjZ = 1.0f )
+{
+ float4 result;
+ if( iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_LINEAR )
+ {
+ result.rgb = vShaderColor.rgb * LINEAR_LIGHT_SCALE;
+ }
+ else if( iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_GAMMA )
+ {
+ result.rgb = vShaderColor.rgb * GAMMA_LIGHT_SCALE;
+ }
+ else if( iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_NONE )
+ {
+ result.rgb = vShaderColor.rgb;
+ }
+
+ if( bWriteDepthToDestAlpha )
+ result.a = DepthToDestAlpha( flProjZ );
+ else
+ result.a = vShaderColor.a;
+
+ result.rgb = BlendPixelFog( result.rgb, pixelFogFactor, g_LinearFogColor.rgb, iPIXELFOGTYPE );
+
+#if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) //Minimum requirement of ps2b
+ result.rgb = SRGBOutput( result.rgb ); //SRGB in pixel shader conversion
+#endif
+
+ return result;
+}
+
+LPREVIEW_PS_OUT FinalOutput( const LPREVIEW_PS_OUT vShaderColor, float pixelFogFactor, const int iPIXELFOGTYPE, const int iTONEMAP_SCALE_TYPE )
+{
+ LPREVIEW_PS_OUT result;
+ result.color = FinalOutput( vShaderColor.color, pixelFogFactor, iPIXELFOGTYPE, iTONEMAP_SCALE_TYPE );
+ result.normal.rgb = SRGBOutput( vShaderColor.normal.rgb );
+ result.normal.a = vShaderColor.normal.a;
+
+ result.position.rgb = SRGBOutput( vShaderColor.position.rgb );
+ result.position.a = vShaderColor.position.a;
+
+ result.flags.rgb = SRGBOutput( vShaderColor.flags.rgb );
+ result.flags.a = vShaderColor.flags.a;
+
+ return result;
+}
+
+
+
+
+float RemapValClamped( float val, float A, float B, float C, float D)
+{
+ float cVal = (val - A) / (B - A);
+ cVal = saturate( cVal );
+
+ return C + (D - C) * cVal;
+}
+
+
+//===================================================================================//
+// This is based on Natasha Tatarchuk's Parallax Occlusion Mapping (ATI)
+//===================================================================================//
+// INPUT:
+// inTexCoord:
+// the texcoord for the height/displacement map before parallaxing
+//
+// vParallax:
+// Compute initial parallax displacement direction:
+// float2 vParallaxDirection = normalize( vViewTS.xy );
+// float fLength = length( vViewTS );
+// float fParallaxLength = sqrt( fLength * fLength - vViewTS.z * vViewTS.z ) / vViewTS.z;
+// Out.vParallax = vParallaxDirection * fParallaxLength * fProjectedBumpHeight;
+//
+// vNormal:
+// tangent space normal
+//
+// vViewW:
+// float3 vViewW = /*normalize*/(mul( matViewInverse, float4( 0, 0, 0, 1)) - inPosition );
+//
+// OUTPUT:
+// the new texcoord after parallaxing
+float2 CalcParallaxedTexCoord( float2 inTexCoord, float2 vParallax, float3 vNormal,
+ float3 vViewW, sampler HeightMapSampler )
+{
+ const int nMinSamples = 8;
+ const int nMaxSamples = 50;
+
+ // Normalize the incoming view vector to avoid artifacts:
+// vView = normalize( vView );
+ vViewW = normalize( vViewW );
+// vLight = normalize( vLight );
+
+ // Change the number of samples per ray depending on the viewing angle
+ // for the surface. Oblique angles require smaller step sizes to achieve
+ // more accurate precision
+ int nNumSteps = (int) lerp( nMaxSamples, nMinSamples, dot( vViewW, vNormal ) );
+
+ float4 cResultColor = float4( 0, 0, 0, 1 );
+
+ //===============================================//
+ // Parallax occlusion mapping offset computation //
+ //===============================================//
+ float fCurrHeight = 0.0;
+ float fStepSize = 1.0 / (float) nNumSteps;
+ float fPrevHeight = 1.0;
+ float fNextHeight = 0.0;
+
+ int nStepIndex = 0;
+// bool bCondition = true;
+
+ float2 dx = ddx( inTexCoord );
+ float2 dy = ddy( inTexCoord );
+
+ float2 vTexOffsetPerStep = fStepSize * vParallax;
+
+ float2 vTexCurrentOffset = inTexCoord;
+ float fCurrentBound = 1.0;
+
+ float x = 0;
+ float y = 0;
+ float xh = 0;
+ float yh = 0;
+
+ float2 texOffset2 = 0;
+
+ bool bCondition = true;
+ while ( bCondition == true && nStepIndex < nNumSteps )
+ {
+ vTexCurrentOffset -= vTexOffsetPerStep;
+
+ fCurrHeight = tex2Dgrad( HeightMapSampler, vTexCurrentOffset, dx, dy ).r;
+
+ fCurrentBound -= fStepSize;
+
+ if ( fCurrHeight > fCurrentBound )
+ {
+ x = fCurrentBound;
+ y = fCurrentBound + fStepSize;
+ xh = fCurrHeight;
+ yh = fPrevHeight;
+
+ texOffset2 = vTexCurrentOffset - vTexOffsetPerStep;
+
+ bCondition = false;
+ }
+ else
+ {
+ nStepIndex++;
+ fPrevHeight = fCurrHeight;
+ }
+
+ } // End of while ( bCondition == true && nStepIndex > -1 )#else
+
+ fCurrentBound -= fStepSize;
+
+ float fParallaxAmount;
+ float numerator = (x * (y - yh) - y * (x - xh));
+ float denomenator = ((y - yh) - (x - xh));
+ // avoid NaN generation
+ if( ( numerator == 0.0f ) && ( denomenator == 0.0f ) )
+ {
+ fParallaxAmount = 0.0f;
+ }
+ else
+ {
+ fParallaxAmount = numerator / denomenator;
+ }
+
+ float2 vParallaxOffset = vParallax * (1 - fParallaxAmount );
+
+ // Sample the height at the next possible step:
+ fNextHeight = tex2Dgrad( HeightMapSampler, texOffset2, dx, dy ).r;
+
+ // Original offset:
+ float2 texSampleBase = inTexCoord - vParallaxOffset;
+
+ return texSampleBase;
+
+#if 0
+ cResultColor.rgb = ComputeDiffuseColor( texSampleBase, vLight );
+
+ float fBound = 1.0 - fStepSize * nStepIndex;
+ if ( fNextHeight < fCurrentBound )
+// if( 0 )
+ {
+ //void DoIteration( in float2 vParallaxJittered, in float3 vLight, inout float4 cResultColor )
+ //cResultColor.rgb = float3(1,0,0);
+ DoIteration( vParallax + vPixelSize, vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor );
+ DoIteration( vParallax - vPixelSize, vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor );
+ DoIteration( vParallax + float2( -vPixelSize.x, vPixelSize.y ), vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor );
+ DoIteration( vParallax + float2( vPixelSize.x, -vPixelSize.y ), vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor );
+
+ cResultColor.rgb /= 5;
+// cResultColor.rgb = float3( 1.0f, 0.0f, 0.0f );
+ } // End of if ( fNextHeight < fCurrentBound )
+
+#if DOSHADOWS
+ {
+ //============================================//
+ // Soft shadow and self-occlusion computation //
+ //============================================//
+ // Compute the blurry shadows (note that this computation takes into
+ // account self-occlusion for shadow computation):
+ float sh0 = tex2D( sNormalMap, texSampleBase).w;
+ float shA = (tex2D( sNormalMap, texSampleBase + inXY * 0.88 ).w - sh0 - 0.88 ) * 1 * fShadowSoftening;
+ float sh9 = (tex2D( sNormalMap, texSampleBase + inXY * 0.77 ).w - sh0 - 0.77 ) * 2 * fShadowSoftening;
+ float sh8 = (tex2D( sNormalMap, texSampleBase + inXY * 0.66 ).w - sh0 - 0.66 ) * 4 * fShadowSoftening;
+ float sh7 = (tex2D( sNormalMap, texSampleBase + inXY * 0.55 ).w - sh0 - 0.55 ) * 6 * fShadowSoftening;
+ float sh6 = (tex2D( sNormalMap, texSampleBase + inXY * 0.44 ).w - sh0 - 0.44 ) * 8 * fShadowSoftening;
+ float sh5 = (tex2D( sNormalMap, texSampleBase + inXY * 0.33 ).w - sh0 - 0.33 ) * 10 * fShadowSoftening;
+ float sh4 = (tex2D( sNormalMap, texSampleBase + inXY * 0.22 ).w - sh0 - 0.22 ) * 12 * fShadowSoftening;
+
+ // Compute the actual shadow strength:
+ float fShadow = 1 - max( max( max( max( max( max( shA, sh9 ), sh8 ), sh7 ), sh6 ), sh5 ), sh4 );
+
+ cResultColor.rgb *= fShadow * 0.6 + 0.4;
+ }
+#endif
+
+ return cResultColor;
+#endif
+}
+
+
+//======================================//
+// HSL Color space conversion routines //
+//======================================//
+
+#define HUE 0
+#define SATURATION 1
+#define LIGHTNESS 2
+
+// Convert from RGB to HSL color space
+float4 RGBtoHSL( float4 inColor )
+{
+ float h, s;
+ float flMax = max( inColor.r, max( inColor.g, inColor.b ) );
+ float flMin = min( inColor.r, min( inColor.g, inColor.b ) );
+
+ float l = (flMax + flMin) / 2.0f;
+
+ if (flMax == flMin) // achromatic case
+ {
+ s = h = 0;
+ }
+ else // chromatic case
+ {
+ // Next, calculate the hue
+ float delta = flMax - flMin;
+
+ // First, calculate the saturation
+ if (l < 0.5f) // If we're in the lower hexcone
+ {
+ s = delta/(flMax + flMin);
+ }
+ else
+ {
+ s = delta/(2 - flMax - flMin);
+ }
+
+ if ( inColor.r == flMax )
+ {
+ h = (inColor.g - inColor.b)/delta; // color between yellow and magenta
+ }
+ else if ( inColor.g == flMax )
+ {
+ h = 2 + (inColor.b - inColor.r)/delta; // color between cyan and yellow
+ }
+ else // blue must be max
+ {
+ h = 4 + (inColor.r - inColor.g)/delta; // color between magenta and cyan
+ }
+
+ h *= 60.0f;
+
+ if (h < 0.0f)
+ {
+ h += 360.0f;
+ }
+
+ h /= 360.0f;
+ }
+
+ return float4 (h, s, l, 1.0f);
+}
+
+float HueToRGB( float v1, float v2, float vH )
+{
+ float fResult = v1;
+
+ vH = fmod (vH + 1.0f, 1.0f);
+
+ if ( ( 6.0f * vH ) < 1.0f )
+ {
+ fResult = ( v1 + ( v2 - v1 ) * 6.0f * vH );
+ }
+ else if ( ( 2.0f * vH ) < 1.0f )
+ {
+ fResult = ( v2 );
+ }
+ else if ( ( 3.0f * vH ) < 2.0f )
+ {
+ fResult = ( v1 + ( v2 - v1 ) * ( ( 2.0f / 3.0f ) - vH ) * 6.0f );
+ }
+
+ return fResult;
+}
+
+// Convert from HSL to RGB color space
+float4 HSLtoRGB( float4 hsl )
+{
+ float r, g, b;
+ float h = hsl[HUE];
+ float s = hsl[SATURATION];
+ float l = hsl[LIGHTNESS];
+
+ if ( s == 0 )
+ {
+ r = g = b = l;
+ }
+ else
+ {
+ float v1, v2;
+
+ if ( l < 0.5f )
+ v2 = l * ( 1.0f + s );
+ else
+ v2 = ( l + s ) - ( s * l );
+
+ v1 = 2 * l - v2;
+
+ r = HueToRGB( v1, v2, h + ( 1.0f / 3.0f ) );
+ g = HueToRGB( v1, v2, h );
+ b = HueToRGB( v1, v2, h - ( 1.0f / 3.0f ) );
+ }
+
+ return float4( r, g, b, 1.0f );
+}
+
+
+// texture combining modes for combining base and detail/basetexture2
+#define TCOMBINE_RGB_EQUALS_BASE_x_DETAILx2 0 // original mode
+#define TCOMBINE_RGB_ADDITIVE 1 // base.rgb+detail.rgb*fblend
+#define TCOMBINE_DETAIL_OVER_BASE 2
+#define TCOMBINE_FADE 3 // straight fade between base and detail.
+#define TCOMBINE_BASE_OVER_DETAIL 4 // use base alpha for blend over detail
+#define TCOMBINE_RGB_ADDITIVE_SELFILLUM 5 // add detail color post lighting
+#define TCOMBINE_RGB_ADDITIVE_SELFILLUM_THRESHOLD_FADE 6
+#define TCOMBINE_MOD2X_SELECT_TWO_PATTERNS 7 // use alpha channel of base to select between mod2x channels in r+a of detail
+#define TCOMBINE_MULTIPLY 8
+#define TCOMBINE_MASK_BASE_BY_DETAIL_ALPHA 9 // use alpha channel of detail to mask base
+#define TCOMBINE_SSBUMP_BUMP 10 // use detail to modulate lighting as an ssbump
+#define TCOMBINE_SSBUMP_NOBUMP 11 // detail is an ssbump but use it as an albedo. shader does the magic here - no user needs to specify mode 11
+
+float4 TextureCombine( float4 baseColor, float4 detailColor, int combine_mode,
+ float fBlendFactor )
+{
+ if ( combine_mode == TCOMBINE_MOD2X_SELECT_TWO_PATTERNS)
+ {
+ float3 dc=lerp(detailColor.r,detailColor.a, baseColor.a);
+ baseColor.rgb*=lerp(float3(1,1,1),2.0*dc,fBlendFactor);
+ }
+ if ( combine_mode == TCOMBINE_RGB_EQUALS_BASE_x_DETAILx2)
+ baseColor.rgb*=lerp(float3(1,1,1),2.0*detailColor.rgb,fBlendFactor);
+ if ( combine_mode == TCOMBINE_RGB_ADDITIVE )
+ baseColor.rgb += fBlendFactor * detailColor.rgb;
+ if ( combine_mode == TCOMBINE_DETAIL_OVER_BASE )
+ {
+ float fblend=fBlendFactor * detailColor.a;
+ baseColor.rgb = lerp( baseColor.rgb, detailColor.rgb, fblend);
+ }
+ if ( combine_mode == TCOMBINE_FADE )
+ {
+ baseColor = lerp( baseColor, detailColor, fBlendFactor);
+ }
+ if ( combine_mode == TCOMBINE_BASE_OVER_DETAIL )
+ {
+ float fblend=fBlendFactor * (1-baseColor.a);
+ baseColor.rgb = lerp( baseColor.rgb, detailColor.rgb, fblend );
+ baseColor.a = detailColor.a;
+ }
+ if ( combine_mode == TCOMBINE_MULTIPLY )
+ {
+ baseColor = lerp( baseColor, baseColor*detailColor, fBlendFactor);
+ }
+
+ if (combine_mode == TCOMBINE_MASK_BASE_BY_DETAIL_ALPHA )
+ {
+ baseColor.a = lerp( baseColor.a, baseColor.a*detailColor.a, fBlendFactor );
+ }
+ if ( combine_mode == TCOMBINE_SSBUMP_NOBUMP )
+ {
+ baseColor.rgb = baseColor.rgb * dot( detailColor.rgb, 2.0/3.0 );
+ }
+ return baseColor;
+}
+
+float3 lerp5(float3 f1, float3 f2, float i1, float i2, float x)
+{
+ return f1+(f2-f1)*(x-i1)/(i2-i1);
+}
+
+float3 TextureCombinePostLighting( float3 lit_baseColor, float4 detailColor, int combine_mode,
+ float fBlendFactor )
+{
+ if ( combine_mode == TCOMBINE_RGB_ADDITIVE_SELFILLUM )
+ lit_baseColor += fBlendFactor * detailColor.rgb;
+ if ( combine_mode == TCOMBINE_RGB_ADDITIVE_SELFILLUM_THRESHOLD_FADE )
+ {
+ // fade in an unusual way - instead of fading out color, remap an increasing band of it from
+ // 0..1
+ //if (fBlendFactor > 0.5)
+ // lit_baseColor += min(1, (1.0/fBlendFactor)*max(0, detailColor.rgb-(1-fBlendFactor) ) );
+ //else
+ // lit_baseColor += 2*fBlendFactor*2*max(0, detailColor.rgb-.5);
+
+ float f = fBlendFactor - 0.5;
+ float fMult = (f >= 0) ? 1.0/fBlendFactor : 4*fBlendFactor;
+ float fAdd = (f >= 0) ? 1.0-fMult : -0.5*fMult;
+ lit_baseColor += saturate(fMult * detailColor.rgb + fAdd);
+ }
+ return lit_baseColor;
+}
+
+//NOTE: On X360. fProjZ is expected to be pre-reversed for cheaper math here in the pixel shader
+float DepthFeathering( sampler DepthSampler, const float2 vScreenPos, float fProjZ, float fProjW, float4 vDepthBlendConstants )
+{
+# if ( !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) ) //minimum requirement of ps2b
+ {
+ float flFeatheredAlpha;
+ float2 flDepths;
+#define flSceneDepth flDepths.x
+#define flSpriteDepth flDepths.y
+
+# if ( defined( _X360 ) )
+ {
+ //Get depth from the depth texture. Need to sample with the offset of (0.5, 0.5) to fix rounding errors
+ asm {
+ tfetch2D flDepths.x___, vScreenPos, DepthSampler, OffsetX=0.5, OffsetY=0.5, MinFilter=point, MagFilter=point, MipFilter=point
+ };
+
+# if( !defined( REVERSE_DEPTH_ON_X360 ) )
+ flSceneDepth = 1.0f - flSceneDepth;
+# endif
+
+ //get the sprite depth into the same range as the texture depth
+ flSpriteDepth = fProjZ / fProjW;
+
+ //unproject to get at the pre-projection z. This value is much more linear than depth
+ flDepths = vDepthBlendConstants.z / flDepths;
+ flDepths = vDepthBlendConstants.y - flDepths;
+
+ flFeatheredAlpha = flSceneDepth - flSpriteDepth;
+ flFeatheredAlpha *= vDepthBlendConstants.x;
+ flFeatheredAlpha = saturate( flFeatheredAlpha );
+ }
+# else
+ {
+ flSceneDepth = tex2D( DepthSampler, vScreenPos ).a; // PC uses dest alpha of the frame buffer
+ flSpriteDepth = SoftParticleDepth( fProjZ );
+
+ flFeatheredAlpha = abs(flSceneDepth - flSpriteDepth) * vDepthBlendConstants.x;
+ flFeatheredAlpha = max( smoothstep( 0.75f, 1.0f, flSceneDepth ), flFeatheredAlpha ); //as the sprite approaches the edge of our compressed depth space, the math stops working. So as the sprite approaches the far depth, smoothly remove feathering.
+ flFeatheredAlpha = saturate( flFeatheredAlpha );
+ }
+# endif
+
+#undef flSceneDepth
+#undef flSpriteDepth
+
+ return flFeatheredAlpha;
+ }
+# else
+ {
+ return 1.0f;
+ }
+# endif
+}
+
+#endif //#ifndef COMMON_PS_FXC_H_
diff --git a/mp/src/materialsystem/stdshaders/common_vertexlitgeneric_dx9.h b/mp/src/materialsystem/stdshaders/common_vertexlitgeneric_dx9.h new file mode 100644 index 00000000..66cc642a --- /dev/null +++ b/mp/src/materialsystem/stdshaders/common_vertexlitgeneric_dx9.h @@ -0,0 +1,423 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef COMMON_VERTEXLITGENERIC_DX9_H_
+#define COMMON_VERTEXLITGENERIC_DX9_H_
+
+#include "common_ps_fxc.h"
+
+// We store four light colors and positions in an
+// array of three of these structures like so:
+//
+// x y z w
+// +------+------+------+------+
+// | L0.rgb | |
+// +------+------+------+ |
+// | L0.pos | L3 |
+// +------+------+------+ rgb |
+// | L1.rgb | |
+// +------+------+------+------+
+// | L1.pos | |
+// +------+------+------+ |
+// | L2.rgb | L3 |
+// +------+------+------+ pos |
+// | L2.pos | |
+// +------+------+------+------+
+//
+struct PixelShaderLightInfo
+{
+ float4 color;
+ float4 pos;
+};
+
+#define cOverbright 2.0f
+#define cOOOverbright 0.5f
+
+#define LIGHTTYPE_NONE 0
+#define LIGHTTYPE_SPOT 1
+#define LIGHTTYPE_POINT 2
+#define LIGHTTYPE_DIRECTIONAL 3
+
+// Better suited to Pixel shader models, 11 instructions in pixel shader
+// ... actually, now only 9: mul, cmp, cmp, mul, mad, mad, mad, mad, mad
+float3 PixelShaderAmbientLight( const float3 worldNormal, const float3 cAmbientCube[6] )
+{
+ float3 linearColor, nSquared = worldNormal * worldNormal;
+ float3 isNegative = ( worldNormal >= 0.0 ) ? 0 : nSquared;
+ float3 isPositive = ( worldNormal >= 0.0 ) ? nSquared : 0;
+ linearColor = isPositive.x * cAmbientCube[0] + isNegative.x * cAmbientCube[1] +
+ isPositive.y * cAmbientCube[2] + isNegative.y * cAmbientCube[3] +
+ isPositive.z * cAmbientCube[4] + isNegative.z * cAmbientCube[5];
+ return linearColor;
+}
+
+// Better suited to Vertex shader models
+// Six VS instructions due to use of constant indexing (slt, mova, mul, mul, mad, mad)
+float3 VertexShaderAmbientLight( const float3 worldNormal, const float3 cAmbientCube[6] )
+{
+ float3 nSquared = worldNormal * worldNormal;
+ int3 isNegative = ( worldNormal < 0.0 );
+ float3 linearColor;
+ linearColor = nSquared.x * cAmbientCube[isNegative.x] +
+ nSquared.y * cAmbientCube[isNegative.y+2] +
+ nSquared.z * cAmbientCube[isNegative.z+4];
+ return linearColor;
+}
+
+float3 AmbientLight( const float3 worldNormal, const float3 cAmbientCube[6] )
+{
+ // Vertex shader cases
+#ifdef SHADER_MODEL_VS_1_0
+ return VertexShaderAmbientLight( worldNormal, cAmbientCube );
+#elif SHADER_MODEL_VS_1_1
+ return VertexShaderAmbientLight( worldNormal, cAmbientCube );
+#elif SHADER_MODEL_VS_2_0
+ return VertexShaderAmbientLight( worldNormal, cAmbientCube );
+#elif SHADER_MODEL_VS_3_0
+ return VertexShaderAmbientLight( worldNormal, cAmbientCube );
+#else
+ // Pixel shader case
+ return PixelShaderAmbientLight( worldNormal, cAmbientCube );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Compute scalar diffuse term with various optional tweaks such as
+// Half Lambert and ambient occlusion
+//-----------------------------------------------------------------------------
+float3 DiffuseTerm(const bool bHalfLambert, const float3 worldNormal, const float3 lightDir,
+ const bool bDoAmbientOcclusion, const float fAmbientOcclusion,
+ const bool bDoLightingWarp, in sampler lightWarpSampler )
+{
+ float fResult;
+
+ float NDotL = dot( worldNormal, lightDir ); // Unsaturated dot (-1 to 1 range)
+
+ if ( bHalfLambert )
+ {
+ fResult = saturate(NDotL * 0.5 + 0.5); // Scale and bias to 0 to 1 range
+
+ if ( !bDoLightingWarp )
+ {
+ fResult *= fResult; // Square
+ }
+ }
+ else
+ {
+ fResult = saturate( NDotL ); // Saturate pure Lambertian term
+ }
+
+ if ( bDoAmbientOcclusion )
+ {
+ // Raise to higher powers for darker AO values
+// float fAOPower = lerp( 4.0f, 1.0f, fAmbientOcclusion );
+// result *= pow( NDotL * 0.5 + 0.5, fAOPower );
+ fResult *= fAmbientOcclusion;
+ }
+
+ float3 fOut = float3( fResult, fResult, fResult );
+ if ( bDoLightingWarp )
+ {
+ fOut = 2.0f * tex1D( lightWarpSampler, fResult );
+ }
+
+ return fOut;
+}
+
+float3 PixelShaderDoGeneralDiffuseLight( const float fAtten, const float3 worldPos, const float3 worldNormal,
+ in sampler NormalizeSampler,
+ const float3 vPosition, const float3 vColor, const bool bHalfLambert,
+ const bool bDoAmbientOcclusion, const float fAmbientOcclusion,
+ const bool bDoLightingWarp, in sampler lightWarpSampler )
+{
+#if (defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0))
+ float3 lightDir = normalize( vPosition - worldPos );
+#else
+ float3 lightDir = NormalizeWithCubemap( NormalizeSampler, vPosition - worldPos );
+#endif
+ return vColor * fAtten * DiffuseTerm( bHalfLambert, worldNormal, lightDir, bDoAmbientOcclusion, fAmbientOcclusion, bDoLightingWarp, lightWarpSampler );
+}
+
+float3 PixelShaderGetLightVector( const float3 worldPos, PixelShaderLightInfo cLightInfo[3], int nLightIndex )
+{
+ if ( nLightIndex == 3 )
+ {
+ // Unpack light 3 from w components...
+ float3 vLight3Pos = float3( cLightInfo[1].pos.w, cLightInfo[2].color.w, cLightInfo[2].pos.w );
+ return normalize( vLight3Pos - worldPos );
+ }
+ else
+ {
+ return normalize( cLightInfo[nLightIndex].pos - worldPos );
+ }
+}
+
+float3 PixelShaderGetLightColor( PixelShaderLightInfo cLightInfo[3], int nLightIndex )
+{
+ if ( nLightIndex == 3 )
+ {
+ // Unpack light 3 from w components...
+ return float3( cLightInfo[0].color.w, cLightInfo[0].pos.w, cLightInfo[1].color.w );
+ }
+ else
+ {
+ return cLightInfo[nLightIndex].color.rgb;
+ }
+}
+
+
+void SpecularAndRimTerms( const float3 vWorldNormal, const float3 vLightDir, const float fSpecularExponent,
+ const float3 vEyeDir, const bool bDoAmbientOcclusion, const float fAmbientOcclusion,
+ const bool bDoSpecularWarp, in sampler specularWarpSampler, const float fFresnel,
+ const float3 color, const bool bDoRimLighting, const float fRimExponent,
+
+ // Outputs
+ out float3 specularLighting, out float3 rimLighting )
+{
+ rimLighting = float3(0.0f, 0.0f, 0.0f);
+
+ //float3 vReflect = reflect( -vEyeDir, vWorldNormal ); // Reflect view through normal
+ float3 vReflect = 2 * vWorldNormal * dot( vWorldNormal , vEyeDir ) - vEyeDir; // Reflect view through normal
+ float LdotR = saturate(dot( vReflect, vLightDir )); // L.R (use half-angle instead?)
+ specularLighting = pow( LdotR, fSpecularExponent ); // Raise to specular exponent
+
+ // Optionally warp as function of scalar specular and fresnel
+ if ( bDoSpecularWarp )
+ specularLighting *= tex2D( specularWarpSampler, float2(specularLighting.x, fFresnel) ); // Sample at { (L.R)^k, fresnel }
+
+ specularLighting *= saturate(dot( vWorldNormal, vLightDir )); // Mask with N.L
+ specularLighting *= color; // Modulate with light color
+
+ if ( bDoAmbientOcclusion ) // Optionally modulate with ambient occlusion
+ specularLighting *= fAmbientOcclusion;
+
+ if ( bDoRimLighting ) // Optionally do rim lighting
+ {
+ rimLighting = pow( LdotR, fRimExponent ); // Raise to rim exponent
+ rimLighting *= saturate(dot( vWorldNormal, vLightDir )); // Mask with N.L
+ rimLighting *= color; // Modulate with light color
+ }
+}
+
+// Traditional fresnel term approximation
+float Fresnel( const float3 vNormal, const float3 vEyeDir )
+{
+ float fresnel = saturate( 1 - dot( vNormal, vEyeDir ) ); // 1-(N.V) for Fresnel term
+ return fresnel * fresnel; // Square for a more subtle look
+}
+
+// Traditional fresnel term approximation which uses 4th power (square twice)
+float Fresnel4( const float3 vNormal, const float3 vEyeDir )
+{
+ float fresnel = saturate( 1 - dot( vNormal, vEyeDir ) ); // 1-(N.V) for Fresnel term
+ fresnel = fresnel * fresnel; // Square
+ return fresnel * fresnel; // Square again for a more subtle look
+}
+
+
+//
+// Custom Fresnel with low, mid and high parameters defining a piecewise continuous function
+// with traditional fresnel (0 to 1 range) as input. The 0 to 0.5 range blends between
+// low and mid while the 0.5 to 1 range blends between mid and high
+//
+// |
+// | . M . . . H
+// | .
+// L
+// |
+// +----------------
+// 0 1
+//
+float Fresnel( const float3 vNormal, const float3 vEyeDir, float3 vRanges )
+{
+ //float result, f = Fresnel( vNormal, vEyeDir ); // Traditional Fresnel
+ //if ( f > 0.5f )
+ // result = lerp( vRanges.y, vRanges.z, (2*f)-1 ); // Blend between mid and high values
+ //else
+ // result = lerp( vRanges.x, vRanges.y, 2*f ); // Blend between low and mid values
+
+ // note: vRanges is now encoded as ((mid-min)*2, mid, (max-mid)*2) to optimize math
+ float f = saturate( 1 - dot( vNormal, vEyeDir ) );
+ f = f*f - 0.5;
+ return vRanges.y + (f >= 0.0 ? vRanges.z : vRanges.x) * f;
+}
+
+void PixelShaderDoSpecularLight( const float3 vWorldPos, const float3 vWorldNormal, const float fSpecularExponent, const float3 vEyeDir,
+ const float fAtten, const float3 vLightColor, const float3 vLightDir,
+ const bool bDoAmbientOcclusion, const float fAmbientOcclusion,
+ const bool bDoSpecularWarp, in sampler specularWarpSampler, float fFresnel,
+ const bool bDoRimLighting, const float fRimExponent,
+
+ // Outputs
+ out float3 specularLighting, out float3 rimLighting )
+{
+ // Compute Specular and rim terms
+ SpecularAndRimTerms( vWorldNormal, vLightDir, fSpecularExponent,
+ vEyeDir, bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoSpecularWarp, specularWarpSampler, fFresnel, vLightColor * fAtten,
+ bDoRimLighting, fRimExponent, specularLighting, rimLighting );
+}
+
+float3 PixelShaderDoLightingLinear( const float3 worldPos, const float3 worldNormal,
+ const float3 staticLightingColor, const bool bStaticLight,
+ const bool bAmbientLight, const float4 lightAtten, const float3 cAmbientCube[6],
+ in sampler NormalizeSampler, const int nNumLights, PixelShaderLightInfo cLightInfo[3],
+ const bool bHalfLambert, const bool bDoAmbientOcclusion, const float fAmbientOcclusion,
+ const bool bDoLightingWarp, in sampler lightWarpSampler )
+{
+ float3 linearColor = 0.0f;
+
+ if ( bStaticLight )
+ {
+ // The static lighting comes in in gamma space and has also been premultiplied by $cOOOverbright
+ // need to get it into
+ // linear space so that we can do adds.
+ linearColor += GammaToLinear( staticLightingColor * cOverbright );
+ }
+
+ if ( bAmbientLight )
+ {
+ float3 ambient = AmbientLight( worldNormal, cAmbientCube );
+
+ if ( bDoAmbientOcclusion )
+ ambient *= fAmbientOcclusion * fAmbientOcclusion; // Note squaring...
+
+ linearColor += ambient;
+ }
+
+ if ( nNumLights > 0 )
+ {
+ linearColor += PixelShaderDoGeneralDiffuseLight( lightAtten.x, worldPos, worldNormal, NormalizeSampler,
+ cLightInfo[0].pos, cLightInfo[0].color, bHalfLambert,
+ bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoLightingWarp, lightWarpSampler );
+ if ( nNumLights > 1 )
+ {
+ linearColor += PixelShaderDoGeneralDiffuseLight( lightAtten.y, worldPos, worldNormal, NormalizeSampler,
+ cLightInfo[1].pos, cLightInfo[1].color, bHalfLambert,
+ bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoLightingWarp, lightWarpSampler );
+ if ( nNumLights > 2 )
+ {
+ linearColor += PixelShaderDoGeneralDiffuseLight( lightAtten.z, worldPos, worldNormal, NormalizeSampler,
+ cLightInfo[2].pos, cLightInfo[2].color, bHalfLambert,
+ bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoLightingWarp, lightWarpSampler );
+ if ( nNumLights > 3 )
+ {
+ // Unpack the 4th light's data from tight constant packing
+ float3 vLight3Color = float3( cLightInfo[0].color.w, cLightInfo[0].pos.w, cLightInfo[1].color.w );
+ float3 vLight3Pos = float3( cLightInfo[1].pos.w, cLightInfo[2].color.w, cLightInfo[2].pos.w );
+ linearColor += PixelShaderDoGeneralDiffuseLight( lightAtten.w, worldPos, worldNormal, NormalizeSampler,
+ vLight3Pos, vLight3Color, bHalfLambert,
+ bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoLightingWarp, lightWarpSampler );
+ }
+ }
+ }
+ }
+
+ return linearColor;
+}
+
+void PixelShaderDoSpecularLighting( const float3 worldPos, const float3 worldNormal, const float fSpecularExponent, const float3 vEyeDir,
+ const float4 lightAtten, const int nNumLights, PixelShaderLightInfo cLightInfo[3],
+ const bool bDoAmbientOcclusion, const float fAmbientOcclusion,
+ const bool bDoSpecularWarp, in sampler specularWarpSampler, float fFresnel,
+ const bool bDoRimLighting, const float fRimExponent,
+
+ // Outputs
+ out float3 specularLighting, out float3 rimLighting )
+{
+ specularLighting = rimLighting = float3( 0.0f, 0.0f, 0.0f );
+ float3 localSpecularTerm, localRimTerm;
+
+ if( nNumLights > 0 )
+ {
+ PixelShaderDoSpecularLight( worldPos, worldNormal, fSpecularExponent, vEyeDir,
+ lightAtten.x, PixelShaderGetLightColor( cLightInfo, 0 ),
+ PixelShaderGetLightVector( worldPos, cLightInfo, 0 ),
+ bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoSpecularWarp, specularWarpSampler, fFresnel,
+ bDoRimLighting, fRimExponent,
+ localSpecularTerm, localRimTerm );
+
+ specularLighting += localSpecularTerm; // Accumulate specular and rim terms
+ rimLighting += localRimTerm;
+ }
+
+ if( nNumLights > 1 )
+ {
+ PixelShaderDoSpecularLight( worldPos, worldNormal, fSpecularExponent, vEyeDir,
+ lightAtten.y, PixelShaderGetLightColor( cLightInfo, 1 ),
+ PixelShaderGetLightVector( worldPos, cLightInfo, 1 ),
+ bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoSpecularWarp, specularWarpSampler, fFresnel,
+ bDoRimLighting, fRimExponent,
+ localSpecularTerm, localRimTerm );
+
+ specularLighting += localSpecularTerm; // Accumulate specular and rim terms
+ rimLighting += localRimTerm;
+ }
+
+
+ if( nNumLights > 2 )
+ {
+ PixelShaderDoSpecularLight( worldPos, worldNormal, fSpecularExponent, vEyeDir,
+ lightAtten.z, PixelShaderGetLightColor( cLightInfo, 2 ),
+ PixelShaderGetLightVector( worldPos, cLightInfo, 2 ),
+ bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoSpecularWarp, specularWarpSampler, fFresnel,
+ bDoRimLighting, fRimExponent,
+ localSpecularTerm, localRimTerm );
+
+ specularLighting += localSpecularTerm; // Accumulate specular and rim terms
+ rimLighting += localRimTerm;
+ }
+
+ if( nNumLights > 3 )
+ {
+ PixelShaderDoSpecularLight( worldPos, worldNormal, fSpecularExponent, vEyeDir,
+ lightAtten.w, PixelShaderGetLightColor( cLightInfo, 3 ),
+ PixelShaderGetLightVector( worldPos, cLightInfo, 3 ),
+ bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoSpecularWarp, specularWarpSampler, fFresnel,
+ bDoRimLighting, fRimExponent,
+ localSpecularTerm, localRimTerm );
+
+ specularLighting += localSpecularTerm; // Accumulate specular and rim terms
+ rimLighting += localRimTerm;
+ }
+
+}
+
+float3 PixelShaderDoRimLighting( const float3 worldNormal, const float3 vEyeDir, const float3 cAmbientCube[6], float fFresnel )
+{
+ float3 vReflect = reflect( -vEyeDir, worldNormal ); // Reflect view through normal
+
+ return fFresnel * PixelShaderAmbientLight( vEyeDir, cAmbientCube );
+}
+
+// Called directly by newer shaders or through the following wrapper for older shaders
+float3 PixelShaderDoLighting( const float3 worldPos, const float3 worldNormal,
+ const float3 staticLightingColor, const bool bStaticLight,
+ const bool bAmbientLight, const float4 lightAtten, const float3 cAmbientCube[6],
+ in sampler NormalizeSampler, const int nNumLights, PixelShaderLightInfo cLightInfo[3],
+ const bool bHalfLambert,
+
+ // New optional/experimental parameters
+ const bool bDoAmbientOcclusion, const float fAmbientOcclusion,
+ const bool bDoLightingWarp, in sampler lightWarpSampler )
+{
+ float3 linearColor = PixelShaderDoLightingLinear( worldPos, worldNormal, staticLightingColor,
+ bStaticLight, bAmbientLight, lightAtten,
+ cAmbientCube, NormalizeSampler, nNumLights, cLightInfo, bHalfLambert,
+ bDoAmbientOcclusion, fAmbientOcclusion,
+ bDoLightingWarp, lightWarpSampler );
+
+ // go ahead and clamp to the linear space equivalent of overbright 2 so that we match
+ // everything else.
+// linearColor = HuePreservingColorClamp( linearColor, pow( 2.0f, 2.2 ) );
+
+ return linearColor;
+}
+
+#endif //#ifndef COMMON_VERTEXLITGENERIC_DX9_H_
diff --git a/mp/src/materialsystem/stdshaders/common_vs_fxc.h b/mp/src/materialsystem/stdshaders/common_vs_fxc.h new file mode 100644 index 00000000..fe2e117a --- /dev/null +++ b/mp/src/materialsystem/stdshaders/common_vs_fxc.h @@ -0,0 +1,955 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: This is where all common code for vertex shaders go.
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+
+
+#ifndef COMMON_VS_FXC_H_
+#define COMMON_VS_FXC_H_
+
+#include "common_fxc.h"
+
+// Put global skip commands here. . make sure and check that the appropriate vars are defined
+// so these aren't used on the wrong shaders!
+// --------------------------------------------------------------------------------
+// Ditch all fastpath attemps if we are doing LIGHTING_PREVIEW.
+// SKIP: defined $LIGHTING_PREVIEW && defined $FASTPATH && $LIGHTING_PREVIEW && $FASTPATH
+// --------------------------------------------------------------------------------
+
+
+#ifndef COMPRESSED_VERTS
+// Default to no vertex compression
+#define COMPRESSED_VERTS 0
+#endif
+
+#if ( !defined( SHADER_MODEL_VS_2_0 ) && !defined( SHADER_MODEL_VS_3_0 ) )
+#if COMPRESSED_VERTS == 1
+#error "Vertex compression is only for DX9 and up!"
+#endif
+#endif
+
+// We're testing 2 normal compression methods
+// One compressed normals+tangents into a SHORT2 each (8 bytes total)
+// The other compresses them together, into a single UBYTE4 (4 bytes total)
+// FIXME: pick one or the other, compare lighting quality in important cases
+#define COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2 0
+#define COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 1
+//#define COMPRESSED_NORMALS_TYPE COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2
+#define COMPRESSED_NORMALS_TYPE COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4
+
+
+#define FOGTYPE_RANGE 0
+#define FOGTYPE_HEIGHT 1
+
+#define COMPILE_ERROR ( 1/0; )
+
+// -------------------------
+// CONSTANTS
+// -------------------------
+
+#pragma def ( vs, c0, 0.0f, 1.0f, 2.0f, 0.5f )
+
+const float4 cConstants1 : register(c1);
+#define cOOGamma cConstants1.x
+#define cOverbright 2.0f
+#define cOneThird cConstants1.z
+#define cOOOverbright ( 1.0f / 2.0f )
+
+
+// The g_bLightEnabled registers and g_nLightCountRegister hold the same information regarding
+// enabling lights, but callers internal to this file tend to use the loops, while external
+// callers will end up using the booleans
+const bool g_bLightEnabled[4] : register(b0);
+ // through b3
+
+const int g_nLightCountRegister : register(i0);
+
+
+#define g_nLightCount g_nLightCountRegister.x
+
+const float4 cEyePosWaterZ : register(c2);
+#define cEyePos cEyePosWaterZ.xyz
+
+// Only cFlexScale.x is used
+// It is a binary value used to switch on/off the addition of the flex delta stream
+const float4 cFlexScale : register( c3 );
+
+const float4x4 cModelViewProj : register(c4);
+const float4x4 cViewProj : register(c8);
+
+// Used to compute projPosZ in shaders without skinning
+// Using cModelViewProj with FastClip generates incorrect results
+// This is just row two of the non-FastClip cModelViewProj matrix
+const float4 cModelViewProjZ : register(c12);
+
+// More constants working back from the top...
+const float4 cViewProjZ : register(c13);
+
+const float4 cFogParams : register(c16);
+#define cFogEndOverFogRange cFogParams.x
+#define cFogOne cFogParams.y
+#define cFogMaxDensity cFogParams.z
+#define cOOFogRange cFogParams.w
+
+const float4x4 cViewModel : register(c17);
+
+const float3 cAmbientCubeX [ 2 ] : register ( c21 ) ;
+const float3 cAmbientCubeY [ 2 ] : register ( c23 ) ;
+const float3 cAmbientCubeZ [ 2 ] : register ( c25 ) ;
+
+#if defined ( SHADER_MODEL_VS_3_0 )
+const float4 cFlexWeights [ 512 ] : register ( c1024 ) ;
+#endif
+
+struct LightInfo
+{
+ float4 color; // {xyz} is color w is light type code (see comment below)
+ float4 dir; // {xyz} is dir w is light type code
+ float4 pos;
+ float4 spotParams;
+ float4 atten;
+};
+
+// w components of color and dir indicate light type:
+// 1x - directional
+// 01 - spot
+// 00 - point
+
+// Four lights x 5 constants each = 20 constants
+LightInfo cLightInfo[4] : register(c27);
+#define LIGHT_0_POSITION_REG c29
+
+#ifdef SHADER_MODEL_VS_1_1
+
+const float4 cModulationColor : register(c37);
+
+#define SHADER_SPECIFIC_CONST_0 c38
+#define SHADER_SPECIFIC_CONST_1 c39
+#define SHADER_SPECIFIC_CONST_2 c40
+#define SHADER_SPECIFIC_CONST_3 c41
+#define SHADER_SPECIFIC_CONST_4 c42
+#define SHADER_SPECIFIC_CONST_5 c43
+#define SHADER_SPECIFIC_CONST_6 c44
+#define SHADER_SPECIFIC_CONST_7 c45
+#define SHADER_SPECIFIC_CONST_8 c46
+#define SHADER_SPECIFIC_CONST_9 c47
+#define SHADER_SPECIFIC_CONST_10 c14
+#define SHADER_SPECIFIC_CONST_11 c15
+
+static const int cModel0Index = 48;
+const float4x3 cModel[16] : register(c48);
+// last cmodel is c105 for dx80, c214 for dx90
+
+#else // DX9 shaders (vs20 and beyond)
+
+const float4 cModulationColor : register( c47 );
+
+#define SHADER_SPECIFIC_CONST_0 c48
+#define SHADER_SPECIFIC_CONST_1 c49
+#define SHADER_SPECIFIC_CONST_2 c50
+#define SHADER_SPECIFIC_CONST_3 c51
+#define SHADER_SPECIFIC_CONST_4 c52
+#define SHADER_SPECIFIC_CONST_5 c53
+#define SHADER_SPECIFIC_CONST_6 c54
+#define SHADER_SPECIFIC_CONST_7 c55
+#define SHADER_SPECIFIC_CONST_8 c56
+#define SHADER_SPECIFIC_CONST_9 c57
+#define SHADER_SPECIFIC_CONST_10 c14
+#define SHADER_SPECIFIC_CONST_11 c15
+
+static const int cModel0Index = 58;
+const float4x3 cModel[53] : register( c58 );
+// last cmodel is c105 for dx80, c216 for dx90
+
+
+#define SHADER_SPECIFIC_BOOL_CONST_0 b4
+#define SHADER_SPECIFIC_BOOL_CONST_1 b5
+#define SHADER_SPECIFIC_BOOL_CONST_2 b6
+#define SHADER_SPECIFIC_BOOL_CONST_3 b7
+#define SHADER_SPECIFIC_BOOL_CONST_4 b8
+#define SHADER_SPECIFIC_BOOL_CONST_5 b9
+#define SHADER_SPECIFIC_BOOL_CONST_6 b10
+#define SHADER_SPECIFIC_BOOL_CONST_7 b11
+#endif // vertex shader model constant packing changes
+
+
+//=======================================================================================
+// Methods to decompress vertex normals
+//=======================================================================================
+
+//-----------------------------------------------------------------------------------
+// Decompress a normal from two-component compressed format
+// We expect this data to come from a signed SHORT2 stream in the range of -32768..32767
+//
+// -32678 and 0 are invalid encodings
+// w contains the sign to use in the cross product when generating a binormal
+void _DecompressShort2Tangent( float2 inputTangent, out float4 outputTangent )
+{
+ float2 ztSigns = sign( inputTangent ); // sign bits for z and tangent (+1 or -1)
+ float2 xyAbs = abs( inputTangent ); // 1..32767
+ outputTangent.xy = (xyAbs - 16384.0f) / 16384.0f; // x and y
+ outputTangent.z = ztSigns.x * sqrt( saturate( 1.0f - dot( outputTangent.xy, outputTangent.xy ) ) );
+ outputTangent.w = ztSigns.y;
+}
+
+//-----------------------------------------------------------------------------------
+// Same code as _DecompressShort2Tangent, just one returns a float4, one a float3
+void _DecompressShort2Normal( float2 inputNormal, out float3 outputNormal )
+{
+ float4 result;
+ _DecompressShort2Tangent( inputNormal, result );
+ outputNormal = result.xyz;
+}
+
+//-----------------------------------------------------------------------------------
+// Decompress normal+tangent together
+void _DecompressShort2NormalTangent( float2 inputNormal, float2 inputTangent, out float3 outputNormal, out float4 outputTangent )
+{
+ // FIXME: if we end up sticking with the SHORT2 format, pack the normal and tangent into a single SHORT4 element
+ // (that would make unpacking normal+tangent here together much cheaper than the sum of their parts)
+ _DecompressShort2Normal( inputNormal, outputNormal );
+ _DecompressShort2Tangent( inputTangent, outputTangent );
+}
+
+//=======================================================================================
+// Decompress a normal and tangent from four-component compressed format
+// We expect this data to come from an unsigned UBYTE4 stream in the range of 0..255
+// The final vTangent.w contains the sign to use in the cross product when generating a binormal
+void _DecompressUByte4NormalTangent( float4 inputNormal,
+ out float3 outputNormal, // {nX, nY, nZ}
+ out float4 outputTangent ) // {tX, tY, tZ, sign of binormal}
+{
+ float fOne = 1.0f;
+
+ float4 ztztSignBits = ( inputNormal - 128.0f ) < 0; // sign bits for zs and binormal (1 or 0) set-less-than (slt) asm instruction
+ float4 xyxyAbs = abs( inputNormal - 128.0f ) - ztztSignBits; // 0..127
+ float4 xyxySignBits = ( xyxyAbs - 64.0f ) < 0; // sign bits for xs and ys (1 or 0)
+ float4 normTan = (abs( xyxyAbs - 64.0f ) - xyxySignBits) / 63.0f; // abs({nX, nY, tX, tY})
+ outputNormal.xy = normTan.xy; // abs({nX, nY, __, __})
+ outputTangent.xy = normTan.zw; // abs({tX, tY, __, __})
+
+ float4 xyxySigns = 1 - 2*xyxySignBits; // Convert sign bits to signs
+ float4 ztztSigns = 1 - 2*ztztSignBits; // ( [1,0] -> [-1,+1] )
+
+ outputNormal.z = 1.0f - outputNormal.x - outputNormal.y; // Project onto x+y+z=1
+ outputNormal.xyz = normalize( outputNormal.xyz ); // Normalize onto unit sphere
+ outputNormal.xy *= xyxySigns.xy; // Restore x and y signs
+ outputNormal.z *= ztztSigns.x; // Restore z sign
+
+ outputTangent.z = 1.0f - outputTangent.x - outputTangent.y; // Project onto x+y+z=1
+ outputTangent.xyz = normalize( outputTangent.xyz ); // Normalize onto unit sphere
+ outputTangent.xy *= xyxySigns.zw; // Restore x and y signs
+ outputTangent.z *= ztztSigns.z; // Restore z sign
+ outputTangent.w = ztztSigns.w; // Binormal sign
+}
+
+
+//-----------------------------------------------------------------------------------
+// Decompress just a normal from four-component compressed format (same as above)
+// We expect this data to come from an unsigned UBYTE4 stream in the range of 0..255
+// [ When compiled, this works out to approximately 17 asm instructions ]
+void _DecompressUByte4Normal( float4 inputNormal,
+ out float3 outputNormal) // {nX, nY, nZ}
+{
+ float fOne = 1.0f;
+
+ float2 ztSigns = ( inputNormal.xy - 128.0f ) < 0; // sign bits for zs and binormal (1 or 0) set-less-than (slt) asm instruction
+ float2 xyAbs = abs( inputNormal.xy - 128.0f ) - ztSigns; // 0..127
+ float2 xySigns = ( xyAbs - 64.0f ) < 0; // sign bits for xs and ys (1 or 0)
+ outputNormal.xy = ( abs( xyAbs - 64.0f ) - xySigns ) / 63.0f; // abs({nX, nY})
+
+ outputNormal.z = 1.0f - outputNormal.x - outputNormal.y; // Project onto x+y+z=1
+ outputNormal.xyz = normalize( outputNormal.xyz ); // Normalize onto unit sphere
+
+ outputNormal.xy *= lerp( fOne.xx, -fOne.xx, xySigns ); // Restore x and y signs
+ outputNormal.z *= lerp( fOne.x, -fOne.x, ztSigns.x ); // Restore z sign
+}
+
+
+void DecompressVertex_Normal( float4 inputNormal, out float3 outputNormal )
+{
+ if ( COMPRESSED_VERTS == 1 )
+ {
+ if ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2 )
+ {
+ _DecompressShort2Normal( inputNormal.xy, outputNormal );
+ }
+ else // ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 )
+ {
+ _DecompressUByte4Normal( inputNormal, outputNormal );
+ }
+ }
+ else
+ {
+ outputNormal = inputNormal.xyz;
+ }
+}
+
+void DecompressVertex_NormalTangent( float4 inputNormal, float4 inputTangent, out float3 outputNormal, out float4 outputTangent )
+{
+ if ( COMPRESSED_VERTS == 1 )
+ {
+ if ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_SEPARATETANGENTS_SHORT2 )
+ {
+ _DecompressShort2NormalTangent( inputNormal.xy, inputTangent.xy, outputNormal, outputTangent );
+ }
+ else // ( COMPRESSED_NORMALS_TYPE == COMPRESSED_NORMALS_COMBINEDTANGENTS_UBYTE4 )
+ {
+ _DecompressUByte4NormalTangent( inputNormal, outputNormal, outputTangent );
+ }
+ }
+ else
+ {
+ outputNormal = inputNormal.xyz;
+ outputTangent = inputTangent;
+ }
+}
+
+
+#ifdef SHADER_MODEL_VS_3_0
+
+//-----------------------------------------------------------------------------
+// Methods to sample morph data from a vertex texture
+// NOTE: vMorphTargetTextureDim.x = width, cVertexTextureDim.y = height, cVertexTextureDim.z = # of float4 fields per vertex
+// For position + normal morph for example, there will be 2 fields.
+//-----------------------------------------------------------------------------
+float4 SampleMorphDelta( sampler2D vt, const float3 vMorphTargetTextureDim, const float4 vMorphSubrect, const float flVertexID, const float flField )
+{
+ float flColumn = floor( flVertexID / vMorphSubrect.w );
+
+ float4 t;
+ t.x = vMorphSubrect.x + vMorphTargetTextureDim.z * flColumn + flField + 0.5f;
+ t.y = vMorphSubrect.y + flVertexID - flColumn * vMorphSubrect.w + 0.5f;
+ t.xy /= vMorphTargetTextureDim.xy;
+ t.z = t.w = 0.f;
+
+ return tex2Dlod( vt, t );
+}
+
+// Optimized version which reads 2 deltas
+void SampleMorphDelta2( sampler2D vt, const float3 vMorphTargetTextureDim, const float4 vMorphSubrect, const float flVertexID, out float4 delta1, out float4 delta2 )
+{
+ float flColumn = floor( flVertexID / vMorphSubrect.w );
+
+ float4 t;
+ t.x = vMorphSubrect.x + vMorphTargetTextureDim.z * flColumn + 0.5f;
+ t.y = vMorphSubrect.y + flVertexID - flColumn * vMorphSubrect.w + 0.5f;
+ t.xy /= vMorphTargetTextureDim.xy;
+ t.z = t.w = 0.f;
+
+ delta1 = tex2Dlod( vt, t );
+ t.x += 1.0f / vMorphTargetTextureDim.x;
+ delta2 = tex2Dlod( vt, t );
+}
+
+#endif // SHADER_MODEL_VS_3_0
+
+
+#if ( defined( SHADER_MODEL_VS_2_0 ) || defined( SHADER_MODEL_VS_3_0 ) )
+
+//-----------------------------------------------------------------------------
+// Method to apply morphs
+//-----------------------------------------------------------------------------
+bool ApplyMorph( float3 vPosFlex, inout float3 vPosition )
+{
+ // Flexes coming in from a separate stream
+ float3 vPosDelta = vPosFlex.xyz * cFlexScale.x;
+ vPosition.xyz += vPosDelta;
+ return true;
+}
+
+bool ApplyMorph( float3 vPosFlex, float3 vNormalFlex, inout float3 vPosition, inout float3 vNormal )
+{
+ // Flexes coming in from a separate stream
+ float3 vPosDelta = vPosFlex.xyz * cFlexScale.x;
+ float3 vNormalDelta = vNormalFlex.xyz * cFlexScale.x;
+ vPosition.xyz += vPosDelta;
+ vNormal += vNormalDelta;
+ return true;
+}
+
+bool ApplyMorph( float3 vPosFlex, float3 vNormalFlex,
+ inout float3 vPosition, inout float3 vNormal, inout float3 vTangent )
+{
+ // Flexes coming in from a separate stream
+ float3 vPosDelta = vPosFlex.xyz * cFlexScale.x;
+ float3 vNormalDelta = vNormalFlex.xyz * cFlexScale.x;
+ vPosition.xyz += vPosDelta;
+ vNormal += vNormalDelta;
+ vTangent.xyz += vNormalDelta;
+ return true;
+}
+
+bool ApplyMorph( float4 vPosFlex, float3 vNormalFlex,
+ inout float3 vPosition, inout float3 vNormal, inout float3 vTangent, out float flWrinkle )
+{
+ // Flexes coming in from a separate stream
+ float3 vPosDelta = vPosFlex.xyz * cFlexScale.x;
+ float3 vNormalDelta = vNormalFlex.xyz * cFlexScale.x;
+ flWrinkle = vPosFlex.w * cFlexScale.y;
+ vPosition.xyz += vPosDelta;
+ vNormal += vNormalDelta;
+ vTangent.xyz += vNormalDelta;
+ return true;
+}
+
+#endif // defined( SHADER_MODEL_VS_2_0 ) || defined( SHADER_MODEL_VS_3_0 )
+
+
+#ifdef SHADER_MODEL_VS_3_0
+
+bool ApplyMorph( sampler2D morphSampler, const float3 vMorphTargetTextureDim, const float4 vMorphSubrect,
+ const float flVertexID, const float3 vMorphTexCoord,
+ inout float3 vPosition )
+{
+#if MORPHING
+
+#if !DECAL
+ // Flexes coming in from a separate stream
+ float4 vPosDelta = SampleMorphDelta( morphSampler, vMorphTargetTextureDim, vMorphSubrect, flVertexID, 0 );
+ vPosition += vPosDelta.xyz;
+#else
+ float4 t = float4( vMorphTexCoord.x, vMorphTexCoord.y, 0.0f, 0.0f );
+ float3 vPosDelta = tex2Dlod( morphSampler, t );
+ vPosition += vPosDelta.xyz * vMorphTexCoord.z;
+#endif // DECAL
+
+ return true;
+
+#else // !MORPHING
+ return false;
+#endif
+}
+
+bool ApplyMorph( sampler2D morphSampler, const float3 vMorphTargetTextureDim, const float4 vMorphSubrect,
+ const float flVertexID, const float3 vMorphTexCoord,
+ inout float3 vPosition, inout float3 vNormal )
+{
+#if MORPHING
+
+#if !DECAL
+ float4 vPosDelta, vNormalDelta;
+ SampleMorphDelta2( morphSampler, vMorphTargetTextureDim, vMorphSubrect, flVertexID, vPosDelta, vNormalDelta );
+ vPosition += vPosDelta.xyz;
+ vNormal += vNormalDelta.xyz;
+#else
+ float4 t = float4( vMorphTexCoord.x, vMorphTexCoord.y, 0.0f, 0.0f );
+ float3 vPosDelta = tex2Dlod( morphSampler, t );
+ t.x += 1.0f / vMorphTargetTextureDim.x;
+ float3 vNormalDelta = tex2Dlod( morphSampler, t );
+ vPosition += vPosDelta.xyz * vMorphTexCoord.z;
+ vNormal += vNormalDelta.xyz * vMorphTexCoord.z;
+#endif // DECAL
+
+ return true;
+
+#else // !MORPHING
+ return false;
+#endif
+}
+
+bool ApplyMorph( sampler2D morphSampler, const float3 vMorphTargetTextureDim, const float4 vMorphSubrect,
+ const float flVertexID, const float3 vMorphTexCoord,
+ inout float3 vPosition, inout float3 vNormal, inout float3 vTangent )
+{
+#if MORPHING
+
+#if !DECAL
+ float4 vPosDelta, vNormalDelta;
+ SampleMorphDelta2( morphSampler, vMorphTargetTextureDim, vMorphSubrect, flVertexID, vPosDelta, vNormalDelta );
+ vPosition += vPosDelta.xyz;
+ vNormal += vNormalDelta.xyz;
+ vTangent += vNormalDelta.xyz;
+#else
+ float4 t = float4( vMorphTexCoord.x, vMorphTexCoord.y, 0.0f, 0.0f );
+ float3 vPosDelta = tex2Dlod( morphSampler, t );
+ t.x += 1.0f / vMorphTargetTextureDim.x;
+ float3 vNormalDelta = tex2Dlod( morphSampler, t );
+ vPosition += vPosDelta.xyz * vMorphTexCoord.z;
+ vNormal += vNormalDelta.xyz * vMorphTexCoord.z;
+ vTangent += vNormalDelta.xyz * vMorphTexCoord.z;
+#endif // DECAL
+
+ return true;
+
+#else // MORPHING
+
+ return false;
+#endif
+}
+
+bool ApplyMorph( sampler2D morphSampler, const float3 vMorphTargetTextureDim, const float4 vMorphSubrect,
+ const float flVertexID, const float3 vMorphTexCoord,
+ inout float3 vPosition, inout float3 vNormal, inout float3 vTangent, out float flWrinkle )
+{
+#if MORPHING
+
+#if !DECAL
+ float4 vPosDelta, vNormalDelta;
+ SampleMorphDelta2( morphSampler, vMorphTargetTextureDim, vMorphSubrect, flVertexID, vPosDelta, vNormalDelta );
+ vPosition += vPosDelta.xyz;
+ vNormal += vNormalDelta.xyz;
+ vTangent += vNormalDelta.xyz;
+ flWrinkle = vPosDelta.w;
+#else
+ float4 t = float4( vMorphTexCoord.x, vMorphTexCoord.y, 0.0f, 0.0f );
+ float4 vPosDelta = tex2Dlod( morphSampler, t );
+ t.x += 1.0f / vMorphTargetTextureDim.x;
+ float3 vNormalDelta = tex2Dlod( morphSampler, t );
+
+ vPosition += vPosDelta.xyz * vMorphTexCoord.z;
+ vNormal += vNormalDelta.xyz * vMorphTexCoord.z;
+ vTangent += vNormalDelta.xyz * vMorphTexCoord.z;
+ flWrinkle = vPosDelta.w * vMorphTexCoord.z;
+#endif // DECAL
+
+ return true;
+
+#else // MORPHING
+
+ flWrinkle = 0.0f;
+ return false;
+
+#endif
+}
+
+#endif // SHADER_MODEL_VS_3_0
+
+
+float RangeFog( const float3 projPos )
+{
+ return max( cFogMaxDensity, ( -projPos.z * cOOFogRange + cFogEndOverFogRange ) );
+}
+
+float WaterFog( const float3 worldPos, const float3 projPos )
+{
+ float4 tmp;
+
+ tmp.xy = cEyePosWaterZ.wz - worldPos.z;
+
+ // tmp.x is the distance from the water surface to the vert
+ // tmp.y is the distance from the eye position to the vert
+
+ // if $tmp.x < 0, then set it to 0
+ // This is the equivalent of moving the vert to the water surface if it's above the water surface
+
+ tmp.x = max( 0.0f, tmp.x );
+
+ // $tmp.w = $tmp.x / $tmp.y
+ tmp.w = tmp.x / tmp.y;
+
+ tmp.w *= projPos.z;
+
+ // $tmp.w is now the distance that we see through water.
+
+ return max( cFogMaxDensity, ( -tmp.w * cOOFogRange + cFogOne ) );
+}
+
+float CalcFog( const float3 worldPos, const float3 projPos, const int fogType )
+{
+#if defined( _X360 )
+ // 360 only does pixel fog
+ return 1.0f;
+#endif
+
+ if( fogType == FOGTYPE_RANGE )
+ {
+ return RangeFog( projPos );
+ }
+ else
+ {
+#if SHADERMODEL_VS_2_0 == 1
+ // We do this work in the pixel shader in dx9, so don't do any fog here.
+ return 1.0f;
+#else
+ return WaterFog( worldPos, projPos );
+#endif
+ }
+}
+
+float CalcFog( const float3 worldPos, const float3 projPos, const bool bWaterFog )
+{
+#if defined( _X360 )
+ // 360 only does pixel fog
+ return 1.0f;
+#endif
+
+ float flFog;
+ if( !bWaterFog )
+ {
+ flFog = RangeFog( projPos );
+ }
+ else
+ {
+#if SHADERMODEL_VS_2_0 == 1
+ // We do this work in the pixel shader in dx9, so don't do any fog here.
+ flFog = 1.0f;
+#else
+ flFog = WaterFog( worldPos, projPos );
+#endif
+ }
+
+ return flFog;
+}
+
+float4 DecompressBoneWeights( const float4 weights )
+{
+ float4 result = weights;
+
+ if ( COMPRESSED_VERTS )
+ {
+ // Decompress from SHORT2 to float. In our case, [-1, +32767] -> [0, +1]
+ // NOTE: we add 1 here so we can divide by 32768 - which is exact (divide by 32767 is not).
+ // This avoids cracking between meshes with different numbers of bone weights.
+ // We use SHORT2 instead of SHORT2N for a similar reason - the GPU's conversion
+ // from [-32768,+32767] to [-1,+1] is imprecise in the same way.
+ result += 1;
+ result /= 32768;
+ }
+
+ return result;
+}
+
+void SkinPosition( bool bSkinning, const float4 modelPos,
+ const float4 boneWeights, float4 fBoneIndices,
+ out float3 worldPos )
+{
+#if !defined( _X360 )
+ int3 boneIndices = D3DCOLORtoUBYTE4( fBoneIndices );
+#else
+ int3 boneIndices = fBoneIndices;
+#endif
+
+ // Needed for invariance issues caused by multipass rendering
+#if defined( _X360 )
+ [isolate]
+#endif
+ {
+ if ( !bSkinning )
+ {
+ worldPos = mul4x3( modelPos, cModel[0] );
+ }
+ else // skinning - always three bones
+ {
+ float4x3 mat1 = cModel[boneIndices[0]];
+ float4x3 mat2 = cModel[boneIndices[1]];
+ float4x3 mat3 = cModel[boneIndices[2]];
+
+ float3 weights = DecompressBoneWeights( boneWeights ).xyz;
+ weights[2] = 1 - (weights[0] + weights[1]);
+
+ float4x3 blendMatrix = mat1 * weights[0] + mat2 * weights[1] + mat3 * weights[2];
+ worldPos = mul4x3( modelPos, blendMatrix );
+ }
+ }
+}
+
+void SkinPositionAndNormal( bool bSkinning, const float4 modelPos, const float3 modelNormal,
+ const float4 boneWeights, float4 fBoneIndices,
+ out float3 worldPos, out float3 worldNormal )
+{
+ // Needed for invariance issues caused by multipass rendering
+#if defined( _X360 )
+ [isolate]
+#endif
+ {
+
+#if !defined( _X360 )
+ int3 boneIndices = D3DCOLORtoUBYTE4( fBoneIndices );
+#else
+ int3 boneIndices = fBoneIndices;
+#endif
+
+ if ( !bSkinning )
+ {
+ worldPos = mul4x3( modelPos, cModel[0] );
+ worldNormal = mul3x3( modelNormal, ( const float3x3 )cModel[0] );
+ }
+ else // skinning - always three bones
+ {
+ float4x3 mat1 = cModel[boneIndices[0]];
+ float4x3 mat2 = cModel[boneIndices[1]];
+ float4x3 mat3 = cModel[boneIndices[2]];
+
+ float3 weights = DecompressBoneWeights( boneWeights ).xyz;
+ weights[2] = 1 - (weights[0] + weights[1]);
+
+ float4x3 blendMatrix = mat1 * weights[0] + mat2 * weights[1] + mat3 * weights[2];
+ worldPos = mul4x3( modelPos, blendMatrix );
+ worldNormal = mul3x3( modelNormal, ( float3x3 )blendMatrix );
+ }
+
+ } // end [isolate]
+}
+
+// Is it worth keeping SkinPosition and SkinPositionAndNormal around since the optimizer
+// gets rid of anything that isn't used?
+void SkinPositionNormalAndTangentSpace(
+ bool bSkinning,
+ const float4 modelPos, const float3 modelNormal,
+ const float4 modelTangentS,
+ const float4 boneWeights, float4 fBoneIndices,
+ out float3 worldPos, out float3 worldNormal,
+ out float3 worldTangentS, out float3 worldTangentT )
+{
+#if !defined( _X360 )
+ int3 boneIndices = D3DCOLORtoUBYTE4( fBoneIndices );
+#else
+ int3 boneIndices = fBoneIndices;
+#endif
+
+ // Needed for invariance issues caused by multipass rendering
+#if defined( _X360 )
+ [isolate]
+#endif
+ {
+ if ( !bSkinning )
+ {
+ worldPos = mul4x3( modelPos, cModel[0] );
+ worldNormal = mul3x3( modelNormal, ( const float3x3 )cModel[0] );
+ worldTangentS = mul3x3( ( float3 )modelTangentS, ( const float3x3 )cModel[0] );
+ }
+ else // skinning - always three bones
+ {
+ float4x3 mat1 = cModel[boneIndices[0]];
+ float4x3 mat2 = cModel[boneIndices[1]];
+ float4x3 mat3 = cModel[boneIndices[2]];
+
+ float3 weights = DecompressBoneWeights( boneWeights ).xyz;
+ weights[2] = 1 - (weights[0] + weights[1]);
+
+ float4x3 blendMatrix = mat1 * weights[0] + mat2 * weights[1] + mat3 * weights[2];
+ worldPos = mul4x3( modelPos, blendMatrix );
+ worldNormal = mul3x3( modelNormal, ( const float3x3 )blendMatrix );
+ worldTangentS = mul3x3( ( float3 )modelTangentS, ( const float3x3 )blendMatrix );
+ }
+ worldTangentT = cross( worldNormal, worldTangentS ) * modelTangentS.w;
+ }
+}
+
+
+//-----------------------------------------------------------------------------
+// Lighting helper functions
+//-----------------------------------------------------------------------------
+
+float3 AmbientLight( const float3 worldNormal )
+{
+ float3 nSquared = worldNormal * worldNormal;
+ int3 isNegative = ( worldNormal < 0.0 );
+ float3 linearColor;
+ linearColor = nSquared.x * cAmbientCubeX[isNegative.x] +
+ nSquared.y * cAmbientCubeY[isNegative.y] +
+ nSquared.z * cAmbientCubeZ[isNegative.z];
+ return linearColor;
+}
+
+// The following "internal" routines are called "privately" by other routines in this file which
+// handle the particular flavor of vs20 control flow appropriate to the original caller
+float VertexAttenInternal( const float3 worldPos, int lightNum )
+{
+ float result = 0.0f;
+
+ // Get light direction
+ float3 lightDir = cLightInfo[lightNum].pos - worldPos;
+
+ // Get light distance squared.
+ float lightDistSquared = dot( lightDir, lightDir );
+
+ // Get 1/lightDistance
+ float ooLightDist = rsqrt( lightDistSquared );
+
+ // Normalize light direction
+ lightDir *= ooLightDist;
+
+ float3 vDist;
+# if defined( _X360 )
+ {
+ //X360 dynamic compile hits an internal compiler error using dst(), this is the breakdown of how dst() works from the 360 docs.
+ vDist.x = 1;
+ vDist.y = lightDistSquared * ooLightDist;
+ vDist.z = lightDistSquared;
+ //flDist.w = ooLightDist;
+ }
+# else
+ {
+ vDist = dst( lightDistSquared, ooLightDist );
+ }
+# endif
+
+ float flDistanceAtten = 1.0f / dot( cLightInfo[lightNum].atten.xyz, vDist );
+
+ // Spot attenuation
+ float flCosTheta = dot( cLightInfo[lightNum].dir.xyz, -lightDir );
+ float flSpotAtten = (flCosTheta - cLightInfo[lightNum].spotParams.z) * cLightInfo[lightNum].spotParams.w;
+ flSpotAtten = max( 0.0001f, flSpotAtten );
+ flSpotAtten = pow( flSpotAtten, cLightInfo[lightNum].spotParams.x );
+ flSpotAtten = saturate( flSpotAtten );
+
+ // Select between point and spot
+ float flAtten = lerp( flDistanceAtten, flDistanceAtten * flSpotAtten, cLightInfo[lightNum].dir.w );
+
+ // Select between above and directional (no attenuation)
+ result = lerp( flAtten, 1.0f, cLightInfo[lightNum].color.w );
+
+ return result;
+}
+
+float CosineTermInternal( const float3 worldPos, const float3 worldNormal, int lightNum, bool bHalfLambert )
+{
+ // Calculate light direction assuming this is a point or spot
+ float3 lightDir = normalize( cLightInfo[lightNum].pos - worldPos );
+
+ // Select the above direction or the one in the structure, based upon light type
+ lightDir = lerp( lightDir, -cLightInfo[lightNum].dir, cLightInfo[lightNum].color.w );
+
+ // compute N dot L
+ float NDotL = dot( worldNormal, lightDir );
+
+ if ( !bHalfLambert )
+ {
+ NDotL = max( 0.0f, NDotL );
+ }
+ else // Half-Lambert
+ {
+ NDotL = NDotL * 0.5 + 0.5;
+ NDotL = NDotL * NDotL;
+ }
+ return NDotL;
+}
+
+// This routine uses booleans to do early-outs and is meant to be called by routines OUTSIDE of this file
+float GetVertexAttenForLight( const float3 worldPos, int lightNum, bool bUseStaticControlFlow )
+{
+ float result = 0.0f;
+
+ // Direct3D uses static control flow but OpenGL currently does not
+ if ( bUseStaticControlFlow )
+ {
+ if ( g_bLightEnabled[lightNum] )
+ {
+ result = VertexAttenInternal( worldPos, lightNum );
+ }
+ }
+ else // OpenGL non-static-control-flow path
+ {
+ result = VertexAttenInternal( worldPos, lightNum );
+ }
+
+ return result;
+}
+
+float3 DoLightInternal( const float3 worldPos, const float3 worldNormal, int lightNum, bool bHalfLambert )
+{
+ return cLightInfo[lightNum].color *
+ CosineTermInternal( worldPos, worldNormal, lightNum, bHalfLambert ) *
+ VertexAttenInternal( worldPos, lightNum );
+}
+
+float3 DoLighting( const float3 worldPos, const float3 worldNormal,
+ const float3 staticLightingColor, const bool bStaticLight,
+ const bool bDynamicLight, bool bHalfLambert )
+{
+ float3 linearColor = float3( 0.0f, 0.0f, 0.0f );
+
+ if( bStaticLight ) // Static light
+ {
+ float3 col = staticLightingColor * cOverbright;
+#if defined ( _X360 )
+ linearColor += col * col;
+#else
+ linearColor += GammaToLinear( col );
+#endif
+ }
+
+ if( bDynamicLight ) // Dynamic light
+ {
+ for (int i = 0; i < g_nLightCount; i++)
+ {
+ linearColor += DoLightInternal( worldPos, worldNormal, i, bHalfLambert );
+ }
+ }
+
+ if( bDynamicLight )
+ {
+ linearColor += AmbientLight( worldNormal ); //ambient light is already remapped
+ }
+
+ return linearColor;
+}
+
+float3 DoLightingUnrolled( const float3 worldPos, const float3 worldNormal,
+ const float3 staticLightingColor, const bool bStaticLight,
+ const bool bDynamicLight, bool bHalfLambert, const int nNumLights )
+{
+ float3 linearColor = float3( 0.0f, 0.0f, 0.0f );
+
+ if( bStaticLight ) // Static light
+ {
+ linearColor += GammaToLinear( staticLightingColor * cOverbright );
+ }
+
+ if( bDynamicLight ) // Ambient light
+ {
+ if ( nNumLights >= 1 )
+ linearColor += DoLightInternal( worldPos, worldNormal, 0, bHalfLambert );
+ if ( nNumLights >= 2 )
+ linearColor += DoLightInternal( worldPos, worldNormal, 1, bHalfLambert );
+ if ( nNumLights >= 3 )
+ linearColor += DoLightInternal( worldPos, worldNormal, 2, bHalfLambert );
+ if ( nNumLights >= 4 )
+ linearColor += DoLightInternal( worldPos, worldNormal, 3, bHalfLambert );
+ }
+
+ if( bDynamicLight )
+ {
+ linearColor += AmbientLight( worldNormal ); //ambient light is already remapped
+ }
+
+ return linearColor;
+}
+
+int4 FloatToInt( in float4 floats )
+{
+ return D3DCOLORtoUBYTE4( floats.zyxw / 255.001953125 );
+}
+
+float2 ComputeSphereMapTexCoords( in float3 reflectionVector )
+{
+ // transform reflection vector into view space
+ reflectionVector = mul( reflectionVector, ( float3x3 )cViewModel );
+
+ // generate <rx ry rz+1>
+ float3 tmp = float3( reflectionVector.x, reflectionVector.y, reflectionVector.z + 1.0f );
+
+ // find 1 / len
+ float ooLen = dot( tmp, tmp );
+ ooLen = 1.0f / sqrt( ooLen );
+
+ // tmp = tmp/|tmp| + 1
+ tmp.xy = ooLen * tmp.xy + 1.0f;
+
+ return tmp.xy * 0.5f;
+}
+
+
+#define DEFORMATION_CLAMP_TO_BOX_IN_WORLDSPACE 1
+ // minxyz.minsoftness / maxxyz.maxsoftness
+float3 ApplyDeformation( float3 worldpos, int deftype, float4 defparms0, float4 defparms1,
+ float4 defparms2, float4 defparms3 )
+{
+ float3 ret = worldpos;
+ if ( deftype == DEFORMATION_CLAMP_TO_BOX_IN_WORLDSPACE )
+ {
+ ret=max( ret, defparms2.xyz );
+ ret=min( ret, defparms3.xyz );
+ }
+
+ return ret;
+}
+
+
+#endif //#ifndef COMMON_VS_FXC_H_
diff --git a/mp/src/materialsystem/stdshaders/cpp_shader_constant_register_map.h b/mp/src/materialsystem/stdshaders/cpp_shader_constant_register_map.h new file mode 100644 index 00000000..b448b048 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/cpp_shader_constant_register_map.h @@ -0,0 +1,45 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Provide convenient mapping for shader constants
+//
+// $NoKeywords: $
+//=============================================================================
+
+#define C_CODE_HACK
+#include "shader_constant_register_map.h"
+#undef C_CODE_HACK
+
+// For the C code, map the above file's defines back to integers...
+#define PSREG_CONSTANT_00 0
+#define PSREG_CONSTANT_01 1
+#define PSREG_CONSTANT_02 2
+#define PSREG_CONSTANT_03 3
+#define PSREG_CONSTANT_04 4
+#define PSREG_CONSTANT_05 5
+#define PSREG_CONSTANT_06 6
+#define PSREG_CONSTANT_07 7
+#define PSREG_CONSTANT_08 8
+#define PSREG_CONSTANT_09 9
+#define PSREG_CONSTANT_10 10
+#define PSREG_CONSTANT_11 11
+#define PSREG_CONSTANT_12 12
+#define PSREG_CONSTANT_13 13
+#define PSREG_CONSTANT_14 14
+#define PSREG_CONSTANT_15 15
+#define PSREG_CONSTANT_16 16
+#define PSREG_CONSTANT_17 17
+#define PSREG_CONSTANT_18 18
+#define PSREG_CONSTANT_19 19
+#define PSREG_CONSTANT_20 20
+#define PSREG_CONSTANT_21 21
+#define PSREG_CONSTANT_22 22
+#define PSREG_CONSTANT_23 23
+#define PSREG_CONSTANT_24 24
+#define PSREG_CONSTANT_25 25
+#define PSREG_CONSTANT_26 26
+#define PSREG_CONSTANT_27 27
+#define PSREG_CONSTANT_28 28
+#define PSREG_CONSTANT_29 29
+#define PSREG_CONSTANT_30 30
+#define PSREG_CONSTANT_31 31
+
diff --git a/mp/src/materialsystem/stdshaders/dx8fallbacks.cpp b/mp/src/materialsystem/stdshaders/dx8fallbacks.cpp new file mode 100644 index 00000000..9ee2659c --- /dev/null +++ b/mp/src/materialsystem/stdshaders/dx8fallbacks.cpp @@ -0,0 +1,11 @@ +#include "BaseVSShader.h"
+
+// This one isn't supported on dx8
+DEFINE_FALLBACK_SHADER( SDK_DepthWrite, Wireframe )
+
+DEFINE_FALLBACK_SHADER( SDK_EyeRefract, Eyes_dx8 )
+DEFINE_FALLBACK_SHADER( SDK_VolumeClouds, UnlitGeneric_DX8 )
+
+// FIXME: These aren't supported on dx8, but need to be.
+DEFINE_FALLBACK_SHADER( SDK_EyeGlint, EyeGlint )
+DEFINE_FALLBACK_SHADER( SDK_AfterShock, AfterShock )
diff --git a/mp/src/materialsystem/stdshaders/example_model_dx9.cpp b/mp/src/materialsystem/stdshaders/example_model_dx9.cpp new file mode 100644 index 00000000..87e012e3 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/example_model_dx9.cpp @@ -0,0 +1,60 @@ +//===================== Copyright (c) Valve Corporation. All Rights Reserved. ======================
+//
+// Example shader that can be applied to models
+//
+//==================================================================================================
+
+#include "BaseVSShader.h"
+#include "convar.h"
+#include "example_model_dx9_helper.h"
+
+#ifdef GAME_SHADER_DLL
+DEFINE_FALLBACK_SHADER( Mod_Example_Model, Mod_Example_Model_DX9 )
+BEGIN_VS_SHADER( Mod_Example_Model_DX9, "Help for Example Model Shader" )
+#else
+DEFINE_FALLBACK_SHADER( Example_Model, Example_Model_DX9 )
+BEGIN_VS_SHADER( Example_Model_DX9, "Help for Example Model Shader" )
+#endif
+
+ BEGIN_SHADER_PARAMS
+ SHADER_PARAM( ALPHATESTREFERENCE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
+ END_SHADER_PARAMS
+
+ void SetupVars( ExampleModel_DX9_Vars_t& info )
+ {
+ info.m_nBaseTexture = BASETEXTURE;
+ info.m_nBaseTextureFrame = FRAME;
+ info.m_nBaseTextureTransform = BASETEXTURETRANSFORM;
+ info.m_nAlphaTestReference = ALPHATESTREFERENCE;
+ info.m_nFlashlightTexture = FLASHLIGHTTEXTURE;
+ info.m_nFlashlightTextureFrame = FLASHLIGHTTEXTUREFRAME;
+ }
+
+ SHADER_INIT_PARAMS()
+ {
+ ExampleModel_DX9_Vars_t info;
+ SetupVars( info );
+ InitParamsExampleModel_DX9( this, params, pMaterialName, info );
+ }
+
+ SHADER_FALLBACK
+ {
+ return 0;
+ }
+
+ SHADER_INIT
+ {
+ ExampleModel_DX9_Vars_t info;
+ SetupVars( info );
+ InitExampleModel_DX9( this, params, info );
+ }
+
+ SHADER_DRAW
+ {
+ ExampleModel_DX9_Vars_t info;
+ SetupVars( info );
+ DrawExampleModel_DX9( this, params, pShaderAPI, pShaderShadow, info, vertexCompression, pContextDataPtr );
+ }
+
+END_SHADER
+
diff --git a/mp/src/materialsystem/stdshaders/example_model_dx9_helper.cpp b/mp/src/materialsystem/stdshaders/example_model_dx9_helper.cpp new file mode 100644 index 00000000..471b9f80 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/example_model_dx9_helper.cpp @@ -0,0 +1,341 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+#include "BaseVSShader.h"
+#include "example_model_dx9_helper.h"
+#include "convar.h"
+#include "cpp_shader_constant_register_map.h"
+#include "example_model_vs20.inc"
+#include "example_model_ps20b.inc"
+#include "commandbuilder.h"
+
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static ConVar mat_fullbright( "mat_fullbright", "0", FCVAR_CHEAT );
+static ConVar r_lightwarpidentity( "r_lightwarpidentity", "0", FCVAR_CHEAT );
+static ConVar r_rimlight( "r_rimlight", "1", FCVAR_CHEAT );
+
+// Textures may be bound to the following samplers:
+// SHADER_SAMPLER0 Base (Albedo) / Gloss in alpha
+// SHADER_SAMPLER4 Flashlight Shadow Depth Map
+// SHADER_SAMPLER5 Normalization cube map
+// SHADER_SAMPLER6 Flashlight Cookie
+
+
+//-----------------------------------------------------------------------------
+// Initialize shader parameters
+//-----------------------------------------------------------------------------
+void InitParamsExampleModel_DX9( CBaseVSShader *pShader, IMaterialVar** params, const char *pMaterialName, ExampleModel_DX9_Vars_t &info )
+{
+ // FLASHLIGHTFIXME: Do ShaderAPI::BindFlashlightTexture
+ Assert( info.m_nFlashlightTexture >= 0 );
+
+ if ( g_pHardwareConfig->SupportsBorderColor() )
+ {
+ params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight_border" );
+ }
+ else
+ {
+ params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" );
+ }
+
+ // This shader can be used with hw skinning
+ SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING );
+ SET_FLAGS2( MATERIAL_VAR2_LIGHTING_VERTEX_LIT );
+}
+
+//-----------------------------------------------------------------------------
+// Initialize shader
+//-----------------------------------------------------------------------------
+void InitExampleModel_DX9( CBaseVSShader *pShader, IMaterialVar** params, ExampleModel_DX9_Vars_t &info )
+{
+ Assert( info.m_nFlashlightTexture >= 0 );
+ pShader->LoadTexture( info.m_nFlashlightTexture, TEXTUREFLAGS_SRGB );
+
+ bool bIsBaseTextureTranslucent = false;
+ if ( params[info.m_nBaseTexture]->IsDefined() )
+ {
+ pShader->LoadTexture( info.m_nBaseTexture, TEXTUREFLAGS_SRGB );
+
+ if ( params[info.m_nBaseTexture]->GetTextureValue()->IsTranslucent() )
+ {
+ bIsBaseTextureTranslucent = true;
+ }
+ }
+}
+
+class CExampleModel_DX9_Context : public CBasePerMaterialContextData
+{
+public:
+ CCommandBufferBuilder< CFixedCommandStorageBuffer< 800 > > m_SemiStaticCmdsOut;
+ bool m_bFastPath;
+
+};
+
+//-----------------------------------------------------------------------------
+// Draws the shader
+//-----------------------------------------------------------------------------
+void DrawExampleModel_DX9_Internal( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow,
+ bool bHasFlashlight, ExampleModel_DX9_Vars_t &info, VertexCompressionType_t vertexCompression,
+ CBasePerMaterialContextData **pContextDataPtr )
+{
+ bool bHasBaseTexture = (info.m_nBaseTexture != -1) && params[info.m_nBaseTexture]->IsTexture();
+ bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0;
+
+ BlendType_t nBlendType= pShader->EvaluateBlendRequirements( info.m_nBaseTexture, true );
+ bool bFullyOpaque = ( nBlendType != BT_BLENDADD ) && ( nBlendType != BT_BLEND ) && !bIsAlphaTested && !bHasFlashlight;
+
+ CExampleModel_DX9_Context *pContextData = reinterpret_cast< CExampleModel_DX9_Context *> ( *pContextDataPtr );
+ if ( !pContextData )
+ {
+ pContextData = new CExampleModel_DX9_Context;
+ *pContextDataPtr = pContextData;
+ }
+
+ if( pShader->IsSnapshotting() )
+ {
+ pShaderShadow->EnableAlphaTest( bIsAlphaTested );
+
+ if( info.m_nAlphaTestReference != -1 && params[info.m_nAlphaTestReference]->GetFloatValue() > 0.0f )
+ {
+ pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[info.m_nAlphaTestReference]->GetFloatValue() );
+ }
+
+ int nShadowFilterMode = 0;
+ if( bHasFlashlight )
+ {
+ if (params[info.m_nBaseTexture]->IsTexture())
+ {
+ pShader->SetAdditiveBlendingShadowState( info.m_nBaseTexture, true );
+ }
+
+ if( bIsAlphaTested )
+ {
+ // disable alpha test and use the zfunc zequals since alpha isn't guaranteed to
+ // be the same on both the regular pass and the flashlight pass.
+ pShaderShadow->EnableAlphaTest( false );
+ pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL );
+ }
+ pShaderShadow->EnableBlending( true );
+ pShaderShadow->EnableDepthWrites( false );
+
+ // Be sure not to write to dest alpha
+ pShaderShadow->EnableAlphaWrites( false );
+
+ nShadowFilterMode = g_pHardwareConfig->GetShadowFilterMode(); // Based upon vendor and device dependent formats
+ }
+ else // not flashlight pass
+ {
+ if (params[info.m_nBaseTexture]->IsTexture())
+ {
+ pShader->SetDefaultBlendingShadowState( info.m_nBaseTexture, true );
+ }
+ }
+
+ unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
+ int userDataSize = 0;
+
+ // Always enable...will bind white if nothing specified...
+ pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); // Base (albedo) map
+ pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
+
+ if( bHasFlashlight )
+ {
+ pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); // Shadow depth map
+ pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER4 );
+ pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, false );
+ pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); // Noise map
+ pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); // Flashlight cookie
+ pShaderShadow->EnableSRGBRead( SHADER_SAMPLER6, true );
+ userDataSize = 4; // tangent S
+ }
+
+ // Always enable, since flat normal will be bound
+ pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); // Normal map
+ userDataSize = 4; // tangent S
+ pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); // Normalizing cube map
+ pShaderShadow->EnableSRGBWrite( true );
+
+ // texcoord0 : base texcoord, texcoord2 : decal hw morph delta
+ int pTexCoordDim[3] = { 2, 0, 3 };
+ int nTexCoordCount = 1;
+
+ // This shader supports compressed vertices, so OR in that flag:
+ flags |= VERTEX_FORMAT_COMPRESSED;
+
+ pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, pTexCoordDim, userDataSize );
+
+ DECLARE_STATIC_VERTEX_SHADER( example_model_vs20 );
+ SET_STATIC_VERTEX_SHADER( example_model_vs20 );
+
+ // Assume we're only going to get in here if we support 2b
+ DECLARE_STATIC_PIXEL_SHADER( example_model_ps20b );
+ SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bHasFlashlight );
+ SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode );
+ SET_STATIC_PIXEL_SHADER_COMBO( CONVERT_TO_SRGB, 0 );
+ SET_STATIC_PIXEL_SHADER( example_model_ps20b );
+
+ if( bHasFlashlight )
+ {
+ pShader->FogToBlack();
+ }
+ else
+ {
+ pShader->DefaultFog();
+ }
+
+ // HACK HACK HACK - enable alpha writes all the time so that we have them for underwater stuff
+ pShaderShadow->EnableAlphaWrites( bFullyOpaque );
+ }
+ else // not snapshotting -- begin dynamic state
+ {
+ bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE );
+
+ if( bHasBaseTexture )
+ {
+ pShader->BindTexture( SHADER_SAMPLER0, info.m_nBaseTexture, info.m_nBaseTextureFrame );
+ }
+ else
+ {
+ pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE );
+ }
+
+ LightState_t lightState = { 0, false, false };
+ bool bFlashlightShadows = false;
+ if( bHasFlashlight )
+ {
+ Assert( info.m_nFlashlightTexture >= 0 && info.m_nFlashlightTextureFrame >= 0 );
+ pShader->BindTexture( SHADER_SAMPLER6, info.m_nFlashlightTexture, info.m_nFlashlightTextureFrame );
+ VMatrix worldToTexture;
+ ITexture *pFlashlightDepthTexture;
+ FlashlightState_t state = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );
+ bFlashlightShadows = state.m_bEnableShadows && ( pFlashlightDepthTexture != NULL );
+
+ SetFlashLightColorFromState( state, pShaderAPI, PSREG_FLASHLIGHT_COLOR );
+
+ if( pFlashlightDepthTexture && g_pConfig->ShadowDepthTexture() && state.m_bEnableShadows )
+ {
+ pShader->BindTexture( SHADER_SAMPLER4, pFlashlightDepthTexture, 0 );
+ pShaderAPI->BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SHADOW_NOISE_2D );
+ }
+ }
+ else // no flashlight
+ {
+ pShaderAPI->GetDX9LightState( &lightState );
+ }
+
+ MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode();
+ int fogIndex = ( fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ) ? 1 : 0;
+ int numBones = pShaderAPI->GetCurrentNumBones();
+
+ bool bWriteDepthToAlpha = false;
+ bool bWriteWaterFogToAlpha = false;
+ if( bFullyOpaque )
+ {
+ bWriteDepthToAlpha = pShaderAPI->ShouldWriteDepthToDestAlpha();
+ bWriteWaterFogToAlpha = (fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z);
+ AssertMsg( !(bWriteDepthToAlpha && bWriteWaterFogToAlpha), "Can't write two values to alpha at the same time." );
+ }
+
+ DECLARE_DYNAMIC_VERTEX_SHADER( example_model_vs20 );
+ SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex );
+ SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, numBones > 0 );
+ SET_DYNAMIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, pShaderAPI->GetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING)!=0);
+ SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
+ SET_DYNAMIC_VERTEX_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
+ SET_DYNAMIC_VERTEX_SHADER( example_model_vs20 );
+
+ DECLARE_DYNAMIC_PIXEL_SHADER( example_model_ps20b );
+ SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
+ SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha );
+ SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha );
+ SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
+ SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows );
+ SET_DYNAMIC_PIXEL_SHADER( example_model_ps20b );
+
+ pShader->SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nBaseTextureTransform );
+ pShader->SetModulationPixelShaderDynamicState_LinearColorSpace( 1 );
+ pShader->SetAmbientCubeDynamicStateVertexShader();
+
+ if( !bHasFlashlight )
+ {
+ pShaderAPI->BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED );
+ }
+
+ pShaderAPI->SetPixelShaderStateAmbientLightCube( PSREG_AMBIENT_CUBE, !lightState.m_bAmbientLight ); // Force to black if not bAmbientLight
+ pShaderAPI->CommitPixelShaderLighting( PSREG_LIGHT_INFO_ARRAY );
+
+ // handle mat_fullbright 2 (diffuse lighting only)
+ if( bLightingOnly )
+ {
+ pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY );
+ }
+
+ pShaderAPI->SetPixelShaderFogParams( PSREG_FOG_PARAMS );
+
+ if( bHasFlashlight )
+ {
+ VMatrix worldToTexture;
+ float atten[4], pos[4], tweaks[4];
+
+ const FlashlightState_t &flashlightState = pShaderAPI->GetFlashlightState( worldToTexture );
+ SetFlashLightColorFromState( flashlightState, pShaderAPI, PSREG_FLASHLIGHT_COLOR );
+
+ pShader->BindTexture( SHADER_SAMPLER6, flashlightState.m_pSpotlightTexture, flashlightState.m_nSpotlightTextureFrame );
+
+ atten[0] = flashlightState.m_fConstantAtten; // Set the flashlight attenuation factors
+ atten[1] = flashlightState.m_fLinearAtten;
+ atten[2] = flashlightState.m_fQuadraticAtten;
+ atten[3] = flashlightState.m_FarZ;
+ pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, atten, 1 );
+
+ pos[0] = flashlightState.m_vecLightOrigin[0]; // Set the flashlight origin
+ pos[1] = flashlightState.m_vecLightOrigin[1];
+ pos[2] = flashlightState.m_vecLightOrigin[2];
+ pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_POSITION_RIM_BOOST, pos, 1 );
+
+ pShaderAPI->SetPixelShaderConstant( PSREG_FLASHLIGHT_TO_WORLD_TEXTURE, worldToTexture.Base(), 4 );
+
+ // Tweaks associated with a given flashlight
+ tweaks[0] = ShadowFilterFromState( flashlightState );
+ tweaks[1] = ShadowAttenFromState( flashlightState );
+ pShader->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 );
+ }
+ }
+ pShader->Draw();
+}
+
+
+//-----------------------------------------------------------------------------
+// Draws the shader
+//-----------------------------------------------------------------------------
+void DrawExampleModel_DX9( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow,
+ ExampleModel_DX9_Vars_t &info, VertexCompressionType_t vertexCompression, CBasePerMaterialContextData **pContextDataPtr )
+
+{
+ bool bHasFlashlight = pShader->UsingFlashlight( params );
+ if ( bHasFlashlight )
+ {
+ DrawExampleModel_DX9_Internal( pShader, params, pShaderAPI, pShaderShadow, false, info, vertexCompression, pContextDataPtr++ );
+ if ( pShaderShadow )
+ {
+ pShader->SetInitialShadowState( );
+ }
+ }
+ DrawExampleModel_DX9_Internal( pShader, params, pShaderAPI, pShaderShadow, bHasFlashlight, info, vertexCompression, pContextDataPtr );
+}
diff --git a/mp/src/materialsystem/stdshaders/example_model_dx9_helper.h b/mp/src/materialsystem/stdshaders/example_model_dx9_helper.h new file mode 100644 index 00000000..3b82e71f --- /dev/null +++ b/mp/src/materialsystem/stdshaders/example_model_dx9_helper.h @@ -0,0 +1,46 @@ +//===================== Copyright (c) Valve Corporation. All Rights Reserved. ======================
+//
+// Example shader that can be applied to models
+//
+//==================================================================================================
+
+#ifndef EXAMPLE_MODEL_DX9_HELPER_H
+#define EXAMPLE_MODEL_DX9_HELPER_H
+
+#include <string.h>
+
+//-----------------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------------
+class CBaseVSShader;
+class IMaterialVar;
+class IShaderDynamicAPI;
+class IShaderShadow;
+
+//-----------------------------------------------------------------------------
+// Init params/ init/ draw methods
+//-----------------------------------------------------------------------------
+struct ExampleModel_DX9_Vars_t
+{
+ ExampleModel_DX9_Vars_t() { memset( this, 0xFF, sizeof(*this) ); }
+
+ int m_nBaseTexture;
+ int m_nBaseTextureFrame;
+ int m_nBaseTextureTransform;
+ int m_nAlphaTestReference;
+ int m_nFlashlightTexture;
+ int m_nFlashlightTextureFrame;
+};
+
+void InitParamsExampleModel_DX9( CBaseVSShader *pShader, IMaterialVar** params,
+ const char *pMaterialName, ExampleModel_DX9_Vars_t &info );
+
+void InitExampleModel_DX9( CBaseVSShader *pShader, IMaterialVar** params,
+ ExampleModel_DX9_Vars_t &info );
+
+void DrawExampleModel_DX9( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI,
+ IShaderShadow* pShaderShadow,
+ ExampleModel_DX9_Vars_t &info, VertexCompressionType_t vertexCompression,
+ CBasePerMaterialContextData **pContextDataPtr );
+
+#endif // EXAMPLE_MODEL_DX9_HELPER_H
diff --git a/mp/src/materialsystem/stdshaders/example_model_ps20b.fxc b/mp/src/materialsystem/stdshaders/example_model_ps20b.fxc new file mode 100644 index 00000000..a7b35e44 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/example_model_ps20b.fxc @@ -0,0 +1,92 @@ +//===================== Copyright (c) Valve Corporation. All Rights Reserved. ======================
+//
+// Example pixel shader that can be applied to models
+//
+//==================================================================================================
+
+// STATIC: "CONVERT_TO_SRGB" "0..0"
+// STATIC: "FLASHLIGHT" "0..1"
+// STATIC: "FLASHLIGHTDEPTHFILTERMODE" "0..2" [ps20b]
+
+// DYNAMIC: "WRITEWATERFOGTODESTALPHA" "0..1"
+// DYNAMIC: "PIXELFOGTYPE" "0..1"
+// DYNAMIC: "NUM_LIGHTS" "0..4"
+// DYNAMIC: "WRITE_DEPTH_TO_DESTALPHA" "0..1" [ps20b]
+// DYNAMIC: "FLASHLIGHTSHADOWS" "0..1" [ps20b]
+
+// SKIP: ($PIXELFOGTYPE == 0) && ($WRITEWATERFOGTODESTALPHA != 0)
+
+// We don't care about flashlight depth unless the flashlight is on
+// SKIP: ( $FLASHLIGHT == 0 ) && ( $FLASHLIGHTSHADOWS == 1 )
+
+// Flashlight shadow filter mode is irrelevant if there is no flashlight
+// SKIP: ( $FLASHLIGHT == 0 ) && ( $FLASHLIGHTDEPTHFILTERMODE != 0 ) [ps20b]
+
+#include "common_flashlight_fxc.h"
+#include "shader_constant_register_map.h"
+
+const float4 g_DiffuseModulation : register( PSREG_DIFFUSE_MODULATION );
+const float4 g_ShadowTweaks : register( PSREG_ENVMAP_TINT__SHADOW_TWEAKS );
+const float3 cAmbientCube[6] : register( PSREG_AMBIENT_CUBE );
+const float4 g_EyePos : register( PSREG_EYEPOS_SPEC_EXPONENT );
+const float4 g_FogParams : register( PSREG_FOG_PARAMS );
+const float4 g_FlashlightAttenuationFactors : register( PSREG_FLASHLIGHT_ATTENUATION ); // On non-flashlight pass
+const float4 g_FlashlightPos_RimBoost : register( PSREG_FLASHLIGHT_POSITION_RIM_BOOST );
+const float4x4 g_FlashlightWorldToTexture : register( PSREG_FLASHLIGHT_TO_WORLD_TEXTURE );
+PixelShaderLightInfo cLightInfo[3] : register( PSREG_LIGHT_INFO_ARRAY ); // 2 registers each - 6 registers total (4th light spread across w's)
+
+#define g_FlashlightPos g_FlashlightPos_RimBoost.xyz
+
+sampler BaseTextureSampler : register( s0 ); // Base map, selfillum in alpha
+sampler ShadowDepthSampler : register( s4 ); // Flashlight shadow depth map sampler
+sampler NormalizeRandRotSampler : register( s5 ); // Normalization / RandomRotation samplers
+sampler FlashlightSampler : register( s6 ); // Flashlight cookie
+
+struct PS_INPUT
+{
+ float2 baseTexCoord : TEXCOORD0;
+ float4 lightAtten : TEXCOORD1;
+ float3 worldNormal : TEXCOORD2;
+ float3 worldPos : TEXCOORD3;
+ float3 projPos : TEXCOORD4;
+};
+
+float4 main( PS_INPUT i ) : COLOR
+{
+ float4 baseColor = tex2D( BaseTextureSampler, i.baseTexCoord );
+
+ float3 diffuseLighting;
+ if ( FLASHLIGHT != 0 )
+ {
+ float4 flashlightSpacePosition = mul( float4( i.worldPos, 1.0f ), g_FlashlightWorldToTexture );
+
+ diffuseLighting = DoFlashlight( g_FlashlightPos, i.worldPos, flashlightSpacePosition,
+ i.worldNormal, g_FlashlightAttenuationFactors.xyz,
+ g_FlashlightAttenuationFactors.w, FlashlightSampler, ShadowDepthSampler,
+ NormalizeRandRotSampler, FLASHLIGHTDEPTHFILTERMODE, FLASHLIGHTSHADOWS, true, i.projPos, false, g_ShadowTweaks );
+ }
+ else // non-flashlight path
+ {
+ // Summation of diffuse illumination from all local lights
+ diffuseLighting = PixelShaderDoLighting( i.worldPos, i.worldNormal,
+ float3( 0.0f, 0.0f, 0.0f ), false, true, i.lightAtten,
+ cAmbientCube, NormalizeRandRotSampler, NUM_LIGHTS, cLightInfo, true,
+
+ // These are dummy parameters:
+ false, 1.0f,
+ false, BaseTextureSampler );
+ }
+
+ float3 result = baseColor.rgb * g_DiffuseModulation.rgb * diffuseLighting;
+ float alpha = g_DiffuseModulation.a * baseColor.a;
+
+ float fogFactor = CalcPixelFogFactor( PIXELFOGTYPE, g_FogParams, g_EyePos.z, i.worldPos.z, i.projPos.z );
+
+#if WRITEWATERFOGTODESTALPHA && ( PIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT )
+ alpha = fogFactor;
+#endif
+
+ bool bWriteDepthToAlpha = ( WRITE_DEPTH_TO_DESTALPHA != 0 ) && ( WRITEWATERFOGTODESTALPHA == 0 );
+
+ return FinalOutput( float4( result, alpha ), fogFactor, PIXELFOGTYPE, TONEMAP_SCALE_LINEAR, bWriteDepthToAlpha, i.projPos.z );
+}
diff --git a/mp/src/materialsystem/stdshaders/example_model_vs20.fxc b/mp/src/materialsystem/stdshaders/example_model_vs20.fxc new file mode 100644 index 00000000..877c84e2 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/example_model_vs20.fxc @@ -0,0 +1,91 @@ +//===================== Copyright (c) Valve Corporation. All Rights Reserved. ======================
+//
+// Example vertex shader that can be applied to models
+//
+//==================================================================================================
+
+// DYNAMIC: "COMPRESSED_VERTS" "0..1"
+// DYNAMIC: "DOWATERFOG" "0..1"
+// DYNAMIC: "SKINNING" "0..1"
+// DYNAMIC: "LIGHTING_PREVIEW" "0..1"
+// DYNAMIC: "NUM_LIGHTS" "0..4"
+
+#include "common_vs_fxc.h"
+
+static const bool g_bSkinning = SKINNING ? true : false;
+static const int g_FogType = DOWATERFOG;
+
+const float4 cBaseTexCoordTransform[2] : register( SHADER_SPECIFIC_CONST_0 );
+
+//-----------------------------------------------------------------------------
+// Input vertex format
+//-----------------------------------------------------------------------------
+struct VS_INPUT
+{
+ // This is all of the stuff that we ever use.
+ float4 vPos : POSITION;
+ float4 vBoneWeights : BLENDWEIGHT;
+ float4 vBoneIndices : BLENDINDICES;
+ float4 vNormal : NORMAL;
+ float2 vTexCoord0 : TEXCOORD0;
+};
+
+struct VS_OUTPUT
+{
+ // Stuff that isn't seen by the pixel shader
+ float4 projPosSetup : POSITION;
+ float fog : FOG;
+ // Stuff that is seen by the pixel shader
+ float2 baseTexCoord : TEXCOORD0;
+ float4 lightAtten : TEXCOORD1;
+ float3 worldNormal : TEXCOORD2;
+ float3 worldPos : TEXCOORD3;
+ float3 projPos : TEXCOORD4;
+};
+
+//-----------------------------------------------------------------------------
+// Main shader entry point
+//-----------------------------------------------------------------------------
+VS_OUTPUT main( const VS_INPUT v )
+{
+ VS_OUTPUT o = ( VS_OUTPUT )0;
+
+ float3 vNormal;
+ DecompressVertex_Normal( v.vNormal, vNormal );
+
+ float3 worldNormal, worldPos;
+ SkinPositionAndNormal( g_bSkinning, v.vPos, vNormal, v.vBoneWeights, v.vBoneIndices, worldPos, worldNormal );
+
+ // Transform into projection space
+ float4 vProjPos = mul( float4( worldPos, 1 ), cViewProj );
+ o.projPosSetup = vProjPos;
+ vProjPos.z = dot( float4( worldPos, 1 ), cViewProjZ );
+
+ o.projPos = vProjPos.xyz;
+ o.fog = CalcFog( worldPos, vProjPos.xyz, g_FogType );
+
+ // Needed for water fog alpha and diffuse lighting
+ o.worldPos = worldPos;
+ o.worldNormal = normalize( worldNormal );
+
+ // Scalar attenuations for four lights
+ o.lightAtten.xyz = float4(0,0,0,0);
+ #if ( NUM_LIGHTS > 0 )
+ o.lightAtten.x = GetVertexAttenForLight( worldPos, 0, false );
+ #endif
+ #if ( NUM_LIGHTS > 1 )
+ o.lightAtten.y = GetVertexAttenForLight( worldPos, 1, false );
+ #endif
+ #if ( NUM_LIGHTS > 2 )
+ o.lightAtten.z = GetVertexAttenForLight( worldPos, 2, false );
+ #endif
+ #if ( NUM_LIGHTS > 3 )
+ o.lightAtten.w = GetVertexAttenForLight( worldPos, 3, false );
+ #endif
+
+ // Base texture coordinate transform
+ o.baseTexCoord.x = dot( v.vTexCoord0, cBaseTexCoordTransform[0] );
+ o.baseTexCoord.y = dot( v.vTexCoord0, cBaseTexCoordTransform[1] );
+
+ return o;
+}
diff --git a/mp/src/materialsystem/stdshaders/fxctmp9/example_model_ps20b.inc b/mp/src/materialsystem/stdshaders/fxctmp9/example_model_ps20b.inc new file mode 100644 index 00000000..018f7b63 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/fxctmp9/example_model_ps20b.inc @@ -0,0 +1,237 @@ +#include "shaderlib/cshader.h"
+class example_model_ps20b_Static_Index
+{
+private:
+ int m_nCONVERT_TO_SRGB;
+#ifdef _DEBUG
+ bool m_bCONVERT_TO_SRGB;
+#endif
+public:
+ void SetCONVERT_TO_SRGB( int i )
+ {
+ Assert( i >= 0 && i <= 0 );
+ m_nCONVERT_TO_SRGB = i;
+#ifdef _DEBUG
+ m_bCONVERT_TO_SRGB = true;
+#endif
+ }
+ void SetCONVERT_TO_SRGB( bool i )
+ {
+ m_nCONVERT_TO_SRGB = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bCONVERT_TO_SRGB = true;
+#endif
+ }
+private:
+ int m_nFLASHLIGHT;
+#ifdef _DEBUG
+ bool m_bFLASHLIGHT;
+#endif
+public:
+ void SetFLASHLIGHT( int i )
+ {
+ Assert( i >= 0 && i <= 1 );
+ m_nFLASHLIGHT = i;
+#ifdef _DEBUG
+ m_bFLASHLIGHT = true;
+#endif
+ }
+ void SetFLASHLIGHT( bool i )
+ {
+ m_nFLASHLIGHT = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bFLASHLIGHT = true;
+#endif
+ }
+private:
+ int m_nFLASHLIGHTDEPTHFILTERMODE;
+#ifdef _DEBUG
+ bool m_bFLASHLIGHTDEPTHFILTERMODE;
+#endif
+public:
+ void SetFLASHLIGHTDEPTHFILTERMODE( int i )
+ {
+ Assert( i >= 0 && i <= 2 );
+ m_nFLASHLIGHTDEPTHFILTERMODE = i;
+#ifdef _DEBUG
+ m_bFLASHLIGHTDEPTHFILTERMODE = true;
+#endif
+ }
+ void SetFLASHLIGHTDEPTHFILTERMODE( bool i )
+ {
+ m_nFLASHLIGHTDEPTHFILTERMODE = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bFLASHLIGHTDEPTHFILTERMODE = true;
+#endif
+ }
+public:
+ example_model_ps20b_Static_Index( )
+ {
+#ifdef _DEBUG
+ m_bCONVERT_TO_SRGB = false;
+#endif // _DEBUG
+ m_nCONVERT_TO_SRGB = 0;
+#ifdef _DEBUG
+ m_bFLASHLIGHT = false;
+#endif // _DEBUG
+ m_nFLASHLIGHT = 0;
+#ifdef _DEBUG
+ m_bFLASHLIGHTDEPTHFILTERMODE = false;
+#endif // _DEBUG
+ m_nFLASHLIGHTDEPTHFILTERMODE = 0;
+ }
+ int GetIndex()
+ {
+ // Asserts to make sure that we aren't using any skipped combinations.
+ // Asserts to make sure that we are setting all of the combination vars.
+#ifdef _DEBUG
+ bool bAllStaticVarsDefined = m_bCONVERT_TO_SRGB && m_bFLASHLIGHT && m_bFLASHLIGHTDEPTHFILTERMODE;
+ Assert( bAllStaticVarsDefined );
+#endif // _DEBUG
+ return ( 80 * m_nCONVERT_TO_SRGB ) + ( 80 * m_nFLASHLIGHT ) + ( 160 * m_nFLASHLIGHTDEPTHFILTERMODE ) + 0;
+ }
+};
+#define shaderStaticTest_example_model_ps20b psh_forgot_to_set_static_CONVERT_TO_SRGB + psh_forgot_to_set_static_FLASHLIGHT + psh_forgot_to_set_static_FLASHLIGHTDEPTHFILTERMODE + 0
+class example_model_ps20b_Dynamic_Index
+{
+private:
+ int m_nWRITEWATERFOGTODESTALPHA;
+#ifdef _DEBUG
+ bool m_bWRITEWATERFOGTODESTALPHA;
+#endif
+public:
+ void SetWRITEWATERFOGTODESTALPHA( int i )
+ {
+ Assert( i >= 0 && i <= 1 );
+ m_nWRITEWATERFOGTODESTALPHA = i;
+#ifdef _DEBUG
+ m_bWRITEWATERFOGTODESTALPHA = true;
+#endif
+ }
+ void SetWRITEWATERFOGTODESTALPHA( bool i )
+ {
+ m_nWRITEWATERFOGTODESTALPHA = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bWRITEWATERFOGTODESTALPHA = true;
+#endif
+ }
+private:
+ int m_nPIXELFOGTYPE;
+#ifdef _DEBUG
+ bool m_bPIXELFOGTYPE;
+#endif
+public:
+ void SetPIXELFOGTYPE( int i )
+ {
+ Assert( i >= 0 && i <= 1 );
+ m_nPIXELFOGTYPE = i;
+#ifdef _DEBUG
+ m_bPIXELFOGTYPE = true;
+#endif
+ }
+ void SetPIXELFOGTYPE( bool i )
+ {
+ m_nPIXELFOGTYPE = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bPIXELFOGTYPE = true;
+#endif
+ }
+private:
+ int m_nNUM_LIGHTS;
+#ifdef _DEBUG
+ bool m_bNUM_LIGHTS;
+#endif
+public:
+ void SetNUM_LIGHTS( int i )
+ {
+ Assert( i >= 0 && i <= 4 );
+ m_nNUM_LIGHTS = i;
+#ifdef _DEBUG
+ m_bNUM_LIGHTS = true;
+#endif
+ }
+ void SetNUM_LIGHTS( bool i )
+ {
+ m_nNUM_LIGHTS = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bNUM_LIGHTS = true;
+#endif
+ }
+private:
+ int m_nWRITE_DEPTH_TO_DESTALPHA;
+#ifdef _DEBUG
+ bool m_bWRITE_DEPTH_TO_DESTALPHA;
+#endif
+public:
+ void SetWRITE_DEPTH_TO_DESTALPHA( int i )
+ {
+ Assert( i >= 0 && i <= 1 );
+ m_nWRITE_DEPTH_TO_DESTALPHA = i;
+#ifdef _DEBUG
+ m_bWRITE_DEPTH_TO_DESTALPHA = true;
+#endif
+ }
+ void SetWRITE_DEPTH_TO_DESTALPHA( bool i )
+ {
+ m_nWRITE_DEPTH_TO_DESTALPHA = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bWRITE_DEPTH_TO_DESTALPHA = true;
+#endif
+ }
+private:
+ int m_nFLASHLIGHTSHADOWS;
+#ifdef _DEBUG
+ bool m_bFLASHLIGHTSHADOWS;
+#endif
+public:
+ void SetFLASHLIGHTSHADOWS( int i )
+ {
+ Assert( i >= 0 && i <= 1 );
+ m_nFLASHLIGHTSHADOWS = i;
+#ifdef _DEBUG
+ m_bFLASHLIGHTSHADOWS = true;
+#endif
+ }
+ void SetFLASHLIGHTSHADOWS( bool i )
+ {
+ m_nFLASHLIGHTSHADOWS = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bFLASHLIGHTSHADOWS = true;
+#endif
+ }
+public:
+ example_model_ps20b_Dynamic_Index()
+ {
+#ifdef _DEBUG
+ m_bWRITEWATERFOGTODESTALPHA = false;
+#endif // _DEBUG
+ m_nWRITEWATERFOGTODESTALPHA = 0;
+#ifdef _DEBUG
+ m_bPIXELFOGTYPE = false;
+#endif // _DEBUG
+ m_nPIXELFOGTYPE = 0;
+#ifdef _DEBUG
+ m_bNUM_LIGHTS = false;
+#endif // _DEBUG
+ m_nNUM_LIGHTS = 0;
+#ifdef _DEBUG
+ m_bWRITE_DEPTH_TO_DESTALPHA = false;
+#endif // _DEBUG
+ m_nWRITE_DEPTH_TO_DESTALPHA = 0;
+#ifdef _DEBUG
+ m_bFLASHLIGHTSHADOWS = false;
+#endif // _DEBUG
+ m_nFLASHLIGHTSHADOWS = 0;
+ }
+ int GetIndex()
+ {
+ // Asserts to make sure that we aren't using any skipped combinations.
+ // Asserts to make sure that we are setting all of the combination vars.
+#ifdef _DEBUG
+ bool bAllDynamicVarsDefined = m_bWRITEWATERFOGTODESTALPHA && m_bPIXELFOGTYPE && m_bNUM_LIGHTS && m_bWRITE_DEPTH_TO_DESTALPHA && m_bFLASHLIGHTSHADOWS;
+ Assert( bAllDynamicVarsDefined );
+#endif // _DEBUG
+ return ( 1 * m_nWRITEWATERFOGTODESTALPHA ) + ( 2 * m_nPIXELFOGTYPE ) + ( 4 * m_nNUM_LIGHTS ) + ( 20 * m_nWRITE_DEPTH_TO_DESTALPHA ) + ( 40 * m_nFLASHLIGHTSHADOWS ) + 0;
+ }
+};
+#define shaderDynamicTest_example_model_ps20b psh_forgot_to_set_dynamic_WRITEWATERFOGTODESTALPHA + psh_forgot_to_set_dynamic_PIXELFOGTYPE + psh_forgot_to_set_dynamic_NUM_LIGHTS + psh_forgot_to_set_dynamic_WRITE_DEPTH_TO_DESTALPHA + psh_forgot_to_set_dynamic_FLASHLIGHTSHADOWS + 0
diff --git a/mp/src/materialsystem/stdshaders/fxctmp9/example_model_vs20.inc b/mp/src/materialsystem/stdshaders/fxctmp9/example_model_vs20.inc new file mode 100644 index 00000000..a8dbd23f --- /dev/null +++ b/mp/src/materialsystem/stdshaders/fxctmp9/example_model_vs20.inc @@ -0,0 +1,160 @@ +#include "shaderlib/cshader.h"
+class example_model_vs20_Static_Index
+{
+public:
+ example_model_vs20_Static_Index( )
+ {
+ }
+ int GetIndex()
+ {
+ // Asserts to make sure that we aren't using any skipped combinations.
+ // Asserts to make sure that we are setting all of the combination vars.
+#ifdef _DEBUG
+#endif // _DEBUG
+ return 0;
+ }
+};
+#define shaderStaticTest_example_model_vs20 0
+class example_model_vs20_Dynamic_Index
+{
+private:
+ int m_nCOMPRESSED_VERTS;
+#ifdef _DEBUG
+ bool m_bCOMPRESSED_VERTS;
+#endif
+public:
+ void SetCOMPRESSED_VERTS( int i )
+ {
+ Assert( i >= 0 && i <= 1 );
+ m_nCOMPRESSED_VERTS = i;
+#ifdef _DEBUG
+ m_bCOMPRESSED_VERTS = true;
+#endif
+ }
+ void SetCOMPRESSED_VERTS( bool i )
+ {
+ m_nCOMPRESSED_VERTS = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bCOMPRESSED_VERTS = true;
+#endif
+ }
+private:
+ int m_nDOWATERFOG;
+#ifdef _DEBUG
+ bool m_bDOWATERFOG;
+#endif
+public:
+ void SetDOWATERFOG( int i )
+ {
+ Assert( i >= 0 && i <= 1 );
+ m_nDOWATERFOG = i;
+#ifdef _DEBUG
+ m_bDOWATERFOG = true;
+#endif
+ }
+ void SetDOWATERFOG( bool i )
+ {
+ m_nDOWATERFOG = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bDOWATERFOG = true;
+#endif
+ }
+private:
+ int m_nSKINNING;
+#ifdef _DEBUG
+ bool m_bSKINNING;
+#endif
+public:
+ void SetSKINNING( int i )
+ {
+ Assert( i >= 0 && i <= 1 );
+ m_nSKINNING = i;
+#ifdef _DEBUG
+ m_bSKINNING = true;
+#endif
+ }
+ void SetSKINNING( bool i )
+ {
+ m_nSKINNING = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bSKINNING = true;
+#endif
+ }
+private:
+ int m_nLIGHTING_PREVIEW;
+#ifdef _DEBUG
+ bool m_bLIGHTING_PREVIEW;
+#endif
+public:
+ void SetLIGHTING_PREVIEW( int i )
+ {
+ Assert( i >= 0 && i <= 1 );
+ m_nLIGHTING_PREVIEW = i;
+#ifdef _DEBUG
+ m_bLIGHTING_PREVIEW = true;
+#endif
+ }
+ void SetLIGHTING_PREVIEW( bool i )
+ {
+ m_nLIGHTING_PREVIEW = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bLIGHTING_PREVIEW = true;
+#endif
+ }
+private:
+ int m_nNUM_LIGHTS;
+#ifdef _DEBUG
+ bool m_bNUM_LIGHTS;
+#endif
+public:
+ void SetNUM_LIGHTS( int i )
+ {
+ Assert( i >= 0 && i <= 4 );
+ m_nNUM_LIGHTS = i;
+#ifdef _DEBUG
+ m_bNUM_LIGHTS = true;
+#endif
+ }
+ void SetNUM_LIGHTS( bool i )
+ {
+ m_nNUM_LIGHTS = i ? 1 : 0;
+#ifdef _DEBUG
+ m_bNUM_LIGHTS = true;
+#endif
+ }
+public:
+ example_model_vs20_Dynamic_Index()
+ {
+#ifdef _DEBUG
+ m_bCOMPRESSED_VERTS = false;
+#endif // _DEBUG
+ m_nCOMPRESSED_VERTS = 0;
+#ifdef _DEBUG
+ m_bDOWATERFOG = false;
+#endif // _DEBUG
+ m_nDOWATERFOG = 0;
+#ifdef _DEBUG
+ m_bSKINNING = false;
+#endif // _DEBUG
+ m_nSKINNING = 0;
+#ifdef _DEBUG
+ m_bLIGHTING_PREVIEW = false;
+#endif // _DEBUG
+ m_nLIGHTING_PREVIEW = 0;
+#ifdef _DEBUG
+ m_bNUM_LIGHTS = false;
+#endif // _DEBUG
+ m_nNUM_LIGHTS = 0;
+ }
+ int GetIndex()
+ {
+ // Asserts to make sure that we aren't using any skipped combinations.
+ // Asserts to make sure that we are setting all of the combination vars.
+#ifdef _DEBUG
+ bool bAllDynamicVarsDefined = m_bCOMPRESSED_VERTS && m_bDOWATERFOG && m_bSKINNING && m_bLIGHTING_PREVIEW && m_bNUM_LIGHTS;
+ Assert( bAllDynamicVarsDefined );
+#endif // _DEBUG
+ return ( 1 * m_nCOMPRESSED_VERTS ) + ( 2 * m_nDOWATERFOG ) + ( 4 * m_nSKINNING ) + ( 8 * m_nLIGHTING_PREVIEW ) + ( 16 * m_nNUM_LIGHTS ) + 0;
+ }
+};
+#define shaderDynamicTest_example_model_vs20 vsh_forgot_to_set_dynamic_COMPRESSED_VERTS + vsh_forgot_to_set_dynamic_DOWATERFOG + vsh_forgot_to_set_dynamic_SKINNING + vsh_forgot_to_set_dynamic_LIGHTING_PREVIEW + vsh_forgot_to_set_dynamic_NUM_LIGHTS + 0
diff --git a/mp/src/materialsystem/stdshaders/game_shader_dx9_base.vpc b/mp/src/materialsystem/stdshaders/game_shader_dx9_base.vpc new file mode 100644 index 00000000..2fb7fc9e --- /dev/null +++ b/mp/src/materialsystem/stdshaders/game_shader_dx9_base.vpc @@ -0,0 +1,101 @@ +//-----------------------------------------------------------------------------
+// game_shader_dx9.vpc
+//
+// Project Script for mods to use an an example of how to override shaders
+//-----------------------------------------------------------------------------
+
+$Macro OUTBINDIR "$SRCDIR\..\game\$GAMENAME\bin"
+
+$Include "$SRCDIR\vpc_scripts\source_dll_base.vpc"
+
+$Configuration "Debug"
+{
+ $General
+ {
+ $OutputDirectory "Debug_dx9_$GAMENAME" [$WIN32]
+ $IntermediateDirectory "Debug_dx9_$GAMENAME" [$WIN32]
+ }
+}
+
+$Configuration "Release"
+{
+ $General
+ {
+ $OutputDirectory "Release_dx9_$GAMENAME" [$WIN32]
+ $IntermediateDirectory "Release_dx9_$GAMENAME" [$WIN32]
+ }
+}
+
+// Common Configuration
+$Configuration
+{
+ $Compiler
+ {
+ $AdditionalIncludeDirectories "$BASE;fxctmp9;vshtmp9;" [$WIN32||$POSIX]
+// $AdditionalIncludeDirectories "$BASE;..\..\dx9sdk\include" [$WIN32]
+ $AdditionalIncludeDirectories "$BASE;fxctmp9_360;vshtmp9_360" [$X360]
+ $PreprocessorDefinitions "$BASE;STDSHADER_DX9_DLL_EXPORT;FAST_MATERIALVAR_ACCESS;GAME_SHADER_DLL"
+ $PreprocessorDefinitions "$BASE;USE_ACTUAL_DX" [($WIN32||$X360) && !$GL]
+ }
+
+ $Linker
+ {
+ $AdditionalDependencies "$BASE version.lib winmm.lib" [$WIN32]
+ $SystemLibraries "iconv" [$OSXALL]
+ }
+}
+
+$Project
+{
+ $Folder "Source Files"
+ {
+ $File "BaseVSShader.cpp"
+
+ $File "example_model_dx9.cpp"
+ $File "example_model_dx9_helper.cpp"
+ }
+
+ $Folder "Header Files"
+ {
+ $File "BaseVSShader.h"
+ $File "common_fxc.h"
+ $File "common_hlsl_cpp_consts.h"
+ $File "common_ps_fxc.h"
+ $File "common_vertexlitgeneric_dx9.h"
+ $File "common_vs_fxc.h"
+ $File "shader_constant_register_map.h"
+
+ $File "example_model_dx9_helper.h"
+ }
+
+ $Folder "Link Libraries" [$WIN32]
+ {
+// $File "$SRCDIR\dx9sdk\lib\d3dx9.lib"
+ $DynamicFile "$SRCDIR\lib\public\mathlib.lib"
+ $DynamicFile "$SRCDIR\lib\public\shaderlib.lib"
+ }
+
+ $Folder "Link Libraries" [$X360]
+ {
+ $DynamicFile "$SRCDIR\lib\public\mathlib_360.lib"
+ $DynamicFile "$SRCDIR\lib\public\shaderlib_360.lib"
+ }
+
+ $Folder "Link Libraries" [$POSIX&&!$LINUX]
+ {
+ $DynamicFile "$SRCDIR\lib\$PLATFORM\mathlib$_STATICLIB_EXT"
+ $DynamicFile "$SRCDIR\lib\$PLATFORM\shaderlib$_STATICLIB_EXT"
+ }
+
+ $Folder "Link Libraries" [$LINUX]
+ {
+ $Lib mathlib
+ $Lib shaderlib
+ }
+
+ $File "buildsdkshaders.bat"
+ $File "buildshaders.bat"
+
+ $Shaders "stdshader_dx9_20b.txt"
+ $Shaders "stdshader_dx9_30.txt"
+}
diff --git a/mp/src/materialsystem/stdshaders/game_shader_dx9_hl2mp.vpc b/mp/src/materialsystem/stdshaders/game_shader_dx9_hl2mp.vpc new file mode 100644 index 00000000..7f5339b7 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/game_shader_dx9_hl2mp.vpc @@ -0,0 +1,13 @@ +//-----------------------------------------------------------------------------
+// game_shader_dx9.vpc
+//
+// Project Script for mods to use an an example of how to override shaders
+//-----------------------------------------------------------------------------
+
+$Macro SRCDIR "..\.."
+$Macro GAMENAME "mod_hl2mp"
+$Include "$SRCDIR\materialsystem\stdshaders\game_shader_dx9_base.vpc"
+
+$Project "Shaders (HL2MP)"
+{
+}
\ No newline at end of file diff --git a/mp/src/materialsystem/stdshaders/genwaterloop.pl b/mp/src/materialsystem/stdshaders/genwaterloop.pl new file mode 100644 index 00000000..0a4701ce --- /dev/null +++ b/mp/src/materialsystem/stdshaders/genwaterloop.pl @@ -0,0 +1,9 @@ +for($ix=-2;$ix<=2;$ix++)
+{
+ for($iy=-2;$iy<=2;$iy++)
+ {
+ print "vRefractColor += tex2D( RefractSampler, vRefractTexCoord + $ix * ddx1 + $iy * ddy1 );\n";
+ $sumweights+=1;
+ }
+}
+print "float sumweights = $sumweights;\n";
diff --git a/mp/src/materialsystem/stdshaders/macros.vsh b/mp/src/materialsystem/stdshaders/macros.vsh new file mode 100644 index 00000000..9b19f777 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/macros.vsh @@ -0,0 +1,1393 @@ +;------------------------------------
+; RULES FOR AUTHORING VERTEX SHADERS:
+;------------------------------------
+; - never use "def" . . .set constants in code instead. . our constant shadowing will break otherwise.
+; (same goes for pixel shaders)
+; - use cN notation instead of c[N] notation. .makes grepping for registers easier.
+; The only exception is c[a0.x+blah] where you have no choice.
+$g_NumRegisters = 12;
+
+; NOTE: These must match the same values in vsh_prep.pl!
+$vPos = "v0";
+$vBoneWeights = "v1";
+$vBoneIndices = "v2";
+$vNormal = "v3";
+$vColor = "v5";
+$vSpecular = "v6";
+$vTexCoord0 = "v7";
+$vTexCoord1 = "v8";
+$vTexCoord2 = "v9";
+$vTexCoord3 = "v10";
+$vTangentS = "v11";
+$vTangentT = "v12";
+$vUserData = "v14";
+
+if( $g_dx9 )
+{
+ if( $g_usesPos )
+ {
+ dcl_position $vPos;
+ }
+
+ if( $g_usesBoneWeights )
+ {
+ dcl_blendweight $vBoneWeights;
+ }
+ if( $g_usesBoneIndices )
+ {
+ dcl_blendindices $vBoneIndices;
+ }
+ if( $g_usesNormal )
+ {
+ dcl_normal $vNormal;
+ }
+ if( $g_usesColor )
+ {
+ dcl_color0 $vColor;
+ }
+ if( $g_usesSpecular )
+ {
+ dcl_color1 $vSpecular;
+ }
+ if( $g_usesTexCoord0 )
+ {
+ dcl_texcoord0 $vTexCoord0;
+ }
+ if( $g_usesTexCoord1 )
+ {
+ dcl_texcoord1 $vTexCoord1;
+ }
+ if( $g_usesTexCoord2 )
+ {
+ dcl_texcoord2 $vTexCoord2;
+ }
+ if( $g_usesTexCoord3 )
+ {
+ dcl_texcoord3 $vTexCoord3;
+ }
+ if( $g_usesTangentS )
+ {
+ dcl_tangent $vTangentS;
+ }
+ if( $g_usesTangentT )
+ {
+ dcl_binormal0 $vTangentT;
+ }
+ if( $g_usesUserData )
+ {
+ dcl_tangent $vUserData;
+ }
+}
+
+# NOTE: These should match g_LightCombinations in vertexshaderdx8.cpp!
+# NOTE: Leave this on single lines or shit might blow up.
+@g_staticLightTypeArray = ( "none", "static", "none", "none", "none", "none", "none", "none", "none", "none", "none", "none", "static", "static", "static", "static", "static", "static", "static", "static", "static", "static" );
+@g_ambientLightTypeArray = ( "none", "none", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient", "ambient" );
+@g_localLightType1Array = ( "none", "none", "none", "spot", "point", "directional", "spot", "spot", "spot", "point", "point", "directional", "none", "spot", "point", "directional", "spot", "spot", "spot", "point", "point", "directional" );
+@g_localLightType2Array = ( "none", "none", "none", "none", "none", "none", "spot", "point", "directional", "point", "directional", "directional", "none", "none", "none", "none", "spot", "point", "directional", "point", "directional", "directional" );
+
+$cConstants0 = "c0";
+$cZero = "c0.x";
+$cOne = "c0.y";
+$cTwo = "c0.z";
+$cHalf = "c0.w";
+
+$cConstants1 = "c1";
+$cOOGamma = "c1.x"; # 1/2.2
+$cOtherOverbrightFactor = "c1.y"; # overbright
+$cOneThird = "c1.z"; # 1/3
+$cOverbrightFactor = "c1.w"; # 1/overbright
+
+$cEyePos = "c2";
+$cWaterZ = "c2.w";
+$cEyePosWaterZ = "c2";
+
+$cLightIndex = "c3";
+$cLight0Offset = "c3.x"; # 27
+$cLight1Offset = "c3.y"; # 32
+$cColorToIntScale = "c3.z"; # matrix array offset = 3.0f * 255.0f + 0.01 (epsilon ensures floor yields desired result)
+$cModel0Index = "c3.w"; # base for start of skinning matrices
+
+; NOTE: These must match the same values in vsh_prep.pl!
+$cModelViewProj0 = "c4";
+$cModelViewProj1 = "c5";
+$cModelViewProj2 = "c6";
+$cModelViewProj3 = "c7";
+
+$cViewProj0 = "c8";
+$cViewProj1 = "c9";
+$cViewProj2 = "c10";
+$cViewProj3 = "c11";
+
+; currently unused
+; c12, c13
+
+$SHADER_SPECIFIC_CONST_10 = "c14";
+$SHADER_SPECIFIC_CONST_11 = "c15";
+
+$cFogParams = "c16";
+$cFogEndOverFogRange = "c16.x";
+$cFogOne = "c16.y";
+$cFogMaxDensity = "c16.z";
+$cOOFogRange = "c16.w"; # (1/(fogEnd-fogStart))
+
+$cViewModel0 = "c17";
+$cViewModel1 = "c18";
+$cViewModel2 = "c19";
+$cViewModel3 = "c20";
+
+$cAmbientColorPosX = "c21";
+$cAmbientColorNegX = "c22";
+$cAmbientColorPosY = "c23";
+$cAmbientColorNegY = "c24";
+$cAmbientColorPosZ = "c25";
+$cAmbientColorNegZ = "c26";
+
+$cAmbientColorPosXOffset = "21";
+$cAmbientColorPosYOffset = "23";
+$cAmbientColorPosZOffset = "25";
+
+$cLight0DiffColor = "c27";
+$cLight0Dir = "c28";
+$cLight0Pos = "c29";
+$cLight0SpotParams = "c30"; # [ exponent, stopdot, stopdot2, 1 / (stopdot - stopdot2)
+$cLight0Atten = "c31"; # [ constant, linear, quadratic, 0.0f ]
+
+$cLight1DiffColor = "c32";
+$cLight1Dir = "c33";
+$cLight1Pos = "c34";
+$cLight1SpotParams = "c35"; # [ exponent, stopdot, stopdot2, 1 / (stopdot - stopdot2)
+$cLight1Atten = "c36"; # [ constant, linear, quadratic, 0.0f ]
+
+$cModulationColor = "c37";
+
+$SHADER_SPECIFIC_CONST_0 = "c38";
+$SHADER_SPECIFIC_CONST_1 = "c39";
+$SHADER_SPECIFIC_CONST_2 = "c40";
+$SHADER_SPECIFIC_CONST_3 = "c41";
+$SHADER_SPECIFIC_CONST_4 = "c42";
+$SHADER_SPECIFIC_CONST_5 = "c43";
+$SHADER_SPECIFIC_CONST_6 = "c44";
+$SHADER_SPECIFIC_CONST_7 = "c45";
+$SHADER_SPECIFIC_CONST_8 = "c46";
+$SHADER_SPECIFIC_CONST_9 = "c47";
+; $SHADER_SPECIFIC_CONST_10 is c14
+; $SHADER_SPECIFIC_CONST_11 is c15
+
+; There are 16 model matrices for skinning
+; NOTE: These must match the same values in vsh_prep.pl!
+$cModel0 = "c48";
+$cModel1 = "c49";
+$cModel2 = "c50";
+
+sub OutputUsedRegisters
+{
+ local( $i );
+ ; USED REGISTERS
+ for( $i = 0; $i < $g_NumRegisters; $i++ )
+ {
+ if( $g_allocated[$i] )
+ {
+ ; $g_allocatedname[$i] = r$i
+ }
+ }
+ ;
+}
+
+sub AllocateRegister
+{
+ local( *reg ) = shift;
+ local( $regname ) = shift;
+ local( $i );
+ for( $i = 0; $i < $g_NumRegisters; $i++ )
+ {
+ if( !$g_allocated[$i] )
+ {
+ $g_allocated[$i] = 1;
+ $g_allocatedname[$i] = $regname;
+ ; AllocateRegister $regname = r$i
+ $reg = "r$i";
+ &OutputUsedRegisters();
+ return;
+ }
+ }
+ ; Out of registers allocating $regname!
+ $reg = "rERROR_OUT_OF_REGISTERS";
+ &OutputUsedRegisters();
+}
+
+; pass in a reference to a var that contains a register. . ie \$var where var will constain "r1", etc
+sub FreeRegister
+{
+ local( *reg ) = shift;
+ local( $regname ) = shift;
+ ; FreeRegister $regname = $reg
+ if( $reg =~ m/rERROR_DEALLOCATED/ )
+ {
+ ; $regname already deallocated
+ ; $reg = "rALREADY_DEALLOCATED";
+ &OutputUsedRegisters();
+ return;
+ }
+; if( $regname ne g_allocatedname[$reg] )
+; {
+; ; Error freeing $reg
+; mov compileerror, freed unallocated register $regname
+; }
+
+ if( ( $reg =~ m/r(.*)/ ) )
+ {
+ $g_allocated[$1] = 0;
+ }
+ $reg = "rERROR_DEALLOCATED";
+ &OutputUsedRegisters();
+}
+
+sub CheckUnfreedRegisters()
+{
+ local( $i );
+ for( $i = 0; $i < $g_NumRegisters; $i++ )
+ {
+ if( $g_allocated[$i] )
+ {
+ print "ERROR: r$i allocated to $g_allocatedname[$i] at end of program\n";
+ $g_allocated[$i] = 0;
+ }
+ }
+}
+
+sub Normalize
+{
+ local( $r ) = shift;
+ dp3 $r.w, $r, $r
+ rsq $r.w, $r.w
+ mul $r, $r, $r.w
+}
+
+sub Cross
+{
+ local( $result ) = shift;
+ local( $a ) = shift;
+ local( $b ) = shift;
+
+ mul $result.xyz, $a.yzx, $b.zxy
+ mad $result.xyz, -$b.yzx, $a.zxy, $result
+}
+
+sub RangeFog
+{
+ local( $projPos ) = shift;
+
+ ;------------------------------
+ ; Regular range fog
+ ;------------------------------
+
+ ; oFog.x = 1.0f = no fog
+ ; oFog.x = 0.0f = full fog
+ ; compute fog factor f = (fog_end - dist)*(1/(fog_end-fog_start))
+ ; this is == to: (fog_end/(fog_end-fog_start) - dist/(fog_end-fog_start)
+ ; which can be expressed with a single mad instruction!
+
+ ; Compute |projPos|
+ local( $tmp );
+ &AllocateRegister( \$tmp );
+ dp3 $tmp.x, $projPos.xyw, $projPos.xyw
+ rsq $tmp.x, $tmp.x
+ rcp $tmp.x, $tmp.x
+
+ if( $g_dx9 )
+ {
+ mad $tmp, -$tmp.x, $cOOFogRange, $cFogEndOverFogRange
+ min $tmp, $tmp, $cOne
+ max oFog, $tmp.x, $cFogMaxDensity
+ }
+ else
+ {
+ mad $tmp, -$tmp.x, $cOOFogRange, $cFogEndOverFogRange
+ min $tmp, $tmp, $cOne
+ max oFog.x, $tmp.x, $cFogMaxDensity
+ }
+ &FreeRegister( \$tmp );
+}
+
+sub DepthFog
+{
+ local( $projPos ) = shift;
+ local( $dest ) = shift;
+
+ if ( $dest eq "" )
+ {
+ $dest = "oFog";
+ }
+
+ ;------------------------------
+ ; Regular range fog
+ ;------------------------------
+
+ ; oFog.x = 1.0f = no fog
+ ; oFog.x = 0.0f = full fog
+ ; compute fog factor f = (fog_end - dist)*(1/(fog_end-fog_start))
+ ; this is == to: (fog_end/(fog_end-fog_start) - dist/(fog_end-fog_start)
+ ; which can be expressed with a single mad instruction!
+
+ ; Compute |projPos|
+ local( $tmp );
+ &AllocateRegister( \$tmp );
+
+ if( $g_dx9 )
+ {
+ mad $tmp, -$projPos.w, $cOOFogRange, $cFogEndOverFogRange
+ min $tmp, $tmp, $cOne
+ max $dest, $tmp.x, $cFogMaxDensity
+ }
+ else
+ {
+ mad $tmp, -$projPos.w, $cOOFogRange, $cFogEndOverFogRange
+ min $tmp, $tmp, $cOne
+ max $dest.x, $tmp.x, $cFogMaxDensity
+ }
+
+ &FreeRegister( \$tmp );
+}
+
+sub WaterRangeFog
+{
+ ; oFog.x = 1.0f = no fog
+ ; oFog.x = 0.0f = full fog
+
+ ; only $worldPos.z is used out of worldPos
+ local( $worldPos ) = shift;
+ local( $projPos ) = shift;
+
+ local( $tmp );
+ &AllocateRegister( \$tmp );
+
+ ; This is simple similar triangles. Imagine a line passing from the point directly vertically
+ ; and another line passing from the point to the eye position.
+ ; Let d = total distance from point to the eye
+ ; Let h = vertical distance from the point to the eye
+ ; Let hw = vertical distance from the point to the water surface
+ ; Let dw = distance from the point to a point on the water surface that lies along the ray from point to eye
+ ; Therefore d/h = dw/hw by similar triangles, or dw = d * hw / h.
+ ; d = |projPos|, h = eyepos.z - worldPos.z, hw = waterheight.z - worldPos.z, dw = what we solve for
+
+ ; Now, tmp.x = hw, and tmp.y = h
+ add $tmp.xy, $cEyePosWaterZ.wz, -$worldPos.z
+
+ ; if $tmp.x < 0, then set it to 0
+ ; This is the equivalent of moving the vert to the water surface if it's above the water surface
+ max $tmp.x, $tmp.x, $cZero
+
+ ; Compute 1 / |projPos| = 1/d
+ dp3 $tmp.z, $projPos.xyw, $projPos.xyw
+ rsq $tmp.z, $tmp.z
+
+ ; Now we have h/d
+ mul $tmp.z, $tmp.z, $tmp.y
+
+ ; Now we have d/h
+ rcp $tmp.w, $tmp.z
+
+ ; We finally have d * hw / h
+ ; $tmp.w is now the distance that we see through water.
+ mul $tmp.w, $tmp.x, $tmp.w
+
+ if( $g_dx9 )
+ {
+ mad $tmp, -$tmp.w, $cOOFogRange, $cFogOne
+ min $tmp, $tmp, $cOne
+ max oFog, $tmp.x, $cFogMaxDensity
+ }
+ else
+ {
+ mad $tmp, -$tmp.w, $cOOFogRange, $cFogOne
+ min $tmp, $tmp, $cOne
+ max oFog.x, $tmp.x, $cFogMaxDensity
+ }
+
+ &FreeRegister( \$tmp );
+}
+
+sub WaterDepthFog
+{
+ ; oFog.x = 1.0f = no fog
+ ; oFog.x = 0.0f = full fog
+
+ ; only $worldPos.z is used out of worldPos
+ local( $worldPos ) = shift;
+ local( $projPos ) = shift;
+ local( $dest ) = shift;
+
+ if ( $dest eq "" )
+ {
+ $dest = "oFog";
+ }
+
+ local( $tmp );
+ &AllocateRegister( \$tmp );
+
+ ; This is simple similar triangles. Imagine a line passing from the point directly vertically
+ ; and another line passing from the point to the eye position.
+ ; Let d = total distance from point to the eye
+ ; Let h = vertical distance from the point to the eye
+ ; Let hw = vertical distance from the point to the water surface
+ ; Let dw = distance from the point to a point on the water surface that lies along the ray from point to eye
+ ; Therefore d/h = dw/hw by similar triangles, or dw = d * hw / h.
+ ; d = projPos.w, h = eyepos.z - worldPos.z, hw = waterheight.z - worldPos.z, dw = what we solve for
+
+ ; Now, tmp.x = hw, and tmp.y = h
+ add $tmp.xy, $cEyePosWaterZ.wz, -$worldPos.z
+
+ ; if $tmp.x < 0, then set it to 0
+ ; This is the equivalent of moving the vert to the water surface if it's above the water surface
+ max $tmp.x, $tmp.x, $cZero
+
+ ; Now we have 1/h
+ rcp $tmp.z, $tmp.y
+
+ ; Now we have d/h
+ mul $tmp.w, $projPos.w, $tmp.z
+
+ ; We finally have d * hw / h
+ ; $tmp.w is now the distance that we see through water.
+ mul $tmp.w, $tmp.x, $tmp.w
+
+ if( $g_dx9 )
+ {
+ mad $tmp, -$tmp.w, $cOOFogRange, $cFogOne
+ min $tmp, $tmp, $cOne
+ max $dest, $tmp.x, $cZero
+ }
+ else
+ {
+ mad $tmp, -$tmp.w, $cOOFogRange, $cFogOne
+ min $tmp, $tmp, $cOne
+ max $dest.x, $tmp.x, $cZero
+ }
+
+ &FreeRegister( \$tmp );
+}
+
+
+;------------------------------------------------------------------------------
+; Main fogging routine
+;------------------------------------------------------------------------------
+sub CalcFog
+{
+ if( !defined $DOWATERFOG )
+ {
+ die "CalcFog called without using \$DOWATERFOG\n";
+ }
+ my $fogType;
+ if( $DOWATERFOG == 0 )
+ {
+ $fogType = "rangefog";
+ }
+ else
+ {
+ $fogType = "heightfog";
+ }
+
+# print "\$fogType = $fogType\n";
+
+ ; CalcFog
+ local( $worldPos ) = shift;
+ local( $projPos ) = shift;
+ local( $dest ) = shift;
+
+ if ( $dest eq "" )
+ {
+ $dest = "oFog";
+ }
+
+ if( $fogType eq "rangefog" )
+ {
+ &DepthFog( $projPos, $dest );
+ }
+ elsif( $fogType eq "heightfog" )
+ {
+ &WaterDepthFog( $worldPos, $projPos, $dest );
+ }
+ else
+ {
+ die;
+ }
+}
+
+sub CalcRangeFog
+{
+ ; CalcFog
+ local( $worldPos ) = shift;
+ local( $projPos ) = shift;
+
+ if( $DOWATERFOG == 0 )
+ {
+ &RangeFog( $projPos );
+ }
+ elsif( $DOWATERFOG == 1 )
+ {
+ &WaterRangeFog( $worldPos, $projPos );
+ }
+ else
+ {
+ die;
+ }
+}
+
+sub GammaToLinear
+{
+ local( $gamma ) = shift;
+ local( $linear ) = shift;
+
+ local( $tmp );
+ &AllocateRegister( \$tmp );
+
+ ; Is rcp more expensive than just storing 2.2 somewhere and doing a mov?
+ rcp $gamma.w, $cOOGamma ; $gamma.w = 2.2
+ lit $linear.z, $gamma.zzzw ; r0.z = linear blue
+ lit $tmp.z, $gamma.yyyw ; r2.z = linear green
+ mov $linear.y, $tmp.z ; r0.y = linear green
+ lit $tmp.z, $gamma.xxxw ; r2.z = linear red
+ mov $linear.x, $tmp.z ; r0.x = linear red
+
+ &FreeRegister( \$tmp );
+}
+
+sub LinearToGamma
+{
+ local( $linear ) = shift;
+ local( $gamma ) = shift;
+
+ local( $tmp );
+ &AllocateRegister( \$tmp );
+
+ mov $linear.w, $cOOGamma ; $linear.w = 1.0/2.2
+ lit $gamma.z, $linear.zzzw ; r0.z = gamma blue
+ lit $tmp.z, $linear.yyyw ; r2.z = gamma green
+ mov $gamma.y, $tmp.z ; r0.y = gamma green
+ lit $tmp.z, $linear.xxxw ; r2.z = gamma red
+ mov $gamma.x, $tmp.z ; r0.x = gamma red
+
+ &FreeRegister( \$tmp );
+}
+
+sub ComputeReflectionVector
+{
+ local( $worldPos ) = shift;
+ local( $worldNormal ) = shift;
+ local( $reflectionVector ) = shift;
+
+ local( $vertToEye ); &AllocateRegister( \$vertToEye );
+ local( $tmp ); &AllocateRegister( \$tmp );
+
+ ; compute reflection vector r = 2 * (n dot v) n - v
+ sub $vertToEye.xyz, $cEyePos.xyz, $worldPos ; $tmp1 = v = c - p
+ dp3 $tmp, $worldNormal, $vertToEye ; $tmp = n dot v
+ mul $tmp.xyz, $tmp.xyz, $worldNormal ; $tmp = (n dot v ) n
+ mad $reflectionVector.xyz, $tmp, $cTwo, -$vertToEye
+
+ &FreeRegister( \$vertToEye );
+ &FreeRegister( \$tmp );
+}
+
+sub ComputeSphereMapTexCoords
+{
+ local( $reflectionVector ) = shift;
+ local( $sphereMapTexCoords ) = shift;
+
+ local( $tmp ); &AllocateRegister( \$tmp );
+
+ ; transform reflection vector into view space
+ dp3 $tmp.x, $reflectionVector, $cViewModel0
+ dp3 $tmp.y, $reflectionVector, $cViewModel1
+ dp3 $tmp.z, $reflectionVector, $cViewModel2
+
+ ; generate <rx ry rz+1>
+ add $tmp.z, $tmp.z, $cOne
+
+ ; find 1 / the length of r2
+ dp3 $tmp.w, $tmp, $tmp
+ rsq $tmp.w, $tmp.w
+
+ ; r1 = r2/|r2| + 1
+ mad $tmp.xy, $tmp.w, $tmp, $cOne
+ mul $sphereMapTexCoords.xy, $tmp.xy, $cHalf
+
+ &FreeRegister( \$tmp );
+}
+
+sub SkinPosition
+{
+# print "\$SKINNING = $SKINNING\n";
+ local( $worldPos ) = shift;
+
+ if( !defined $SKINNING )
+ {
+ die "using \$SKINNING without defining.\n";
+ }
+
+ if( $SKINNING == 0 )
+ {
+ ;
+ ; 0 bone skinning (4 instructions)
+ ;
+ ; Transform position into world space
+ ; position
+ dp4 $worldPos.x, $vPos, $cModel0
+ dp4 $worldPos.y, $vPos, $cModel1
+ dp4 $worldPos.z, $vPos, $cModel2
+ mov $worldPos.w, $cOne
+ }
+ else
+ {
+ ;
+ ; 3 bone skinning (19 instructions)
+ ;
+ local( $boneIndices );
+ local( $blendedMatrix0 );
+ local( $blendedMatrix1 );
+ local( $blendedMatrix2 );
+ local( $localPos );
+ &AllocateRegister( \$boneIndices );
+ &AllocateRegister( \$blendedMatrix0 );
+ &AllocateRegister( \$blendedMatrix1 );
+ &AllocateRegister( \$blendedMatrix2 );
+
+ ; Transform position into world space using all bones
+ ; denormalize d3dcolor to matrix index
+ mad $boneIndices, $vBoneIndices, $cColorToIntScale, $cModel0Index
+ if ( $g_x360 )
+ {
+ mov $boneIndices, $boneIndices.zyxw
+ }
+
+ ; r11 = boneindices at this point
+ ; first matrix
+ mov a0.x, $boneIndices.z
+ mul $blendedMatrix0, $vBoneWeights.x, c[a0.x]
+ mul $blendedMatrix1, $vBoneWeights.x, c[a0.x+1]
+ mul $blendedMatrix2, $vBoneWeights.x, c[a0.x+2]
+ ; second matrix
+ mov a0.x, $boneIndices.y
+ mad $blendedMatrix0, $vBoneWeights.y, c[a0.x], $blendedMatrix0
+ mad $blendedMatrix1, $vBoneWeights.y, c[a0.x+1], $blendedMatrix1
+ mad $blendedMatrix2, $vBoneWeights.y, c[a0.x+2], $blendedMatrix2
+
+ ; Calculate third weight
+ ; compute 1-(weight1+weight2) to calculate weight2
+ ; Use $boneIndices.w as a temp since we aren't using it for anything.
+ add $boneIndices.w, $vBoneWeights.x, $vBoneWeights.y
+ sub $boneIndices.w, $cOne, $boneIndices.w
+
+ ; third matrix
+ mov a0.x, $boneIndices.x
+ mad $blendedMatrix0, $boneIndices.w, c[a0.x], $blendedMatrix0
+ mad $blendedMatrix1, $boneIndices.w, c[a0.x+1], $blendedMatrix1
+ mad $blendedMatrix2, $boneIndices.w, c[a0.x+2], $blendedMatrix2
+
+ dp4 $worldPos.x, $vPos, $blendedMatrix0
+ dp4 $worldPos.y, $vPos, $blendedMatrix1
+ dp4 $worldPos.z, $vPos, $blendedMatrix2
+ mov $worldPos.w, $cOne
+
+ &FreeRegister( \$boneIndices );
+ &FreeRegister( \$blendedMatrix0 );
+ &FreeRegister( \$blendedMatrix1 );
+ &FreeRegister( \$blendedMatrix2 );
+ }
+}
+
+
+sub SkinPositionAndNormal
+{
+# print "\$SKINNING = $SKINNING\n";
+ local( $worldPos ) = shift;
+ local( $worldNormal ) = shift;
+
+ if( !defined $SKINNING )
+ {
+ die "using \$SKINNING without defining.\n";
+ }
+
+ if( $SKINNING == 0 )
+ {
+ ;
+ ; 0 bone skinning (13 instructions)
+ ;
+ ; Transform position + normal + tangentS + tangentT into world space
+ ; position
+ dp4 $worldPos.x, $vPos, $cModel0
+ dp4 $worldPos.y, $vPos, $cModel1
+ dp4 $worldPos.z, $vPos, $cModel2
+ mov $worldPos.w, $cOne
+ ; normal
+ dp3 $worldNormal.x, $vNormal, $cModel0
+ dp3 $worldNormal.y, $vNormal, $cModel1
+ dp3 $worldNormal.z, $vNormal, $cModel2
+ }
+ else
+ {
+ local( $boneIndices );
+ local( $blendedMatrix0 );
+ local( $blendedMatrix1 );
+ local( $blendedMatrix2 );
+ local( $localPos );
+ local( $localNormal );
+ local( $normalLength );
+ local( $ooNormalLength );
+ &AllocateRegister( \$boneIndices );
+ &AllocateRegister( \$blendedMatrix0 );
+ &AllocateRegister( \$blendedMatrix1 );
+ &AllocateRegister( \$blendedMatrix2 );
+
+ ; Transform position into world space using all bones
+ ; denormalize d3dcolor to matrix index
+ mad $boneIndices, $vBoneIndices, $cColorToIntScale, $cModel0Index
+ if ( $g_x360 )
+ {
+ mov $boneIndices, $boneIndices.zyxw
+ }
+
+ ; r11 = boneindices at this point
+ ; first matrix
+ mov a0.x, $boneIndices.z
+ mul $blendedMatrix0, $vBoneWeights.x, c[a0.x]
+ mul $blendedMatrix1, $vBoneWeights.x, c[a0.x+1]
+ mul $blendedMatrix2, $vBoneWeights.x, c[a0.x+2]
+ ; second matrix
+ mov a0.x, $boneIndices.y
+ mad $blendedMatrix0, $vBoneWeights.y, c[a0.x], $blendedMatrix0
+ mad $blendedMatrix1, $vBoneWeights.y, c[a0.x+1], $blendedMatrix1
+ mad $blendedMatrix2, $vBoneWeights.y, c[a0.x+2], $blendedMatrix2
+
+ ; Calculate third weight
+ ; compute 1-(weight1+weight2) to calculate weight2
+ ; Use $boneIndices.w as a temp since we aren't using it for anything.
+ add $boneIndices.w, $vBoneWeights.x, $vBoneWeights.y
+ sub $boneIndices.w, $cOne, $boneIndices.w
+
+ ; third matrix
+ mov a0.x, $boneIndices.x
+ mad $blendedMatrix0, $boneIndices.w, c[a0.x], $blendedMatrix0
+ mad $blendedMatrix1, $boneIndices.w, c[a0.x+1], $blendedMatrix1
+ mad $blendedMatrix2, $boneIndices.w, c[a0.x+2], $blendedMatrix2
+
+ dp4 $worldPos.x, $vPos, $blendedMatrix0
+ dp4 $worldPos.y, $vPos, $blendedMatrix1
+ dp4 $worldPos.z, $vPos, $blendedMatrix2
+ mov $worldPos.w, $cOne
+
+ ; normal
+ dp3 $worldNormal.x, $vNormal, $blendedMatrix0
+ dp3 $worldNormal.y, $vNormal, $blendedMatrix1
+ dp3 $worldNormal.z, $vNormal, $blendedMatrix2
+
+ &FreeRegister( \$boneIndices );
+ &FreeRegister( \$blendedMatrix0 );
+ &FreeRegister( \$blendedMatrix1 );
+ &FreeRegister( \$blendedMatrix2 );
+ }
+}
+
+sub SkinPositionNormalAndTangentSpace
+{
+# print "\$SKINNING = $SKINNING\n";
+ local( $worldPos ) = shift;
+ local( $worldNormal ) = shift;
+ local( $worldTangentS ) = shift;
+ local( $worldTangentT ) = shift;
+ local( $userData );
+ local( $localPos );
+ local( $localNormal );
+ local( $normalLength );
+ local( $ooNormalLength );
+
+ if( !defined $SKINNING )
+ {
+ die "using \$SKINNING without defining.\n";
+ }
+
+# X360TBD: needed for compressed vertex format
+# if ( $g_x360 )
+# {
+# &AllocateRegister( \$userData );
+# ; remap compressed range [0..1] to [-1..1]
+# mad $userData, $vUserData, $cTwo, -$cOne
+# }
+
+ if( $SKINNING == 0 )
+ {
+ ;
+ ; 0 bone skinning (13 instructions)
+ ;
+ ; Transform position + normal + tangentS + tangentT into world space
+ dp4 $worldPos.x, $vPos, $cModel0
+ dp4 $worldPos.y, $vPos, $cModel1
+ dp4 $worldPos.z, $vPos, $cModel2
+ mov $worldPos.w, $cOne
+
+ ; normal
+ dp3 $worldNormal.x, $vNormal, $cModel0
+ dp3 $worldNormal.y, $vNormal, $cModel1
+ dp3 $worldNormal.z, $vNormal, $cModel2
+
+# X360TBD: needed for compressed vertex format
+# if ( $g_x360 )
+# {
+# ; tangents
+# dp3 $worldTangentS.x, $userData, $cModel0
+# dp3 $worldTangentS.y, $userData, $cModel1
+# dp3 $worldTangentS.z, $userData, $cModel2
+#
+# ; calculate tangent t via cross( N, S ) * S[3]
+# &Cross( $worldTangentT, $worldNormal, $worldTangentS );
+# mul $worldTangentT.xyz, $userData.w, $worldTangentT.xyz
+# }
+# else
+ {
+ ; tangents
+ dp3 $worldTangentS.x, $vUserData, $cModel0
+ dp3 $worldTangentS.y, $vUserData, $cModel1
+ dp3 $worldTangentS.z, $vUserData, $cModel2
+
+ ; calculate tangent t via cross( N, S ) * S[3]
+ &Cross( $worldTangentT, $worldNormal, $worldTangentS );
+ mul $worldTangentT.xyz, $vUserData.w, $worldTangentT.xyz
+ }
+ }
+ else
+ {
+ local( $boneIndices );
+ local( $blendedMatrix0 );
+ local( $blendedMatrix1 );
+ local( $blendedMatrix2 );
+ &AllocateRegister( \$boneIndices );
+ &AllocateRegister( \$blendedMatrix0 );
+ &AllocateRegister( \$blendedMatrix1 );
+ &AllocateRegister( \$blendedMatrix2 );
+
+ ; Transform position into world space using all bones
+ ; denormalize d3dcolor to matrix index
+ mad $boneIndices, $vBoneIndices, $cColorToIntScale, $cModel0Index
+ if ( $g_x360 )
+ {
+ mov $boneIndices, $boneIndices.zyxw
+ }
+
+ ; r11 = boneindices at this point
+ ; first matrix
+ mov a0.x, $boneIndices.z
+ mul $blendedMatrix0, $vBoneWeights.x, c[a0.x]
+ mul $blendedMatrix1, $vBoneWeights.x, c[a0.x+1]
+ mul $blendedMatrix2, $vBoneWeights.x, c[a0.x+2]
+ ; second matrix
+ mov a0.x, $boneIndices.y
+ mad $blendedMatrix0, $vBoneWeights.y, c[a0.x], $blendedMatrix0
+ mad $blendedMatrix1, $vBoneWeights.y, c[a0.x+1], $blendedMatrix1
+ mad $blendedMatrix2, $vBoneWeights.y, c[a0.x+2], $blendedMatrix2
+
+ ; Calculate third weight
+ ; compute 1-(weight1+weight2) to calculate weight2
+ ; Use $boneIndices.w as a temp since we aren't using it for anything.
+ add $boneIndices.w, $vBoneWeights.x, $vBoneWeights.y
+ sub $boneIndices.w, $cOne, $boneIndices.w
+
+ ; third matrix
+ mov a0.x, $boneIndices.x
+ mad $blendedMatrix0, $boneIndices.w, c[a0.x], $blendedMatrix0
+ mad $blendedMatrix1, $boneIndices.w, c[a0.x+1], $blendedMatrix1
+ mad $blendedMatrix2, $boneIndices.w, c[a0.x+2], $blendedMatrix2
+
+ ; position
+ dp4 $worldPos.x, $vPos, $blendedMatrix0
+ dp4 $worldPos.y, $vPos, $blendedMatrix1
+ dp4 $worldPos.z, $vPos, $blendedMatrix2
+ mov $worldPos.w, $cOne
+
+ ; normal
+ dp3 $worldNormal.x, $vNormal, $blendedMatrix0
+ dp3 $worldNormal.y, $vNormal, $blendedMatrix1
+ dp3 $worldNormal.z, $vNormal, $blendedMatrix2
+
+# X360TBD: needed for compressed vertex format
+# if ( $g_x360 )
+# {
+# ; tangents
+# dp3 $worldTangentS.x, $userData, $blendedMatrix0
+# dp3 $worldTangentS.y, $userData, $blendedMatrix1
+# dp3 $worldTangentS.z, $userData, $blendedMatrix2
+#
+# ; calculate tangent t via cross( N, S ) * S[3]
+# &Cross( $worldTangentT, $worldNormal, $worldTangentS );
+# mul $worldTangentT.xyz, $userData.w, $worldTangentT.xyz
+# }
+# else
+ {
+ ; tangents
+ dp3 $worldTangentS.x, $vUserData, $blendedMatrix0
+ dp3 $worldTangentS.y, $vUserData, $blendedMatrix1
+ dp3 $worldTangentS.z, $vUserData, $blendedMatrix2
+
+ ; calculate tangent t via cross( N, S ) * S[3]
+ &Cross( $worldTangentT, $worldNormal, $worldTangentS );
+ mul $worldTangentT.xyz, $vUserData.w, $worldTangentT.xyz
+ }
+
+ &FreeRegister( \$boneIndices );
+ &FreeRegister( \$blendedMatrix0 );
+ &FreeRegister( \$blendedMatrix1 );
+ &FreeRegister( \$blendedMatrix2 );
+ }
+
+# X360TBD: needed for compressed vertex format
+# if ( $g_x360 )
+# {
+# &FreeRegister( \$userData );
+# }
+}
+
+sub ColorClamp
+{
+ ; ColorClamp; stomps $color.w
+ local( $color ) = shift;
+ local( $dst ) = shift;
+
+ ; Get the max of RGB and stick it in W
+ max $color.w, $color.x, $color.y
+ max $color.w, $color.w, $color.z
+
+ ; get the greater of one and the max color.
+ max $color.w, $color.w, $cOne
+
+ rcp $color.w, $color.w
+ mul $dst.xyz, $color.w, $color.xyz
+}
+
+sub AmbientLight
+{
+ local( $worldNormal ) = shift;
+ local( $linearColor ) = shift;
+ local( $add ) = shift;
+
+ ; Ambient lighting
+ &AllocateRegister( \$nSquared );
+ &AllocateRegister( \$isNegative );
+
+ mul $nSquared.xyz, $worldNormal.xyz, $worldNormal.xyz ; compute n times n
+ slt $isNegative.xyz, $worldNormal.xyz, $cZero ; Figure out whether each component is >0
+ mov a0.x, $isNegative.x
+ if( $add )
+ {
+ mad $linearColor.xyz, $nSquared.x, c[a0.x + $cAmbientColorPosXOffset], $linearColor ; $linearColor = normal[0]*normal[0] * box color of appropriate x side
+ }
+ else
+ {
+ mul $linearColor.xyz, $nSquared.x, c[a0.x + $cAmbientColorPosXOffset] ; $linearColor = normal[0]*normal[0] * box color of appropriate x side
+ }
+ mov a0.x, $isNegative.y
+ mad $linearColor.xyz, $nSquared.y, c[a0.x + $cAmbientColorPosYOffset], $linearColor
+ mov a0.x, $isNegative.z
+ mad $linearColor.xyz, $nSquared.z, c[a0.x + $cAmbientColorPosZOffset], $linearColor
+
+ &FreeRegister( \$isNegative );
+ &FreeRegister( \$nSquared );
+}
+
+sub DirectionalLight
+{
+ local( $worldNormal ) = shift;
+ local( $linearColor ) = shift;
+ local( $add ) = shift;
+
+ &AllocateRegister( \$nDotL ); # FIXME: This only needs to be a scalar
+
+ ; NOTE: Gotta use -l here, since light direction = -l
+ ; DIRECTIONAL LIGHT
+ ; compute n dot l
+ dp3 $nDotL.x, -c[a0.x + 1], $worldNormal
+
+ if ( $HALF_LAMBERT == 0 )
+ {
+ ; lambert
+ max $nDotL.x, $nDotL.x, c0.x ; Clamp to zero
+ }
+ elsif ( $HALF_LAMBERT == 1 )
+ {
+ ; half-lambert
+ mad $nDotL.x, $nDotL.x, $cHalf, $cHalf ; dot = (dot * 0.5 + 0.5)^2
+ mul $nDotL.x, $nDotL.x, $nDotL.x
+ }
+ else
+ {
+ die "\$HALF_LAMBERT is hosed\n";
+ }
+
+ if( $add )
+ {
+ mad $linearColor.xyz, c[a0.x], $nDotL.x, $linearColor
+ }
+ else
+ {
+ mul $linearColor.xyz, c[a0.x], $nDotL.x
+ }
+
+ &FreeRegister( \$nDotL );
+}
+
+sub PointLight
+{
+ local( $worldPos ) = shift;
+ local( $worldNormal ) = shift;
+ local( $linearColor ) = shift;
+ local( $add ) = shift;
+
+ local( $lightDir );
+ &AllocateRegister( \$lightDir );
+
+ ; POINT LIGHT
+ ; compute light direction
+ sub $lightDir, c[a0.x+2], $worldPos
+
+ local( $lightDistSquared );
+ local( $ooLightDist );
+ &AllocateRegister( \$lightDistSquared );
+ &AllocateRegister( \$ooLightDist );
+
+ ; normalize light direction, maintain temporaries for attenuation
+ dp3 $lightDistSquared, $lightDir, $lightDir
+ rsq $ooLightDist, $lightDistSquared.x
+ mul $lightDir, $lightDir, $ooLightDist.x
+
+ local( $attenuationFactors );
+ &AllocateRegister( \$attenuationFactors );
+
+ ; compute attenuation amount (r2 = 'd*d d*d d*d d*d', r3 = '1/d 1/d 1/d 1/d')
+ dst $attenuationFactors, $lightDistSquared, $ooLightDist ; r4 = ( 1, d, d*d, 1/d )
+ &FreeRegister( \$lightDistSquared );
+ &FreeRegister( \$ooLightDist );
+ local( $attenuation );
+ &AllocateRegister( \$attenuation );
+ dp3 $attenuation, $attenuationFactors, c[a0.x+4] ; r3 = atten0 + d * atten1 + d*d * atten2
+
+ rcp $lightDir.w, $attenuation ; $lightDir.w = 1 / (atten0 + d * atten1 + d*d * atten2)
+
+ &FreeRegister( \$attenuationFactors );
+ &FreeRegister( \$attenuation );
+
+ local( $tmp );
+ &AllocateRegister( \$tmp ); # FIXME : really only needs to be a scalar
+
+ ; compute n dot l, fold in distance attenutation
+ dp3 $tmp.x, $lightDir, $worldNormal
+
+ if ( $HALF_LAMBERT == 0 )
+ {
+ ; lambert
+ max $tmp.x, $tmp.x, c0.x ; Clamp to zero
+ }
+ elsif ( $HALF_LAMBERT == 1 )
+ {
+ ; half-lambert
+ mad $tmp.x, $tmp.x, $cHalf, $cHalf ; dot = (dot * 0.5 + 0.5)^2
+ mul $tmp.x, $tmp.x, $tmp.x
+ }
+ else
+ {
+ die "\$HALF_LAMBERT is hosed\n";
+ }
+
+ mul $tmp.x, $tmp.x, $lightDir.w
+ if( $add )
+ {
+ mad $linearColor.xyz, c[a0.x], $tmp.x, $linearColor
+ }
+ else
+ {
+ mul $linearColor.xyz, c[a0.x], $tmp.x
+ }
+
+ &FreeRegister( \$lightDir );
+ &FreeRegister( \$tmp ); # FIXME : really only needs to be a scalar
+}
+
+sub SpotLight
+{
+ local( $worldPos ) = shift;
+ local( $worldNormal ) = shift;
+ local( $linearColor ) = shift;
+ local( $add ) = shift;
+
+ local( $lightDir );
+ &AllocateRegister( \$lightDir );
+
+ ; SPOTLIGHT
+ ; compute light direction
+ sub $lightDir, c[a0.x+2], $worldPos
+
+ local( $lightDistSquared );
+ local( $ooLightDist );
+ &AllocateRegister( \$lightDistSquared );
+ &AllocateRegister( \$ooLightDist );
+
+ ; normalize light direction, maintain temporaries for attenuation
+ dp3 $lightDistSquared, $lightDir, $lightDir
+ rsq $ooLightDist, $lightDistSquared.x
+ mul $lightDir, $lightDir, $ooLightDist.x
+
+ local( $attenuationFactors );
+ &AllocateRegister( \$attenuationFactors );
+
+ ; compute attenuation amount (r2 = 'd*d d*d d*d d*d', r3 = '1/d 1/d 1/d 1/d')
+ dst $attenuationFactors, $lightDistSquared, $ooLightDist ; r4 = ( 1, d, d*d, 1/d )
+
+ &FreeRegister( \$lightDistSquared );
+ &FreeRegister( \$ooLightDist );
+ local( $attenuation ); &AllocateRegister( \$attenuation );
+
+ dp3 $attenuation, $attenuationFactors, c[a0.x+4] ; r3 = atten0 + d * atten1 + d*d * atten2
+ rcp $lightDir.w, $attenuation ; r1.w = 1 / (atten0 + d * atten1 + d*d * atten2)
+
+ &FreeRegister( \$attenuationFactors );
+ &FreeRegister( \$attenuation );
+
+ local( $litSrc ); &AllocateRegister( \$litSrc );
+ local( $tmp ); &AllocateRegister( \$tmp ); # FIXME - only needs to be scalar
+
+ ; compute n dot l
+ dp3 $litSrc.x, $worldNormal, $lightDir
+
+ if ( $HALF_LAMBERT == 0 )
+ {
+ ; lambert
+ max $litSrc.x, $litSrc.x, c0.x ; Clamp to zero
+ }
+ elsif ( $HALF_LAMBERT == 1 )
+ {
+ ; half-lambert
+ mad $litSrc.x, $litSrc.x, $cHalf, $cHalf ; dot = (dot * 0.5 + 0.5) ^ 2
+ mul $litSrc.x, $litSrc.x, $litSrc.x
+ }
+ else
+ {
+ die "\$HALF_LAMBERT is hosed\n";
+ }
+
+ ; compute angular attenuation
+ dp3 $tmp.x, c[a0.x+1], -$lightDir ; dot = -delta * spot direction
+ sub $litSrc.y, $tmp.x, c[a0.x+3].z ; r2.y = dot - stopdot2
+ &FreeRegister( \$tmp );
+ mul $litSrc.y, $litSrc.y, c[a0.x+3].w ; r2.y = (dot - stopdot2) / (stopdot - stopdot2)
+ mov $litSrc.w, c[a0.x+3].x ; r2.w = exponent
+ local( $litDst ); &AllocateRegister( \$litDst );
+ lit $litDst, $litSrc ; r3.y = N dot L or 0, whichever is bigger
+ &FreeRegister( \$litSrc );
+ ; r3.z = pow((dot - stopdot2) / (stopdot - stopdot2), exponent)
+ min $litDst.z, $litDst.z, $cOne ; clamp pow() to 1
+
+ local( $tmp1 ); &AllocateRegister( \$tmp1 );
+ local( $tmp2 ); &AllocateRegister( \$tmp2 ); # FIXME - could be scalar
+
+ ; fold in distance attenutation with other factors
+ mul $tmp1, c[a0.x], $lightDir.w
+ mul $tmp2.x, $litDst.y, $litDst.z
+ if( $add )
+ {
+ mad $linearColor.xyz, $tmp1, $tmp2.x, $linearColor
+ }
+ else
+ {
+ mul $linearColor.xyz, $tmp1, $tmp2.x
+ }
+
+ &FreeRegister( \$lightDir );
+ &FreeRegister( \$litDst );
+ &FreeRegister( \$tmp1 );
+ &FreeRegister( \$tmp2 );
+}
+
+sub DoLight
+{
+ local( $lightType ) = shift;
+ local( $worldPos ) = shift;
+ local( $worldNormal ) = shift;
+ local( $linearColor ) = shift;
+ local( $add ) = shift;
+
+ if( $lightType eq "spot" )
+ {
+ &SpotLight( $worldPos, $worldNormal, $linearColor, $add );
+ }
+ elsif( $lightType eq "point" )
+ {
+ &PointLight( $worldPos, $worldNormal, $linearColor, $add );
+ }
+ elsif( $lightType eq "directional" )
+ {
+ &DirectionalLight( $worldNormal, $linearColor, $add );
+ }
+ else
+ {
+ die "don't know about light type \"$lightType\"\n";
+ }
+}
+
+sub DoLighting
+{
+ if( !defined $LIGHT_COMBO )
+ {
+ die "DoLighting called without using \$LIGHT_COMBO\n";
+ }
+ if ( !defined $HALF_LAMBERT )
+ {
+ die "DoLighting called without using \$HALF_LAMBERT\n";
+ }
+
+ my $staticLightType = $g_staticLightTypeArray[$LIGHT_COMBO];
+ my $ambientLightType = $g_ambientLightTypeArray[$LIGHT_COMBO];
+ my $localLightType1 = $g_localLightType1Array[$LIGHT_COMBO];
+ my $localLightType2 = $g_localLightType2Array[$LIGHT_COMBO];
+
+# print "\$staticLightType = $staticLightType\n";
+# print "\$ambientLightType = $ambientLightType\n";
+# print "\$localLightType1 = $localLightType1\n";
+# print "\$localLightType2 = $localLightType2\n";
+
+ local( $worldPos ) = shift;
+ local( $worldNormal ) = shift;
+
+ ; special case for no lighting
+ if( $staticLightType eq "none" && $ambientLightType eq "none" &&
+ $localLightType1 eq "none" && $localLightType2 eq "none" )
+ {
+ ; Have to write something here since debug d3d runtime will barf otherwise.
+ mov oD0, $cOne
+ return;
+ }
+
+ ; special case for static lighting only
+ ; Don't need to bother converting to linear space in this case.
+ if( $staticLightType eq "static" && $ambientLightType eq "none" &&
+ $localLightType1 eq "none" && $localLightType2 eq "none" )
+ {
+ mov oD0, $vSpecular
+ return;
+ }
+
+ alloc $linearColor
+ alloc $gammaColor
+
+ local( $add ) = 0;
+ if( $staticLightType eq "static" )
+ {
+ ; The static lighting comes in in gamma space and has also been premultiplied by $cOverbrightFactor
+ ; need to get it into
+ ; linear space so that we can do adds.
+ rcp $gammaColor.w, $cOverbrightFactor
+ mul $gammaColor.xyz, $vSpecular, $gammaColor.w
+ &GammaToLinear( $gammaColor, $linearColor );
+ $add = 1;
+ }
+
+ if( $ambientLightType eq "ambient" )
+ {
+ &AmbientLight( $worldNormal, $linearColor, $add );
+ $add = 1;
+ }
+
+ if( $localLightType1 ne "none" )
+ {
+ mov a0.x, $cLight0Offset
+ &DoLight( $localLightType1, $worldPos, $worldNormal, $linearColor, $add );
+ $add = 1;
+ }
+
+ if( $localLightType2 ne "none" )
+ {
+ mov a0.x, $cLight1Offset
+ &DoLight( $localLightType2, $worldPos, $worldNormal, $linearColor, $add );
+ $add = 1;
+ }
+
+ ;------------------------------------------------------------------------------
+ ; Output color (gamma correction)
+ ;------------------------------------------------------------------------------
+
+ &LinearToGamma( $linearColor, $gammaColor );
+ if( 0 )
+ {
+ mul oD0.xyz, $gammaColor.xyz, $cOverbrightFactor
+ }
+ else
+ {
+ mul $gammaColor.xyz, $gammaColor.xyz, $cOverbrightFactor
+ &ColorClamp( $gammaColor, "oD0" );
+ }
+
+; mov oD0.xyz, $linearColor
+ mov oD0.w, $cOne ; make sure all components are defined
+
+ free $linearColor
+ free $gammaColor
+}
+
+sub DoDynamicLightingToLinear
+{
+ local( $worldPos ) = shift;
+ local( $worldNormal ) = shift;
+ local( $linearColor ) = shift;
+
+ if( !defined $LIGHT_COMBO )
+ {
+ die "DoLighting called without using \$LIGHT_COMBO\n";
+ }
+ if ( !defined $HALF_LAMBERT )
+ {
+ die "DoLighting called without using \$HALF_LAMBERT\n";
+ }
+
+ my $staticLightType = $g_staticLightTypeArray[$LIGHT_COMBO];
+ my $ambientLightType = $g_ambientLightTypeArray[$LIGHT_COMBO];
+ my $localLightType1 = $g_localLightType1Array[$LIGHT_COMBO];
+ my $localLightType2 = $g_localLightType2Array[$LIGHT_COMBO];
+
+ # No lights at all. . note that we don't even consider static lighting here.
+ if( $ambientLightType eq "none" &&
+ $localLightType1 eq "none" && $localLightType2 eq "none" )
+ {
+ mov $linearColor, $cZero
+ return;
+ }
+
+ local( $add ) = 0;
+ if( $ambientLightType eq "ambient" )
+ {
+ &AmbientLight( $worldNormal, $linearColor, $add );
+ $add = 1;
+ }
+
+ if( $localLightType1 ne "none" )
+ {
+ mov a0.x, $cLight0Offset
+ &DoLight( $localLightType1, $worldPos, $worldNormal, $linearColor, $add );
+ $add = 1;
+ }
+
+ if( $localLightType2 ne "none" )
+ {
+ mov a0.x, $cLight1Offset
+ &DoLight( $localLightType2, $worldPos, $worldNormal, $linearColor, $add );
+ $add = 1;
+ }
+}
+
+sub NotImplementedYet
+{
+ &AllocateRegister( \$projPos );
+ dp4 $projPos.x, $worldPos, $cViewProj0
+ dp4 $projPos.y, $worldPos, $cViewProj1
+ dp4 $projPos.z, $worldPos, $cViewProj2
+ dp4 $projPos.w, $worldPos, $cViewProj3
+ mov oPos, $projPos
+ &FreeRegister( \$projPos );
+ exit;
+}
diff --git a/mp/src/materialsystem/stdshaders/shader_constant_register_map.h b/mp/src/materialsystem/stdshaders/shader_constant_register_map.h new file mode 100644 index 00000000..485bb7c4 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/shader_constant_register_map.h @@ -0,0 +1,81 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Provide convenient mapping for shader constants
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef C_CODE_HACK
+#include "common_vertexlitgeneric_dx9.h"
+#endif
+
+#define PSREG_SELFILLUMTINT PSREG_CONSTANT_00
+#define PSREG_DIFFUSE_MODULATION PSREG_CONSTANT_01
+#define PSREG_ENVMAP_TINT__SHADOW_TWEAKS PSREG_CONSTANT_02
+#define PSREG_SELFILLUM_SCALE_BIAS_EXP PSREG_CONSTANT_03
+#define PSREG_AMBIENT_CUBE PSREG_CONSTANT_04
+// PSREG_AMBIENT_CUBE PSREG_CONSTANT_05
+// PSREG_AMBIENT_CUBE PSREG_CONSTANT_06
+// PSREG_AMBIENT_CUBE PSREG_CONSTANT_07
+// PSREG_AMBIENT_CUBE PSREG_CONSTANT_08
+// PSREG_AMBIENT_CUBE PSREG_CONSTANT_09
+#define PSREG_ENVMAP_FRESNEL__SELFILLUMMASK PSREG_CONSTANT_10
+#define PSREG_EYEPOS_SPEC_EXPONENT PSREG_CONSTANT_11
+#define PSREG_FOG_PARAMS PSREG_CONSTANT_12
+#define PSREG_FLASHLIGHT_ATTENUATION PSREG_CONSTANT_13
+#define PSREG_FLASHLIGHT_POSITION_RIM_BOOST PSREG_CONSTANT_14
+#define PSREG_FLASHLIGHT_TO_WORLD_TEXTURE PSREG_CONSTANT_15
+// PSREG_FLASHLIGHT_TO_WORLD_TEXTURE PSREG_CONSTANT_16
+// PSREG_FLASHLIGHT_TO_WORLD_TEXTURE PSREG_CONSTANT_17
+// PSREG_FLASHLIGHT_TO_WORLD_TEXTURE PSREG_CONSTANT_18
+#define PSREG_FRESNEL_SPEC_PARAMS PSREG_CONSTANT_19
+#define PSREG_LIGHT_INFO_ARRAY PSREG_CONSTANT_20
+// PSREG_LIGHT_INFO_ARRAY PSREG_CONSTANT_21
+// PSREG_LIGHT_INFO_ARRAY PSREG_CONSTANT_22
+// PSREG_LIGHT_INFO_ARRAY PSREG_CONSTANT_23
+// PSREG_LIGHT_INFO_ARRAY PSREG_CONSTANT_24
+// PSREG_LIGHT_INFO_ARRAY PSREG_CONSTANT_25
+#define PSREG_SPEC_RIM_PARAMS PSREG_CONSTANT_26
+// #define **free** PSREG_CONSTANT_27 //actually using this often blows constant limits, since literals have to get stuffed somewhere...
+#define PSREG_FLASHLIGHT_COLOR PSREG_CONSTANT_28
+#define PSREG_LINEAR_FOG_COLOR PSREG_CONSTANT_29
+#define PSREG_LIGHT_SCALE PSREG_CONSTANT_30
+#define PSREG_FLASHLIGHT_SCREEN_SCALE PSREG_CONSTANT_31
+// --- End of ps_2_0 and ps_2_b constants ---
+
+
+#ifndef C_CODE_HACK
+//for fxc code, map the constants to register names.
+#define PSREG_CONSTANT_00 c0
+#define PSREG_CONSTANT_01 c1
+#define PSREG_CONSTANT_02 c2
+#define PSREG_CONSTANT_03 c3
+#define PSREG_CONSTANT_04 c4
+#define PSREG_CONSTANT_05 c5
+#define PSREG_CONSTANT_06 c6
+#define PSREG_CONSTANT_07 c7
+#define PSREG_CONSTANT_08 c8
+#define PSREG_CONSTANT_09 c9
+#define PSREG_CONSTANT_10 c10
+#define PSREG_CONSTANT_11 c11
+#define PSREG_CONSTANT_12 c12
+#define PSREG_CONSTANT_13 c13
+#define PSREG_CONSTANT_14 c14
+#define PSREG_CONSTANT_15 c15
+#define PSREG_CONSTANT_16 c16
+#define PSREG_CONSTANT_17 c17
+#define PSREG_CONSTANT_18 c18
+#define PSREG_CONSTANT_19 c19
+#define PSREG_CONSTANT_20 c20
+#define PSREG_CONSTANT_21 c21
+#define PSREG_CONSTANT_22 c22
+#define PSREG_CONSTANT_23 c23
+#define PSREG_CONSTANT_24 c24
+#define PSREG_CONSTANT_25 c25
+#define PSREG_CONSTANT_26 c26
+#define PSREG_CONSTANT_27 c27
+#define PSREG_CONSTANT_28 c28
+#define PSREG_CONSTANT_29 c29
+#define PSREG_CONSTANT_30 c30
+#define PSREG_CONSTANT_31 c31
+#endif
diff --git a/mp/src/materialsystem/stdshaders/stdshader_dx9_20b.txt b/mp/src/materialsystem/stdshaders/stdshader_dx9_20b.txt new file mode 100644 index 00000000..f70ae0a2 --- /dev/null +++ b/mp/src/materialsystem/stdshaders/stdshader_dx9_20b.txt @@ -0,0 +1,11 @@ +//
+// Standard shaders collection
+//
+// These shaders are compiled as the following shader models:
+// _ps20.vcs
+// _ps20b.vcs
+// _vs20.vcs
+//
+
+example_model_ps20b.fxc
+example_model_vs20.fxc
diff --git a/mp/src/materialsystem/stdshaders/stdshader_dx9_30.txt b/mp/src/materialsystem/stdshaders/stdshader_dx9_30.txt new file mode 100644 index 00000000..5a09a37b --- /dev/null +++ b/mp/src/materialsystem/stdshaders/stdshader_dx9_30.txt @@ -0,0 +1,10 @@ +//
+// vs 3.0 ps 3.0 shaders collection
+//
+// These shaders are forced to compile as shader model 3.0
+// using the new compiler.
+// _ps30.vcs
+// _vs30.vcs
+//
+
+// There are no examples of such shaders in the SDK, but add yours here.
|