Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

641 lines
23 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $Header: $
// $NoKeywords: $
//===========================================================================//
#include "BaseVSShader.h"
#include "vertexlitgeneric_dx9_helper.h"
#include "vortwarp_vs20.inc"
#include "vortwarp_ps20.inc"
#include "vortwarp_ps20b.inc"
#include "convar.h"
#ifndef _X360
#include "vortwarp_vs30.inc"
#include "vortwarp_ps30.inc"
#endif
DEFINE_FALLBACK_SHADER( VortWarp, VortWarp_dx9 )
extern ConVar r_flashlight_version2;
struct VortWarp_DX9_Vars_t : public VertexLitGeneric_DX9_Vars_t
{
VortWarp_DX9_Vars_t() { memset( this, 0xFF, sizeof(*this) ); }
int m_nEntityOrigin;
int m_nWarpParam;
int m_nFlowMap;
int m_nSelfIllumMap;
int m_nUnlit;
};
//-----------------------------------------------------------------------------
// Draws the shader
//-----------------------------------------------------------------------------
void DrawVortWarp_DX9( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI,
IShaderShadow* pShaderShadow, bool bVertexLitGeneric, bool hasFlashlight, VortWarp_DX9_Vars_t &info, VertexCompressionType_t vertexCompression )
{
bool hasBaseTexture = params[info.m_nBaseTexture]->IsTexture();
bool hasBump = (info.m_nBumpmap != -1) && params[info.m_nBumpmap]->IsTexture();
bool hasDetailTexture = !hasBump && params[info.m_nDetail]->IsTexture();
bool hasNormalMapAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK );
bool hasVertexColor = bVertexLitGeneric ? false : IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
bool hasVertexAlpha = bVertexLitGeneric ? false : IS_FLAG_SET( MATERIAL_VAR_VERTEXALPHA );
bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0;
bool hasSelfIllumInEnvMapMask =
( info.m_nSelfIllumEnvMapMask_Alpha != -1 ) &&
( params[info.m_nSelfIllumEnvMapMask_Alpha]->GetFloatValue() != 0.0 ) ;
bool bHasFlowMap = ( info.m_nFlowMap != -1 ) && params[info.m_nFlowMap]->IsTexture();
bool bHasSelfIllumMap = ( info.m_nSelfIllumMap != -1 ) && params[info.m_nSelfIllumMap]->IsTexture();
BlendType_t blendType;
if ( params[info.m_nBaseTexture]->IsTexture() )
{
blendType = pShader->EvaluateBlendRequirements( info.m_nBaseTexture, true );
}
else
{
blendType = pShader->EvaluateBlendRequirements( info.m_nEnvmapMask, false );
}
if( pShader->IsSnapshotting() )
{
// look at color and alphamod stuff.
// Unlit generic never uses the flashlight
bool hasEnvmap = !hasFlashlight && params[info.m_nEnvmap]->IsTexture();
bool hasEnvmapMask = (hasSelfIllumInEnvMapMask || !hasFlashlight) &&
params[info.m_nEnvmapMask]->IsTexture();
bool bHasNormal = bVertexLitGeneric || hasEnvmap;
if( hasFlashlight )
{
hasEnvmapMask = false;
}
bool bHalfLambert = IS_FLAG_SET( MATERIAL_VAR_HALFLAMBERT );
// Alpha test: FIXME: shouldn't this be handled in CBaseVSShader::SetInitialShadowState
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() );
}
if( hasFlashlight )
{
if (params[info.m_nBaseTexture]->IsTexture())
{
pShader->SetAdditiveBlendingShadowState( info.m_nBaseTexture, true );
}
else
{
pShader->SetAdditiveBlendingShadowState( info.m_nEnvmapMask, false );
}
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 );
}
else
{
if (params[info.m_nBaseTexture]->IsTexture())
{
pShader->SetDefaultBlendingShadowState( info.m_nBaseTexture, true );
}
else
{
pShader->SetDefaultBlendingShadowState( info.m_nEnvmapMask, false );
}
}
unsigned int flags = VERTEX_POSITION;
int nTexCoordCount = 1; // texcoord0 : base texcoord
int userDataSize = 0;
if( bHasNormal )
{
flags |= VERTEX_NORMAL;
}
if( hasBaseTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true );
}
if( hasEnvmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );
}
}
if( hasFlashlight )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
userDataSize = 4; // tangent S
}
if( hasDetailTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
}
if( hasBump )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
userDataSize = 4; // tangent S
// Normalizing cube map
pShaderShadow->EnableTexture( SHADER_SAMPLER5, true );
}
if( hasEnvmapMask )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
}
if( hasVertexColor || hasVertexAlpha )
{
flags |= VERTEX_COLOR;
}
pShaderShadow->EnableSRGBWrite( true );
if( bHasSelfIllumMap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
}
if( bHasFlowMap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
}
// This shader supports compressed vertices, so OR in that flag:
flags |= VERTEX_FORMAT_COMPRESSED;
pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, NULL, userDataSize );
Assert( hasBump );
#ifndef _X360
if ( !g_pHardwareConfig->HasFastVertexTextures() )
#endif
{
bool bUseStaticControlFlow = g_pHardwareConfig->SupportsStaticControlFlow();
DECLARE_STATIC_VERTEX_SHADER( vortwarp_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( HALFLAMBERT, bHalfLambert);
SET_STATIC_VERTEX_SHADER_COMBO( USE_STATIC_CONTROL_FLOW, bUseStaticControlFlow );
SET_STATIC_VERTEX_SHADER( vortwarp_vs20 );
if( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER( vortwarp_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, hasBaseTexture );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, hasEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSELIGHTING, !params[info.m_nUnlit]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( HALFLAMBERT, bHalfLambert);
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( TRANSLUCENT, blendType == BT_BLEND );
SET_STATIC_PIXEL_SHADER( vortwarp_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( vortwarp_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, hasBaseTexture );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, hasEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSELIGHTING, !params[info.m_nUnlit]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( HALFLAMBERT, bHalfLambert);
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( TRANSLUCENT, blendType == BT_BLEND );
SET_STATIC_PIXEL_SHADER( vortwarp_ps20 );
}
}
#ifndef _X360
else
{
// The vertex shader uses the vertex id stream
SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID );
DECLARE_STATIC_VERTEX_SHADER( vortwarp_vs30 );
SET_STATIC_VERTEX_SHADER_COMBO( HALFLAMBERT, bHalfLambert);
SET_STATIC_VERTEX_SHADER( vortwarp_vs30 );
DECLARE_STATIC_PIXEL_SHADER( vortwarp_ps30 );
SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, hasBaseTexture );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, hasEnvmap );
SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSELIGHTING, !params[info.m_nUnlit]->GetIntValue() );
SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask );
SET_STATIC_PIXEL_SHADER_COMBO( HALFLAMBERT, bHalfLambert);
SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, hasFlashlight );
SET_STATIC_PIXEL_SHADER_COMBO( TRANSLUCENT, blendType == BT_BLEND );
SET_STATIC_PIXEL_SHADER( vortwarp_ps30 );
}
#endif
if( hasFlashlight )
{
pShader->FogToBlack();
}
else
{
pShader->DefaultFog();
}
if( blendType == BT_BLEND )
{
pShaderShadow->EnableBlending( true );
pShaderShadow->BlendFunc( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA );
pShaderShadow->EnableAlphaWrites( false );
}
else
{
pShaderShadow->EnableAlphaWrites( true );
}
}
else
{
bool hasEnvmap = !hasFlashlight && params[info.m_nEnvmap]->IsTexture();
bool hasEnvmapMask = !hasFlashlight && params[info.m_nEnvmapMask]->IsTexture();
if( hasBaseTexture )
{
pShader->BindTexture( SHADER_SAMPLER0, info.m_nBaseTexture, info.m_nBaseTextureFrame );
}
if( hasEnvmap )
{
pShader->BindTexture( SHADER_SAMPLER1, info.m_nEnvmap, info.m_nEnvmapFrame );
}
if( hasDetailTexture )
{
pShader->BindTexture( SHADER_SAMPLER2, info.m_nDetail, info.m_nDetailFrame );
}
if( !g_pConfig->m_bFastNoBump )
{
if( hasBump )
{
pShader->BindTexture( SHADER_SAMPLER3, info.m_nBumpmap, info.m_nBumpFrame );
}
}
else
{
if( hasBump )
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT );
}
}
if( hasEnvmapMask )
{
pShader->BindTexture( SHADER_SAMPLER4, info.m_nEnvmapMask, info.m_nEnvmapMaskFrame );
}
if( hasFlashlight )
{
Assert( info.m_nFlashlightTexture >= 0 && info.m_nFlashlightTextureFrame >= 0 );
pShader->BindTexture( SHADER_SAMPLER7, info.m_nFlashlightTexture, info.m_nFlashlightTextureFrame );
VMatrix worldToTexture;
ITexture *pFlashlightDepthTexture;
FlashlightState_t state = pShaderAPI->GetFlashlightStateEx( worldToTexture, &pFlashlightDepthTexture );
SetFlashLightColorFromState( state, pShaderAPI );
}
// Set up light combo state
LightState_t lightState = {0, false, false};
if ( bVertexLitGeneric && !hasFlashlight )
{
pShaderAPI->GetDX9LightState( &lightState );
}
MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode();
int fogIndex = ( fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ) ? 1 : 0;
int numBones = pShaderAPI->GetCurrentNumBones();
Assert( hasBump );
#ifndef _X360
if ( !g_pHardwareConfig->HasFastVertexTextures() )
#endif
{
bool bUseStaticControlFlow = g_pHardwareConfig->SupportsStaticControlFlow();
DECLARE_DYNAMIC_VERTEX_SHADER( vortwarp_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, numBones > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER_COMBO( NUM_LIGHTS, bUseStaticControlFlow ? 0 : lightState.m_nNumLights );
SET_DYNAMIC_VERTEX_SHADER( vortwarp_vs20 );
if( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( vortwarp_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z &&
blendType != BT_BLENDADD && blendType != BT_BLEND && !bIsAlphaTested );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
float warpParam = params[info.m_nWarpParam]->GetFloatValue();
// float selfIllumTint = params[info.m_nSelfIllumTint]->GetFloatValue();
// DevMsg( 1, "warpParam: %f %f\n", warpParam, selfIllumTint );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WARPINGIN, warpParam > 0.0f && warpParam < 1.0f );
SET_DYNAMIC_PIXEL_SHADER( vortwarp_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( vortwarp_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z &&
blendType != BT_BLENDADD && blendType != BT_BLEND && !bIsAlphaTested );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
float warpParam = params[info.m_nWarpParam]->GetFloatValue();
// float selfIllumTint = params[info.m_nSelfIllumTint]->GetFloatValue();
// DevMsg( 1, "warpParam: %f %f\n", warpParam, selfIllumTint );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WARPINGIN, warpParam > 0.0f && warpParam < 1.0f );
SET_DYNAMIC_PIXEL_SHADER( vortwarp_ps20 );
}
}
#ifndef _X360
else
{
pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, SHADER_VERTEXTEXTURE_SAMPLER0 );
DECLARE_DYNAMIC_VERTEX_SHADER( vortwarp_vs30 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, numBones > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, pShaderAPI->IsHWMorphingEnabled() );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( vortwarp_vs30 );
DECLARE_DYNAMIC_PIXEL_SHADER( vortwarp_ps30 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights );
SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z &&
blendType != BT_BLENDADD && blendType != BT_BLEND && !bIsAlphaTested );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
float warpParam = params[info.m_nWarpParam]->GetFloatValue();
// float selfIllumTint = params[info.m_nSelfIllumTint]->GetFloatValue();
// DevMsg( 1, "warpParam: %f %f\n", warpParam, selfIllumTint );
SET_DYNAMIC_PIXEL_SHADER_COMBO( WARPINGIN, warpParam > 0.0f && warpParam < 1.0f );
SET_DYNAMIC_PIXEL_SHADER( vortwarp_ps30 );
}
#endif
pShader->SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nBaseTextureTransform );
if( hasDetailTexture )
{
pShader->SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBaseTextureTransform, info.m_nDetailScale );
Assert( !hasBump );
}
if( hasBump )
{
pShader->SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBumpTransform );
Assert( !hasDetailTexture );
}
if( hasEnvmapMask )
{
pShader->SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nEnvmapMaskTransform );
}
if( hasEnvmap )
{
pShader->SetEnvMapTintPixelShaderDynamicState( 0, info.m_nEnvmapTint, -1, true );
}
if( ( info.m_nHDRColorScale != -1 ) && pShader->IsHDREnabled() )
{
pShader->SetModulationPixelShaderDynamicState_LinearColorSpace_LinearScale( 1, params[info.m_nHDRColorScale]->GetFloatValue() );
}
else
{
pShader->SetModulationPixelShaderDynamicState_LinearColorSpace( 1 );
}
pShader->SetPixelShaderConstant( 2, info.m_nEnvmapContrast );
pShader->SetPixelShaderConstant( 3, info.m_nEnvmapSaturation );
pShader->SetPixelShaderConstant( 4, info.m_nSelfIllumTint );
pShader->SetAmbientCubeDynamicStateVertexShader();
if( hasBump )
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED );
pShaderAPI->SetPixelShaderStateAmbientLightCube( 5 );
pShaderAPI->CommitPixelShaderLighting( 13 );
}
if( bHasSelfIllumMap )
{
pShader->BindTexture( SHADER_SAMPLER6, info.m_nSelfIllumMap, -1 );
}
if( bHasFlowMap )
{
pShader->BindTexture( SHADER_SAMPLER2, info.m_nFlowMap, -1 );
}
float eyePos[4];
pShaderAPI->GetWorldSpaceCameraPosition( eyePos );
pShaderAPI->SetPixelShaderConstant( 20, eyePos, 1 );
pShaderAPI->SetPixelShaderFogParams( 21 );
// dynamic drawing code that extends vertexlitgeneric
float curTime = params[info.m_nWarpParam]->GetFloatValue();
float timeVec[4] = { 0.0f, 0.0f, 0.0f, curTime };
Assert( params[info.m_nEntityOrigin]->IsDefined() );
params[info.m_nEntityOrigin]->GetVecValue( timeVec, 3 );
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, timeVec, 1 );
curTime = pShaderAPI->CurrentTime();
timeVec[0] = curTime;
timeVec[1] = curTime;
timeVec[2] = curTime;
timeVec[3] = curTime;
pShaderAPI->SetPixelShaderConstant( 22, timeVec, 1 );
// flashlightfixme: put this in common code.
if( hasFlashlight )
{
VMatrix worldToTexture;
const FlashlightState_t &flashlightState = pShaderAPI->GetFlashlightState( worldToTexture );
// 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;
pShaderAPI->SetPixelShaderConstant( 22, atten, 1 );
// 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;
pShaderAPI->SetPixelShaderConstant( 23, pos, 1 );
pShaderAPI->SetPixelShaderConstant( 24, worldToTexture.Base(), 4 );
}
}
pShader->Draw();
}
BEGIN_VS_SHADER( VortWarp_DX9,
"Help for VortWarp_DX9" )
BEGIN_SHADER_PARAMS
SHADER_PARAM( ALBEDO, SHADER_PARAM_TYPE_TEXTURE, "shadertest/BaseTexture", "albedo (Base texture with no baked lighting)" )
SHADER_PARAM( SELFILLUMTINT, SHADER_PARAM_TYPE_COLOR, "[1 1 1]", "Self-illumination tint" )
SHADER_PARAM( DETAIL, SHADER_PARAM_TYPE_TEXTURE, "shadertest/detail", "detail texture" )
SHADER_PARAM( DETAILFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "frame number for $detail" )
SHADER_PARAM( DETAILSCALE, SHADER_PARAM_TYPE_FLOAT, "4", "scale of the detail texture" )
SHADER_PARAM( ENVMAP, SHADER_PARAM_TYPE_TEXTURE, "shadertest/shadertest_env", "envmap" )
SHADER_PARAM( ENVMAPFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "envmap frame number" )
SHADER_PARAM( ENVMAPMASK, SHADER_PARAM_TYPE_TEXTURE, "shadertest/shadertest_envmask", "envmap mask" )
SHADER_PARAM( ENVMAPMASKFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "" )
SHADER_PARAM( ENVMAPMASKTRANSFORM, SHADER_PARAM_TYPE_MATRIX, "center .5 .5 scale 1 1 rotate 0 translate 0 0", "$envmapmask texcoord transform" )
SHADER_PARAM( ENVMAPTINT, SHADER_PARAM_TYPE_COLOR, "[1 1 1]", "envmap tint" )
SHADER_PARAM( BUMPMAP, SHADER_PARAM_TYPE_TEXTURE, "models/shadertest/shader1_normal", "bump map" )
SHADER_PARAM( BUMPFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "frame number for $bumpmap" )
SHADER_PARAM( BUMPTRANSFORM, SHADER_PARAM_TYPE_MATRIX, "center .5 .5 scale 1 1 rotate 0 translate 0 0", "$bumpmap texcoord transform" )
SHADER_PARAM( ENVMAPCONTRAST, SHADER_PARAM_TYPE_FLOAT, "0.0", "contrast 0 == normal 1 == color*color" )
SHADER_PARAM( ENVMAPSATURATION, SHADER_PARAM_TYPE_FLOAT, "1.0", "saturation 0 == greyscale 1 == normal" )
SHADER_PARAM( SELFILLUM_ENVMAPMASK_ALPHA, SHADER_PARAM_TYPE_FLOAT,"0.0","defines that self illum value comes from env map mask alpha" )
// Debugging term for visualizing ambient data on its own
SHADER_PARAM( AMBIENTONLY, SHADER_PARAM_TYPE_INTEGER, "0", "Control drawing of non-ambient light ()" )
// hack hack hack
SHADER_PARAM( ENTITYORIGIN, SHADER_PARAM_TYPE_VEC3,"0.0","center if the model in world space" )
SHADER_PARAM( WARPPARAM, SHADER_PARAM_TYPE_FLOAT,"0.0","animation param between 0 and 1" )
SHADER_PARAM( FLOWMAP, SHADER_PARAM_TYPE_TEXTURE, "", "flow map" )
SHADER_PARAM( SELFILLUMMAP, SHADER_PARAM_TYPE_TEXTURE, "", "self-illumination map" )
SHADER_PARAM( UNLIT, SHADER_PARAM_TYPE_BOOL, "", "" )
SHADER_PARAM( PHONGEXPONENT, SHADER_PARAM_TYPE_FLOAT, "5.0", "Phong exponent for local specular lights" )
SHADER_PARAM( PHONGTINT, SHADER_PARAM_TYPE_VEC3, "5.0", "Phong tint for local specular lights" )
SHADER_PARAM( PHONGALBEDOTINT, SHADER_PARAM_TYPE_BOOL, "1.0", "Apply tint by albedo (controlled by spec exponent texture" )
SHADER_PARAM( LIGHTWARPTEXTURE, SHADER_PARAM_TYPE_TEXTURE, "shadertest/BaseTexture", "1D ramp texture for tinting scalar diffuse term" )
SHADER_PARAM( PHONGWARPTEXTURE, SHADER_PARAM_TYPE_TEXTURE, "shadertest/BaseTexture", "warp specular term" )
SHADER_PARAM( PHONGFRESNELRANGES, SHADER_PARAM_TYPE_VEC3, "[0 0.5 1]", "Parameters for remapping fresnel output" )
SHADER_PARAM( PHONGBOOST, SHADER_PARAM_TYPE_FLOAT, "1.0", "Phong overbrightening factor (specular mask channel should be authored to account for this)" )
SHADER_PARAM( PHONGEXPONENTTEXTURE, SHADER_PARAM_TYPE_TEXTURE, "shadertest/BaseTexture", "Phong Exponent map" )
SHADER_PARAM( PHONG, SHADER_PARAM_TYPE_BOOL, "0", "enables phong lighting" )
END_SHADER_PARAMS
void SetupVars( VortWarp_DX9_Vars_t& info )
{
info.m_nBaseTexture = BASETEXTURE;
info.m_nBaseTextureFrame = FRAME;
info.m_nBaseTextureTransform = BASETEXTURETRANSFORM;
info.m_nAlbedo = ALBEDO;
info.m_nSelfIllumTint = SELFILLUMTINT;
info.m_nDetail = DETAIL;
info.m_nDetailFrame = DETAILFRAME;
info.m_nDetailScale = DETAILSCALE;
info.m_nEnvmap = ENVMAP;
info.m_nEnvmapFrame = ENVMAPFRAME;
info.m_nEnvmapMask = ENVMAPMASK;
info.m_nEnvmapMaskFrame = ENVMAPMASKFRAME;
info.m_nEnvmapMaskTransform = ENVMAPMASKTRANSFORM;
info.m_nEnvmapTint = ENVMAPTINT;
info.m_nBumpmap = BUMPMAP;
info.m_nBumpFrame = BUMPFRAME;
info.m_nBumpTransform = BUMPTRANSFORM;
info.m_nEnvmapContrast = ENVMAPCONTRAST;
info.m_nEnvmapSaturation = ENVMAPSATURATION;
info.m_nAlphaTestReference = -1;
info.m_nFlashlightTexture = FLASHLIGHTTEXTURE;
info.m_nFlashlightTextureFrame = FLASHLIGHTTEXTUREFRAME;
info.m_nSelfIllumEnvMapMask_Alpha = SELFILLUM_ENVMAPMASK_ALPHA;
info.m_nAmbientOnly = AMBIENTONLY;
info.m_nEntityOrigin = ENTITYORIGIN;
info.m_nWarpParam = WARPPARAM;
info.m_nFlowMap = FLOWMAP;
info.m_nSelfIllumMap = SELFILLUMMAP;
info.m_nUnlit = UNLIT;
info.m_nPhongExponent = PHONGEXPONENT;
info.m_nPhongExponentTexture = PHONGEXPONENTTEXTURE;
info.m_nDiffuseWarpTexture = LIGHTWARPTEXTURE;
info.m_nPhongWarpTexture = PHONGWARPTEXTURE;
info.m_nPhongBoost = PHONGBOOST;
info.m_nPhongFresnelRanges = PHONGFRESNELRANGES;
info.m_nPhong = PHONG;
}
SHADER_INIT_PARAMS()
{
VortWarp_DX9_Vars_t vars;
if( !params[BUMPMAP]->IsDefined() )
{
params[BUMPMAP]->SetStringValue( "dev/flat_normal" );
}
SetupVars( vars );
if( !params[UNLIT]->IsDefined() )
{
params[UNLIT]->SetIntValue( 0 );
}
if( !params[SELFILLUMTINT]->IsDefined() )
{
params[SELFILLUMTINT]->SetVecValue( 0.0f, 0.0f, 0.0f, 0.0f );
}
InitParamsVertexLitGeneric_DX9( this, params, pMaterialName, true, vars );
}
SHADER_FALLBACK
{
if (g_pHardwareConfig->GetDXSupportLevel() < 90)
return "vortwarp_DX8";
return 0;
}
SHADER_INIT
{
VortWarp_DX9_Vars_t vars;
SetupVars( vars );
InitVertexLitGeneric_DX9( this, params, true, vars );
if( params[FLOWMAP]->IsDefined() )
{
LoadTexture( FLOWMAP );
}
if( params[SELFILLUMMAP]->IsDefined() )
{
LoadTexture( SELFILLUMMAP );
}
}
SHADER_DRAW
{
VortWarp_DX9_Vars_t vars;
SetupVars( vars );
// UGH!!! FIXME!!!!! Should fix VertexlitGeneric_dx9_helper so that you
// can override the vertex shader/pixel shader used (along with the combo vars).
bool bHasFlashlight = UsingFlashlight( params );
if ( bHasFlashlight && ( IsX360() || r_flashlight_version2.GetInt() ) )
{
DrawVortWarp_DX9( this, params, pShaderAPI, pShaderShadow, true, false, vars, vertexCompression );
SHADOW_STATE
{
SetInitialShadowState();
}
}
DrawVortWarp_DX9( this, params, pShaderAPI, pShaderShadow, true, bHasFlashlight, vars, vertexCompression );
}
END_SHADER