d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
521 Commits
25 Branches
6 Tags
221 MiB
Tree: b9cf6b2c7e
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b9cf6b2c7e'
${ noResults }
source-engine/materialsystem/stdshaders/lightmappedgeneric_dx8.cpp

803 lines
25 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Lightmap only shader
//
// $Header: $
// $NoKeywords: $
//=============================================================================//
#include "BaseVSShader.h"
#include "lightmappedgeneric_vs11.inc"
#include "unlitgeneric_vs11.inc"
#include "worldvertextransition_seamless.inc"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
static ConVar mat_fullbright( "mat_fullbright","0", FCVAR_CHEAT );
DEFINE_FALLBACK_SHADER( LightmappedGeneric, LightmappedGeneric_DX8 )
BEGIN_VS_SHADER( LightmappedGeneric_DX8,
"Help for LightmappedGeneric_DX8" )
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( DETAILSCALE, SHADER_PARAM_TYPE_FLOAT, "4", "scale of the detail texture" )
SHADER_PARAM( DETAILBLENDFACTOR, SHADER_PARAM_TYPE_FLOAT, "1", "amount of detail texture to apply" )
SHADER_PARAM( ENVMAP, SHADER_PARAM_TYPE_TEXTURE, "shadertest/shadertest_env", "envmap" )
SHADER_PARAM( ENVMAPFRAME, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( ENVMAPMASK, SHADER_PARAM_TYPE_TEXTURE, "shadertest/shadertest_envmask", "envmap mask" )
SHADER_PARAM( ENVMAPMASKFRAME, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( ENVMAPMASKSCALE, SHADER_PARAM_TYPE_FLOAT, "1", "envmap mask scale" )
SHADER_PARAM( ENVMAPTINT, SHADER_PARAM_TYPE_COLOR, "[1 1 1]", "envmap tint" )
SHADER_PARAM( BUMPMAP, SHADER_PARAM_TYPE_TEXTURE, "models/shadertest/shader1_normal", "bump map" )
SHADER_PARAM( BUMPFRAME, SHADER_PARAM_TYPE_INTEGER, "0", "frame number for $bumpmap" )
SHADER_PARAM( BUMPTRANSFORM, SHADER_PARAM_TYPE_MATRIX, "center .5 .5 scale 1 1 rotate 0 translate 0 0", "$bumpmap texcoord transform" )
SHADER_PARAM( ENVMAPCONTRAST, SHADER_PARAM_TYPE_FLOAT, "0.0", "contrast 0 == normal 1 == color*color" )
SHADER_PARAM( ENVMAPSATURATION, SHADER_PARAM_TYPE_FLOAT, "1.0", "saturation 0 == greyscale 1 == normal" )
SHADER_PARAM( FRESNELREFLECTION, SHADER_PARAM_TYPE_FLOAT, "1.0", "1.0 == mirror, 0.0 == water" )
SHADER_PARAM( ENVMAPOPTIONAL, SHADER_PARAM_TYPE_INTEGER, "90", "Do specular pass only on dxlevel or higher (ie.80, 81, 90)" )
SHADER_PARAM( NODIFFUSEBUMPLIGHTING, SHADER_PARAM_TYPE_BOOL, "0", "0 == Use diffuse bump lighting, 1 = No diffuse bump lighting" )
SHADER_PARAM( FORCEBUMP, SHADER_PARAM_TYPE_BOOL, "0", "0 == Do bumpmapping if the card says it can handle it. 1 == Always do bumpmapping." )
SHADER_PARAM( ALPHATESTREFERENCE, SHADER_PARAM_TYPE_FLOAT, "0.0", "" )
SHADER_PARAM( SSBUMP, SHADER_PARAM_TYPE_INTEGER, "0", "whether or not to use alternate bumpmap format with height" )
SHADER_PARAM( SEAMLESS_SCALE, SHADER_PARAM_TYPE_FLOAT, "0", "Scale factor for 'seamless' texture mapping. 0 means to use ordinary mapping" )
END_SHADER_PARAMS
virtual bool ShouldUseBumpmapping( IMaterialVar **params )
{
return g_pConfig->UseBumpmapping() && params[BUMPMAP]->IsDefined();
}
// Set up anything that is necessary to make decisions in SHADER_FALLBACK.
SHADER_INIT_PARAMS()
{
// FLASHLIGHTFIXME
params[FLASHLIGHTTEXTURE]->SetStringValue( "effects/flashlight001" );
// Write over $basetexture with $albedo if we are going to be using diffuse normal mapping.
if( ShouldUseBumpmapping( params ) && params[ALBEDO]->IsDefined() &&
params[BASETEXTURE]->IsDefined() &&
!( params[NODIFFUSEBUMPLIGHTING]->IsDefined() && params[NODIFFUSEBUMPLIGHTING]->GetIntValue() ) )
{
params[BASETEXTURE]->SetStringValue( params[ALBEDO]->GetStringValue() );
}
if( IsUsingGraphics() && params[ENVMAP]->IsDefined() && !CanUseEditorMaterials() )
{
if( stricmp( params[ENVMAP]->GetStringValue(), "env_cubemap" ) == 0 )
{
Warning( "env_cubemap used on world geometry without rebuilding map. . ignoring: %s\n", pMaterialName );
params[ENVMAP]->SetUndefined();
}
}
if( !params[ENVMAPMASKSCALE]->IsDefined() )
{
params[ENVMAPMASKSCALE]->SetFloatValue( 1.0f );
}
if( !params[ENVMAPTINT]->IsDefined() )
{
params[ENVMAPTINT]->SetVecValue( 1.0f, 1.0f, 1.0f );
}
if( !params[SELFILLUMTINT]->IsDefined() )
{
params[SELFILLUMTINT]->SetVecValue( 1.0f, 1.0f, 1.0f );
}
if( !params[DETAILSCALE]->IsDefined() )
{
params[DETAILSCALE]->SetFloatValue( 4.0f );
}
if( !params[DETAILBLENDFACTOR]->IsDefined() )
{
params[DETAILBLENDFACTOR]->SetFloatValue( 1.0f );
}
if( !params[FRESNELREFLECTION]->IsDefined() )
{
params[FRESNELREFLECTION]->SetFloatValue( 1.0f );
}
if( !params[ENVMAPMASKFRAME]->IsDefined() )
{
params[ENVMAPMASKFRAME]->SetIntValue( 0 );
}
if( !params[ENVMAPFRAME]->IsDefined() )
{
params[ENVMAPFRAME]->SetIntValue( 0 );
}
if( !params[BUMPFRAME]->IsDefined() )
{
params[BUMPFRAME]->SetIntValue( 0 );
}
if( !params[ENVMAPCONTRAST]->IsDefined() )
{
params[ENVMAPCONTRAST]->SetFloatValue( 0.0f );
}
if( !params[ENVMAPSATURATION]->IsDefined() )
{
params[ENVMAPSATURATION]->SetFloatValue( 1.0f );
}
if( !params[ALPHATESTREFERENCE]->IsDefined() )
{
params[ALPHATESTREFERENCE]->SetFloatValue( 0.0f );
}
// No texture means no self-illum or env mask in base alpha
if ( !params[BASETEXTURE]->IsDefined() )
{
CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM );
CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK );
}
// If in decal mode, no debug override...
if (IS_FLAG_SET(MATERIAL_VAR_DECAL))
{
SET_FLAGS( MATERIAL_VAR_NO_DEBUG_OVERRIDE );
}
SET_FLAGS2( MATERIAL_VAR2_LIGHTING_LIGHTMAP );
if( ShouldUseBumpmapping( params ) && (params[NODIFFUSEBUMPLIGHTING]->GetIntValue() == 0) )
{
SET_FLAGS2( MATERIAL_VAR2_LIGHTING_BUMPED_LIGHTMAP );
}
// Get rid of the envmap if it's optional for this dx level.
if( params[ENVMAPOPTIONAL]->IsDefined() && (params[ENVMAPOPTIONAL]->GetIntValue() > g_pHardwareConfig->GetDXSupportLevel()) )
{
params[ENVMAP]->SetUndefined();
}
// If mat_specular 0, then get rid of envmap
if( !g_pConfig->UseSpecular() && params[ENVMAP]->IsDefined() && params[BASETEXTURE]->IsDefined() )
{
params[ENVMAP]->SetUndefined();
}
if( params[SEAMLESS_SCALE]->IsDefined() && params[SEAMLESS_SCALE]->GetFloatValue() != 0.0f )
{
if( params[BUMPMAP]->IsDefined() )
{
Warning( "Can't use $bumpmap with $seamless_scale for lightmappedgeneric_dx8. Implicitly disabling $bumpmap: %s\n", pMaterialName );
params[BUMPMAP]->SetUndefined();
}
if( params[ENVMAP]->IsDefined() )
{
Warning( "Can't use $envmap with $seamless_scale for lightmappedgeneric_dx8. Implicitly disabling $envmap: %s\n", pMaterialName );
params[ENVMAP]->SetUndefined();
}
}
if ( !params[SEAMLESS_SCALE]->IsDefined() )
{
// zero means don't do seamless mapping.
params[SEAMLESS_SCALE]->SetFloatValue( 0.0f );
}
// Get rid of envmap if we aren't using bumpmapping
// *and* we have normalmapalphaenvmapmask *and* we don't have envmapmask elsewhere
if ( params[ENVMAP]->IsDefined() && params[BUMPMAP]->IsDefined() && IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ) && !ShouldUseBumpmapping( params ) )
{
if ( !IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) && !params[ENVMAPMASK]->IsDefined() )
{
params[ENVMAP]->SetUndefined();
}
}
}
SHADER_FALLBACK
{
if ( IsPC() && g_pHardwareConfig->GetDXSupportLevel() < 80)
return "LightmappedGeneric_DX6";
if ( IsPC() && g_pHardwareConfig->PreferReducedFillrate() )
return "LightmappedGeneric_NoBump_DX8";
return 0;
}
SHADER_INIT
{
LoadTexture( FLASHLIGHTTEXTURE );
if( ShouldUseBumpmapping( params ) )
{
LoadBumpMap( BUMPMAP );
}
if (params[BASETEXTURE]->IsDefined())
{
LoadTexture( BASETEXTURE );
if (!params[BASETEXTURE]->GetTextureValue()->IsTranslucent())
{
CLEAR_FLAGS( MATERIAL_VAR_SELFILLUM );
CLEAR_FLAGS( MATERIAL_VAR_BASEALPHAENVMAPMASK );
}
}
if (params[DETAIL]->IsDefined())
{
LoadTexture( DETAIL );
}
// Don't alpha test if the alpha channel is used for other purposes
if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM) || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) )
CLEAR_FLAGS( MATERIAL_VAR_ALPHATEST );
if (params[ENVMAP]->IsDefined())
{
if( !IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) )
LoadCubeMap( ENVMAP );
else
LoadTexture( ENVMAP );
if( !g_pHardwareConfig->SupportsCubeMaps() )
{
SET_FLAGS( MATERIAL_VAR_ENVMAPSPHERE );
}
if (params[ENVMAPMASK]->IsDefined())
LoadTexture( ENVMAPMASK );
}
if( ShouldUseBumpmapping( params ) )
{
SET_FLAGS2( MATERIAL_VAR2_NEEDS_TANGENT_SPACES );
}
}
#ifndef USE_HLSL_PIXEL_SHADERS
inline const char *GetPixelShaderName( IMaterialVar** params, bool bBumpedEnvMap )
{
static char const* s_pPixelShaders[] =
{
// Unmasked
"LightmappedGeneric_EnvMapV2",
"LightmappedGeneric_SelfIlluminatedEnvMapV2",
"LightmappedGeneric_BaseAlphaMaskedEnvMapV2",
"LightmappedGeneric_SelfIlluminatedEnvMapV2",
// Env map mask
"LightmappedGeneric_MaskedEnvMapV2",
"LightmappedGeneric_SelfIlluminatedMaskedEnvMapV2",
"LightmappedGeneric_MaskedEnvMapV2",
"LightmappedGeneric_SelfIlluminatedMaskedEnvMapV2",
};
if (!params[BASETEXTURE]->IsTexture())
{
if (params[ENVMAP]->IsTexture() && !bBumpedEnvMap )
{
if (!params[ENVMAPMASK]->IsDefined() )
{
return "LightmappedGeneric_EnvmapNoTexture";
}
else
{
return "LightmappedGeneric_MaskedEnvmapNoTexture";
}
}
else
{
return "LightmappedGeneric_NoTexture";
}
}
else
{
if (params[ENVMAP]->IsTexture() && !bBumpedEnvMap )
{
int pshIndex = 0;
if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM))
pshIndex |= 0x1;
if (IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK))
pshIndex |= 0x2;
if (params[ENVMAPMASK]->IsTexture())
pshIndex |= 0x4;
return s_pPixelShaders[pshIndex];
}
else
{
if (IS_FLAG_SET(MATERIAL_VAR_SELFILLUM))
return "LightmappedGeneric_SelfIlluminated";
else
return "LightmappedGeneric";
}
}
}
#endif
void DrawUnbumpedUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bBumpedEnvMap )
{
bool hasEnvmap = params[ENVMAP]->IsTexture() && !bBumpedEnvMap;
bool hasBaseTexture = params[BASETEXTURE]->IsTexture();
bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
bool hasEnvmapCameraSpace = IS_FLAG_SET( MATERIAL_VAR_ENVMAPCAMERASPACE );
bool hasEnvmapSphere = IS_FLAG_SET( MATERIAL_VAR_ENVMAPSPHERE );
if ( hasEnvmap || hasBaseTexture || hasVertexColor || !bBumpedEnvMap )
{
SHADOW_STATE
{
// Alpha test
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
if ( params[ALPHATESTREFERENCE]->GetFloatValue() > 0.0f )
{
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[ALPHATESTREFERENCE]->GetFloatValue() );
}
// Base texture on stage 0
if (params[BASETEXTURE]->IsTexture())
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
}
// Lightmap on stage 1
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
int fmt = VERTEX_POSITION;
if ( hasEnvmap )
{
fmt |= VERTEX_NORMAL;
// envmap on stage 2
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
// envmapmask on stage 3
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK ) )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
}
}
if (params[BASETEXTURE]->IsTexture() || bBumpedEnvMap)
{
SetDefaultBlendingShadowState( BASETEXTURE, true );
}
else
{
SetDefaultBlendingShadowState( ENVMAPMASK, false );
}
if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR))
{
fmt |= VERTEX_COLOR;
}
pShaderShadow->VertexShaderVertexFormat( fmt, 2, 0, 0 );
lightmappedgeneric_vs11_Static_Index vshIndex;
vshIndex.SetDETAIL( false );
vshIndex.SetENVMAP( hasEnvmap );
vshIndex.SetENVMAPCAMERASPACE( hasEnvmap && hasEnvmapCameraSpace );
vshIndex.SetENVMAPSPHERE( hasEnvmap && hasEnvmapSphere );
vshIndex.SetVERTEXCOLOR( hasVertexColor );
pShaderShadow->SetVertexShader( "LightmappedGeneric_vs11", vshIndex.GetIndex() );
const char *pshName = GetPixelShaderName( params, bBumpedEnvMap );
pShaderShadow->SetPixelShader( pshName );
DefaultFog();
}
DYNAMIC_STATE
{
if (hasBaseTexture)
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM );
}
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
if ( hasEnvmap )
{
BindTexture( SHADER_SAMPLER2, ENVMAP, ENVMAPFRAME );
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) )
{
if (params[ENVMAPMASK]->IsTexture() )
BindTexture( SHADER_SAMPLER3, ENVMAPMASK, ENVMAPMASKFRAME );
else
BindTexture( SHADER_SAMPLER3, BASETEXTURE, FRAME );
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, ENVMAPMASKSCALE );
}
if (IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) ||
IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE))
{
LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_VIEWMODEL );
}
SetEnvMapTintPixelShaderDynamicState( 2, ENVMAPTINT, -1 );
}
if ( !hasEnvmap || hasBaseTexture || hasVertexColor )
{
SetModulationVertexShaderDynamicState();
}
EnablePixelShaderOverbright( 0, true, true );
SetPixelShaderConstant( 1, SELFILLUMTINT );
lightmappedgeneric_vs11_Dynamic_Index vshIndex;
vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
}
Draw();
}
if ( bBumpedEnvMap )
{
DrawWorldBumpedSpecularLighting(
BUMPMAP, ENVMAP, BUMPFRAME, ENVMAPFRAME,
ENVMAPTINT, ALPHA, ENVMAPCONTRAST, ENVMAPSATURATION,
BUMPTRANSFORM, FRESNELREFLECTION,
hasEnvmap || hasBaseTexture || hasVertexColor );
}
}
void DrawDetailNoEnvmap( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool doSelfIllum )
{
SHADOW_STATE
{
// Alpha test
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
// Base texture on stage 0
if (params[BASETEXTURE]->IsTexture())
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
// Lightmap on stage 1
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
// Detail on stage 2
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
int fmt = VERTEX_POSITION;
SetDefaultBlendingShadowState( BASETEXTURE, true );
if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR))
fmt |= VERTEX_COLOR;
pShaderShadow->VertexShaderVertexFormat( fmt, 2, 0, 0 );
lightmappedgeneric_vs11_Static_Index vshIndex;
vshIndex.SetDETAIL( true );
vshIndex.SetENVMAP( false );
vshIndex.SetENVMAPCAMERASPACE( false );
vshIndex.SetENVMAPSPHERE( false );
vshIndex.SetVERTEXCOLOR( IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) );
pShaderShadow->SetVertexShader( "LightmappedGeneric_vs11", vshIndex.GetIndex() );
if (!params[BASETEXTURE]->IsTexture())
{
pShaderShadow->SetPixelShader("LightmappedGeneric_DetailNoTexture");
}
else
{
if (!IS_FLAG_SET(MATERIAL_VAR_SELFILLUM) || (!doSelfIllum))
{
pShaderShadow->SetPixelShader("LightmappedGeneric_Detail");
}
else
{
pShaderShadow->SetPixelShader("LightmappedGeneric_DetailSelfIlluminated");
}
}
DefaultFog();
}
DYNAMIC_STATE
{
if (params[BASETEXTURE]->IsTexture())
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM );
}
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
BindTexture( SHADER_SAMPLER2, DETAIL, FRAME );
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, BASETEXTURETRANSFORM, DETAILSCALE );
SetModulationVertexShaderDynamicState();
EnablePixelShaderOverbright( 0, true, true );
if (doSelfIllum)
{
SetPixelShaderConstant( 1, SELFILLUMTINT );
}
float c2[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
c2[0] = c2[1] = c2[2] = c2[3] = params[DETAILBLENDFACTOR]->GetFloatValue();
pShaderAPI->SetPixelShaderConstant( 2, c2, 1 );
lightmappedgeneric_vs11_Dynamic_Index vshIndex;
vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
}
Draw();
}
inline const char *GetAdditiveEnvmapPixelShaderName( bool usingMask,
bool usingBaseTexture, bool usingBaseAlphaEnvmapMask )
{
static char const* s_pPixelShaders[] =
{
"LightmappedGeneric_AddEnvmapNoTexture",
"LightmappedGeneric_AddEnvmapMaskNoTexture",
};
if ( !usingMask && usingBaseTexture && usingBaseAlphaEnvmapMask )
return "LightmappedGeneric_AddBaseAlphaMaskedEnvMap";
int pshIndex = 0;
if (usingMask)
pshIndex |= 0x1;
return s_pPixelShaders[pshIndex];
}
void DrawAdditiveEnvmap( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow )
{
bool usingBaseTexture = params[BASETEXTURE]->IsTexture();
bool usingMask = params[ENVMAPMASK]->IsTexture();
bool usingBaseAlphaEnvmapMask = IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK);
SHADOW_STATE
{
// Alpha test
pShaderShadow->EnableAlphaTest( false );
pShaderShadow->EnableTexture( SHADER_SAMPLER0, false );
pShaderShadow->EnableTexture( SHADER_SAMPLER1, false );
// envmap on stage 2
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
// envmapmask on stage 3
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK ) )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
}
if (params[BASETEXTURE]->IsTexture())
{
SetAdditiveBlendingShadowState( BASETEXTURE, true );
}
else
{
SetAdditiveBlendingShadowState( ENVMAPMASK, false );
}
int fmt = VERTEX_POSITION | VERTEX_NORMAL;
pShaderShadow->VertexShaderVertexFormat( fmt, 1, 0, 0 );
// Compute the vertex shader index.
lightmappedgeneric_vs11_Static_Index vshIndex;
vshIndex.SetDETAIL( false );
vshIndex.SetENVMAP( true );
vshIndex.SetENVMAPCAMERASPACE( IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE) );
vshIndex.SetENVMAPSPHERE( IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) );
vshIndex.SetVERTEXCOLOR( false );
s_pShaderShadow->SetVertexShader( "LightmappedGeneric_vs11", vshIndex.GetIndex() );
const char *pshName = GetAdditiveEnvmapPixelShaderName( usingMask,
usingBaseTexture, usingBaseAlphaEnvmapMask );
pShaderShadow->SetPixelShader( pshName );
FogToBlack();
}
DYNAMIC_STATE
{
BindTexture( SHADER_SAMPLER2, ENVMAP, ENVMAPFRAME );
if (usingMask || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK))
{
if (usingMask)
BindTexture( SHADER_SAMPLER3, ENVMAPMASK, ENVMAPMASKFRAME );
else
BindTexture( SHADER_SAMPLER3, BASETEXTURE, FRAME );
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, ENVMAPMASKSCALE );
}
SetPixelShaderConstant( 2, ENVMAPTINT );
if (IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) || IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE))
{
LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_VIEWMODEL );
}
SetModulationVertexShaderDynamicState();
// Compute the vertex shader index.
lightmappedgeneric_vs11_Dynamic_Index vshIndex;
vshIndex.SetDOWATERFOG( s_pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
s_pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
}
Draw();
}
void DrawDetailMode1( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bBumpedEnvMap )
{
// Mode 1 :
// Pass 1 : B * L * D + Self Illum
// Pass 2 : Add E * M
// Draw the detail w/ no envmap
DrawDetailNoEnvmap( params, pShaderAPI, pShaderShadow, true );
if ( !bBumpedEnvMap )
{
DrawAdditiveEnvmap( params, pShaderAPI, pShaderShadow );
}
else
{
DrawWorldBumpedSpecularLighting(
BUMPMAP, ENVMAP, BUMPFRAME, ENVMAPFRAME,
ENVMAPTINT, ALPHA, ENVMAPCONTRAST, ENVMAPSATURATION,
BUMPTRANSFORM, FRESNELREFLECTION,
true );
}
}
void DrawDetailUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bBumpedEnvMap )
{
// We don't have enough textures; gotta do this in two passes if there's envmapping
if (!params[ENVMAP]->IsTexture())
{
DrawDetailNoEnvmap( params, pShaderAPI, pShaderShadow, IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ) );
}
else
{
if (!params[BASETEXTURE]->IsTexture())
{
// If there's an envmap but no base texture, ignore detail
DrawUnbumpedUsingVertexShader( params, pShaderAPI, pShaderShadow, bBumpedEnvMap );
}
else
{
DrawDetailMode1( params, pShaderAPI, pShaderShadow, bBumpedEnvMap );
}
}
}
void DrawUnbumpedSeamlessUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow )
{
// This is the seamless_scale version, which doesn't use $detail or $bumpmap
SHADOW_STATE
{
// three copies of the base texture for seamless blending
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
// lightmap
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
int fmt = VERTEX_POSITION;
pShaderShadow->VertexShaderVertexFormat( fmt, 2, 0, 0 );
worldvertextransition_seamless_Static_Index vshIndex;
pShaderShadow->SetVertexShader( "WorldVertexTransition_Seamless", vshIndex.GetIndex() );
int pshIndex = 0;
pShaderShadow->SetPixelShader( "WorldVertexTransition_Seamless", pshIndex );
FogToFogColor();
}
DYNAMIC_STATE
{
bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE );
// Texture 0..2
if( bLightingOnly )
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY );
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_GREY );
pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_GREY );
}
else
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
BindTexture( SHADER_SAMPLER1, BASETEXTURE, FRAME );
BindTexture( SHADER_SAMPLER2, BASETEXTURE, FRAME );
}
// Texture 3 = lightmap
pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_LIGHTMAP );
EnablePixelShaderOverbright( 0, true, true );
float fSeamlessScale = params[SEAMLESS_SCALE]->GetFloatValue();
float map_scale[4]= { fSeamlessScale, fSeamlessScale, fSeamlessScale, fSeamlessScale };
pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, map_scale );
worldvertextransition_seamless_Dynamic_Index vshIndex;
vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
}
Draw();
}
SHADER_DRAW
{
bool hasFlashlight = UsingFlashlight( params );
bool bBump = ShouldUseBumpmapping( params ) && params[BUMPMAP]->IsTexture() &&
(params[NODIFFUSEBUMPLIGHTING]->GetIntValue() == 0);
bool bSSBump = bBump && ( params[SSBUMP]->GetIntValue() != 0 );
if( hasFlashlight )
{
DrawFlashlight_dx80( params, pShaderAPI, pShaderShadow, bBump, BUMPMAP, BUMPFRAME, BUMPTRANSFORM,
FLASHLIGHTTEXTURE, FLASHLIGHTTEXTUREFRAME, true, false, 0, -1, -1 );
}
else if( bBump )
{
DrawWorldBumpedUsingVertexShader(
BASETEXTURE, BASETEXTURETRANSFORM,
BUMPMAP, BUMPFRAME, BUMPTRANSFORM, ENVMAPMASK, ENVMAPMASKFRAME, ENVMAP,
ENVMAPFRAME, ENVMAPTINT, COLOR, ALPHA, ENVMAPCONTRAST, ENVMAPSATURATION, FRAME, FRESNELREFLECTION,
false, -1, -1, -1, bSSBump );
}
else
{
bool bBumpedEnvMap = ShouldUseBumpmapping( params ) && params[BUMPMAP]->IsTexture() && params[ENVMAP]->IsTexture();
if (!params[DETAIL]->IsTexture())
{
if( params[SEAMLESS_SCALE]->GetFloatValue() != 0.0f )
{
DrawUnbumpedSeamlessUsingVertexShader( params, pShaderAPI, pShaderShadow );
}
else
{
DrawUnbumpedUsingVertexShader( params, pShaderAPI, pShaderShadow, bBumpedEnvMap );
}
}
else
{
DrawDetailUsingVertexShader( params, pShaderAPI, pShaderShadow, bBumpedEnvMap );
}
}
}
END_SHADER
//-----------------------------------------------------------------------------
// Version that doesn't do bumpmapping
//-----------------------------------------------------------------------------
BEGIN_INHERITED_SHADER( LightmappedGeneric_NoBump_DX8, LightmappedGeneric_DX8,
"Help for LightmappedGeneric_NoBump_DX8" )
SHADER_FALLBACK
{
if (g_pHardwareConfig->GetDXSupportLevel() < 80)
return "LightmappedGeneric_DX6";
return 0;
}
virtual bool ShouldUseBumpmapping( IMaterialVar **params )
{
if ( !g_pConfig->UseBumpmapping() )
return false;
if ( !params[BUMPMAP]->IsDefined() )
return false;
return ( params[FORCEBUMP]->GetIntValue() != 0 );
}
END_INHERITED_SHADER