mirror of
https://github.com/celisej567/cool-source-archive.git
synced 2026-09-15 20:09:19 +03:00
545 lines
17 KiB
C
545 lines
17 KiB
C
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
// SKIP: $BUMPMAP2 && $WARPLIGHTING
|
|
// SKIP: $WARPLIGHTING && $DETAILTEXTURE
|
|
// SKIP: $ENVMAPMASK && $BUMPMAP
|
|
// SKIP: $NORMALMAPALPHAENVMAPMASK && $BASEALPHAENVMAPMASK
|
|
// SKIP: $NORMALMAPALPHAENVMAPMASK && $ENVMAPMASK
|
|
// SKIP: $BASEALPHAENVMAPMASK && $ENVMAPMASK
|
|
// SKIP: $BASEALPHAENVMAPMASK && $SELFILLUM
|
|
// SKIP: !$FASTPATH && $FASTPATHENVMAPCONTRAST
|
|
// SKIP: !$FASTPATH && $FASTPATHENVMAPTINT
|
|
// SKIP: !$BUMPMAP && $DIFFUSEBUMPMAP
|
|
// SKIP: !$BUMPMAP && $BUMPMAP2
|
|
// SKIP: $ENVMAPMASK && $BUMPMAP2
|
|
// SKIP: $BASETEXTURENOENVMAP && ( !$BASETEXTURE2 || !$CUBEMAP )
|
|
// SKIP: $BASETEXTURE2NOENVMAP && ( !$BASETEXTURE2 || !$CUBEMAP )
|
|
// SKIP: $BASEALPHAENVMAPMASK && $BUMPMAP
|
|
// SKIP: $PARALLAXMAP && $DETAILTEXTURE
|
|
// SKIP: $SEAMLESS && $RELIEF_MAPPING
|
|
// SKIP: $SEAMLESS && $DETAILTEXTURE
|
|
// SKIP: $SEAMLESS && $MASKEDBLENDING
|
|
// SKIP: $BUMPMASK && ( $SEAMLESS || $DETAILTEXTURE || $SELFILLUM || $BASETEXTURENOENVMAP || $BASETEXTURE2 )
|
|
// SKIP: !$BUMPMAP && ($NORMAL_DECODE_MODE == 1)
|
|
// SKIP: !$BUMPMAP && ($NORMAL_DECODE_MODE == 2)
|
|
// SKIP: !$BUMPMAP && ($NORMALMASK_DECODE_MODE == 1)
|
|
// SKIP: !$BUMPMAP && ($NORMALMASK_DECODE_MODE == 2)
|
|
// NOSKIP: $FANCY_BLENDING && (!$FASTPATH)
|
|
|
|
// debug crap:
|
|
// NOSKIP: $DETAILTEXTURE
|
|
// NOSKIP: $CUBEMAP
|
|
// NOSKIP: $ENVMAPMASK
|
|
// NOSKIP: $BASEALPHAENVMAPMASK
|
|
// NOSKIP: $SELFILLUM
|
|
|
|
#define USE_32BIT_LIGHTMAPS_ON_360 //uncomment to use 32bit lightmaps, be sure to keep this in sync with the same #define in materialsystem/cmatlightmaps.cpp
|
|
|
|
// Define the common constant buffers we will use
|
|
#include "common_cbuffers_def_noskinning_fxc.h"
|
|
|
|
#include "common_ps_fxc.h"
|
|
#include "common_flashlight_fxc.h"
|
|
#include "common_lightmappedgeneric_fxc.h"
|
|
#include "lightmappedgeneric_dx11_shared_fxc.h"
|
|
|
|
#if SEAMLESS
|
|
#define USE_FAST_PATH 1
|
|
#else
|
|
#define USE_FAST_PATH FASTPATH
|
|
#endif
|
|
|
|
cbuffer LightmappedGeneric_PS : register( b3 )
|
|
{
|
|
LightmappedGeneric_t c;
|
|
};
|
|
|
|
#define g_OutlineParams c.g_OutlineParamsAndColor[0]
|
|
#define g_OutlineColor c.g_OutlineParamsAndColor[1]
|
|
|
|
#if USE_FAST_PATH == 1
|
|
|
|
#if FASTPATHENVMAPCONTRAST == 0
|
|
static const float3 g_EnvmapContrast = { 0.0f, 0.0f, 0.0f };
|
|
#else
|
|
static const float3 g_EnvmapContrast = { 1.0f, 1.0f, 1.0f };
|
|
#endif
|
|
static const float3 g_EnvmapSaturation = { 1.0f, 1.0f, 1.0f };
|
|
static const float g_FresnelReflection = 1.0f;
|
|
static const float g_OneMinusFresnelReflection = 0.0f;
|
|
static const float4 g_SelfIllumTint = { 1.0f, 1.0f, 1.0f, 1.0f };
|
|
#if OUTLINE
|
|
#define OUTLINE_MIN_VALUE0 g_OutlineParams.x
|
|
#define OUTLINE_MIN_VALUE1 g_OutlineParams.y
|
|
#define OUTLINE_MAX_VALUE0 g_OutlineParams.z
|
|
#define OUTLINE_MAX_VALUE1 g_OutlineParams.w
|
|
#define OUTLINE_COLOR g_OutlineColor
|
|
#endif
|
|
#if SOFTEDGES
|
|
#define SOFT_MASK_MIN g_EdgeSoftnessParms.x
|
|
#define SOFT_MASK_MAX g_EdgeSoftnessParms.y
|
|
#endif
|
|
#else
|
|
#define g_EnvmapContrast c.cEnvmapContrast.xyz
|
|
#define g_EnvmapSaturation c.cEnvmapSaturation.xyz
|
|
#define g_SelfIllumTint c.cSelfIllumTint
|
|
#define g_FresnelReflection c.cFresnelReflection.a
|
|
#define g_OneMinusFresnelReflection c.cFresnelReflection.b
|
|
#endif
|
|
|
|
#define g_DetailTint (c.g_DetailTint_and_BlendFactor.rgb)
|
|
#define g_DetailBlendFactor (c.g_DetailTint_and_BlendFactor.w)
|
|
|
|
#define g_flAlpha2 c.g_TintValuesAndLightmapScale.w
|
|
#define g_EyePos cEyePos.xyz
|
|
|
|
Texture2D BaseTexture : register( t0 );
|
|
sampler BaseTextureSampler : register( s0 );
|
|
|
|
Texture2D LightmapTexture : register( t1 );
|
|
sampler LightmapSampler : register( s1 );
|
|
|
|
#if CUBEMAP
|
|
TextureCube EnvmapTexture : register( t4 );
|
|
sampler EnvmapSampler : register( s4 );
|
|
#endif
|
|
|
|
#if FANCY_BLENDING
|
|
Texture2D BlendModulationTexture : register( t8 );
|
|
sampler BlendModulationSampler : register( s8 );
|
|
#endif
|
|
|
|
#if DETAILTEXTURE
|
|
Texture2D DetailTexture : register( t2 );
|
|
sampler DetailSampler : register( s2 );
|
|
#endif
|
|
|
|
#if BUMPMAP
|
|
Texture2D BumpmapTexture : register( t3 );
|
|
sampler BumpmapSampler : register( s3 );
|
|
#else
|
|
#define BumpmapTexture BaseTexture
|
|
#define BumpmapSampler BaseTextureSampler
|
|
#endif
|
|
|
|
#if BUMPMAP2 == 1
|
|
Texture2D BumpmapTexture2 : register( t5 );
|
|
sampler BumpmapSampler2 : register( s5 );
|
|
#elif ENVMAPMASK == 1
|
|
Texture2D EnvmapMaskTexture : register( t5 );
|
|
sampler EnvmapMaskSampler : register( s5 );
|
|
#endif
|
|
|
|
#if WARPLIGHTING
|
|
Texture2D WarpLightingTexture : register( t7 );
|
|
sampler WarpLightingSampler : register( s7 );
|
|
#endif
|
|
|
|
#if BASETEXTURE2
|
|
Texture2D BaseTexture2 : register( t6 );
|
|
sampler BaseTextureSampler2 : register( s6 );
|
|
#else
|
|
#define BaseTexture2 BaseTexture
|
|
#define BaseTextureSampler2 BaseTextureSampler
|
|
#endif
|
|
|
|
#if BUMPMASK == 1
|
|
Texture2D BumpMaskTexture : register( t9 );
|
|
sampler BumpMaskSampler : register( s9 );
|
|
#endif
|
|
|
|
struct PS_INPUT
|
|
{
|
|
float4 projPos : SV_POSITION;
|
|
float4 vertexColor : COLOR;
|
|
#if SEAMLESS
|
|
float4 SeamlessTexCoord_VertexBlend : TEXCOORD0; // zy xz
|
|
#else
|
|
float3 baseTexCoord_VertexBlend : TEXCOORD0;
|
|
#endif
|
|
float4 detailOrBumpAndEnvmapMaskTexCoord : TEXCOORD1;
|
|
float4 lightmapTexCoord1And2 : TEXCOORD2;
|
|
float4 lightmapTexCoord3 : TEXCOORD3;
|
|
float4 worldPos_projPosZ : TEXCOORD4;
|
|
|
|
#if CUBEMAP || (LIGHTING_PREVIEW)
|
|
float3x3 tangentSpaceTranspose : TEXCOORD5;
|
|
// tangentSpaceTranspose : TEXCOORD6
|
|
// tangentSpaceTranspose : TEXCOORD7
|
|
#endif
|
|
|
|
float3 eyePos : COLOR1;
|
|
};
|
|
|
|
float4 main( PS_INPUT i ) : SV_TARGET
|
|
{
|
|
bool bBaseTexture2 = BASETEXTURE2 ? true : false;
|
|
bool bDetailTexture = DETAILTEXTURE ? true : false;
|
|
bool bBumpmap = BUMPMAP ? true : false;
|
|
bool bDiffuseBumpmap = DIFFUSEBUMPMAP ? true : false;
|
|
bool bCubemap = CUBEMAP ? true : false;
|
|
bool bEnvmapMask = ENVMAPMASK ? true : false;
|
|
bool bBaseAlphaEnvmapMask = BASEALPHAENVMAPMASK ? true : false;
|
|
bool bSelfIllum = SELFILLUM ? true : false;
|
|
bool bNormalMapAlphaEnvmapMask = NORMALMAPALPHAENVMAPMASK ? true : false;
|
|
bool bBaseTextureNoEnvmap = BASETEXTURENOENVMAP ? true : false;
|
|
bool bBaseTexture2NoEnvmap = BASETEXTURE2NOENVMAP ? true : false;
|
|
|
|
float4 baseColor = 0.0f;
|
|
float4 baseColor2 = 0.0f;
|
|
float4 vNormal = float4( 0, 0, 1, 1 );
|
|
float3 baseTexCoords = float3( 0,0,0 );
|
|
|
|
#if SEAMLESS
|
|
baseTexCoords = i.SeamlessTexCoord_VertexBlend.xyz;
|
|
#else
|
|
baseTexCoords.xy = i.baseTexCoord_VertexBlend.xy;
|
|
#endif
|
|
|
|
GetBaseTextureAndNormal( BaseTexture, BaseTextureSampler, BaseTexture2, BaseTextureSampler2,
|
|
BumpmapTexture, BumpmapSampler, bBaseTexture2, bBumpmap || bNormalMapAlphaEnvmapMask,
|
|
baseTexCoords, i.vertexColor.rgb, baseColor, baseColor2, vNormal );
|
|
|
|
#if BUMPMAP == 1 // not ssbump
|
|
vNormal.xyz = vNormal.xyz * 2.0f - 1.0f; // make signed if we're not ssbump
|
|
#endif
|
|
|
|
float3 lightmapColor1 = float3( 1.0f, 1.0f, 1.0f );
|
|
float3 lightmapColor2 = float3( 1.0f, 1.0f, 1.0f );
|
|
float3 lightmapColor3 = float3( 1.0f, 1.0f, 1.0f );
|
|
#if LIGHTING_PREVIEW == 0
|
|
if ( bBumpmap && bDiffuseBumpmap )
|
|
{
|
|
float2 bumpCoord1;
|
|
float2 bumpCoord2;
|
|
float2 bumpCoord3;
|
|
ComputeBumpedLightmapCoordinates( i.lightmapTexCoord1And2, i.lightmapTexCoord3.xy,
|
|
bumpCoord1, bumpCoord2, bumpCoord3 );
|
|
|
|
lightmapColor1 = LightMapSample( LightmapTexture, LightmapSampler, bumpCoord1 );
|
|
lightmapColor2 = LightMapSample( LightmapTexture, LightmapSampler, bumpCoord2 );
|
|
lightmapColor3 = LightMapSample( LightmapTexture, LightmapSampler, bumpCoord3 );
|
|
}
|
|
else
|
|
{
|
|
float2 bumpCoord1 = ComputeLightmapCoordinates( i.lightmapTexCoord1And2, i.lightmapTexCoord3.xy );
|
|
lightmapColor1 = LightMapSample( LightmapTexture, LightmapSampler, bumpCoord1 );
|
|
}
|
|
#endif
|
|
|
|
#if RELIEF_MAPPING
|
|
// in the parallax case, all texcoords must be the same in order to free
|
|
// up an iterator for the tangent space view vector
|
|
float2 detailTexCoord = i.baseTexCoord_VertexBlend.xy;
|
|
float2 bumpmapTexCoord = i.baseTexCoord_VertexBlend.xy;
|
|
float2 envmapMaskTexCoord = i.baseTexCoord_VertexBlend.xy;
|
|
#else
|
|
|
|
#if ( DETAILTEXTURE == 1 )
|
|
float2 detailTexCoord = i.detailOrBumpAndEnvmapMaskTexCoord.xy;
|
|
float2 bumpmapTexCoord = i.baseTexCoord_VertexBlend.xy;
|
|
#elif ( BUMPMASK == 1 )
|
|
float2 detailTexCoord = 0.0f;
|
|
float2 bumpmapTexCoord = i.detailOrBumpAndEnvmapMaskTexCoord.xy;
|
|
float2 bumpmap2TexCoord = i.detailOrBumpAndEnvmapMaskTexCoord.wz;
|
|
#else
|
|
float2 detailTexCoord = 0.0f;
|
|
float2 bumpmapTexCoord = i.detailOrBumpAndEnvmapMaskTexCoord.xy;
|
|
#endif
|
|
|
|
float2 envmapMaskTexCoord = i.detailOrBumpAndEnvmapMaskTexCoord.wz;
|
|
#endif // !RELIEF_MAPPING
|
|
|
|
float4 detailColor = float4( 1.0f, 1.0f, 1.0f, 1.0f );
|
|
#if DETAILTEXTURE
|
|
|
|
detailColor = float4( g_DetailTint, 1.0f ) * DetailTexture.Sample( DetailSampler, detailTexCoord );
|
|
|
|
#endif
|
|
|
|
#if ( OUTLINE || SOFTEDGES )
|
|
float distAlphaMask = baseColor.a;
|
|
|
|
# if OUTLINE
|
|
if ( ( distAlphaMask >= OUTLINE_MIN_VALUE0 ) &&
|
|
( distAlphaMask <= OUTLINE_MAX_VALUE1 ) )
|
|
{
|
|
float oFactor = 1.0;
|
|
if ( distAlphaMask <= OUTLINE_MIN_VALUE1 )
|
|
{
|
|
oFactor = smoothstep( OUTLINE_MIN_VALUE0, OUTLINE_MIN_VALUE1, distAlphaMask );
|
|
}
|
|
else
|
|
{
|
|
oFactor = smoothstep( OUTLINE_MAX_VALUE1, OUTLINE_MAX_VALUE0, distAlphaMask );
|
|
}
|
|
baseColor = lerp( baseColor, OUTLINE_COLOR, oFactor );
|
|
}
|
|
# endif
|
|
# if SOFTEDGES
|
|
baseColor.a *= smoothstep( SOFT_MASK_MAX, SOFT_MASK_MIN, distAlphaMask );
|
|
# else
|
|
baseColor.a *= distAlphaMask >= 0.5;
|
|
# endif
|
|
#endif
|
|
|
|
|
|
//#if LIGHTING_PREVIEW == 2
|
|
// baseColor.xyz = GammaToLinear( baseColor.xyz );
|
|
//#endif
|
|
|
|
float blendedAlpha = baseColor.a;
|
|
|
|
#if MASKEDBLENDING
|
|
float blendfactor = 0.5;
|
|
#elif SEAMLESS
|
|
float blendfactor = i.SeamlessTexCoord_VertexBlend.w;
|
|
#else
|
|
float blendfactor = i.baseTexCoord_VertexBlend.z;
|
|
#endif
|
|
|
|
if ( bBaseTexture2 )
|
|
{
|
|
#if (SELFILLUM == 0) && (PIXELFOGTYPE != PIXEL_FOG_TYPE_HEIGHT) && (FANCY_BLENDING)
|
|
float4 modt = BlendModulationTexture.Sample( BlendModulationSampler,i.lightmapTexCoord3.zw );
|
|
#if MASKEDBLENDING
|
|
// FXC is unable to optimize this, despite blendfactor=0.5 above
|
|
//float minb=modt.g-modt.r;
|
|
//float maxb=modt.g+modt.r;
|
|
//blendfactor=smoothstep(minb,maxb,blendfactor);
|
|
//blendfactor=modt.g;
|
|
float minb = modt.g - modt.r;
|
|
float maxb = modt.g + modt.r;
|
|
#else
|
|
float minb = max( 0,modt.g - modt.r );
|
|
float maxb = min( 1,modt.g + modt.r );
|
|
//float minb=saturate(modt.g-modt.r);
|
|
//float maxb=saturate(modt.g+modt.r);
|
|
#endif
|
|
blendfactor = smoothstep( minb,maxb,blendfactor );
|
|
//#endif
|
|
#endif
|
|
//baseColor.rgb = lerp( baseColor.rgb, baseColor2.rgb, blendfactor );
|
|
baseColor.rgb = lerp( baseColor, baseColor2.rgb, blendfactor );
|
|
blendedAlpha = lerp( baseColor.a, baseColor2.a, blendfactor );
|
|
}
|
|
|
|
float3 specularFactor = 1.0f;
|
|
float4 vNormalMask = float4( 0, 0, 1, 1 );
|
|
if ( bBumpmap )
|
|
{
|
|
if ( bBaseTextureNoEnvmap )
|
|
{
|
|
vNormal.a = 0.0f;
|
|
}
|
|
|
|
#if ( BUMPMAP2 == 1 )
|
|
{
|
|
#if ( BUMPMASK == 1 )
|
|
float2 b2TexCoord = bumpmap2TexCoord;
|
|
#else
|
|
float2 b2TexCoord = bumpmapTexCoord;
|
|
#endif
|
|
|
|
float4 vNormal2;
|
|
if ( BUMPMAP == 2 )
|
|
vNormal2 = BumpmapTexture2.Sample( BumpmapSampler2, b2TexCoord );
|
|
else
|
|
vNormal2 = DecompressNormal( BumpmapTexture2, BumpmapSampler2, b2TexCoord,
|
|
NORMAL_DECODE_MODE, BumpmapTexture2, BumpmapSampler2 ); // Bump 2 coords
|
|
|
|
if ( bBaseTexture2NoEnvmap )
|
|
{
|
|
vNormal2.a = 0.0f;
|
|
}
|
|
|
|
#if ( BUMPMASK == 1 )
|
|
float3 vNormal1 = DecompressNormal( BumpmapTexture, BumpmapSampler,
|
|
i.detailOrBumpAndEnvmapMaskTexCoord.xy,
|
|
NORMALMASK_DECODE_MODE, BumpmapTexture, BumpmapSampler );
|
|
|
|
vNormal.xyz = normalize( vNormal1.xyz + vNormal2.xyz );
|
|
|
|
// Third normal map...same coords as base
|
|
vNormalMask = DecompressNormal( BumpMaskTexture, BumpMaskSampler, i.baseTexCoord_VertexBlend.xy,
|
|
NORMALMASK_DECODE_MODE, BumpMaskTexture, BumpMaskSampler );
|
|
|
|
vNormal.xyz = lerp( vNormalMask.xyz, vNormal.xyz, vNormalMask.a ); // Mask out normals from vNormal
|
|
specularFactor = vNormalMask.a;
|
|
#else // BUMPMASK == 0
|
|
if ( FANCY_BLENDING && bNormalMapAlphaEnvmapMask )
|
|
{
|
|
vNormal = lerp( vNormal, vNormal2, blendfactor );
|
|
}
|
|
else
|
|
{
|
|
vNormal.xyz = lerp( vNormal.xyz, vNormal2.xyz, blendfactor );
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif // BUMPMAP2 == 1
|
|
|
|
if ( bNormalMapAlphaEnvmapMask )
|
|
{
|
|
specularFactor *= vNormal.a;
|
|
}
|
|
}
|
|
else if ( bNormalMapAlphaEnvmapMask )
|
|
{
|
|
specularFactor *= vNormal.a;
|
|
}
|
|
|
|
#if ( BUMPMAP2 == 0 )
|
|
#if ENVMAPMASK
|
|
{
|
|
specularFactor *= EnvmapMaskTexture.Sample( EnvmapMaskSampler, envmapMaskTexCoord ).xyz;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
if ( bBaseAlphaEnvmapMask )
|
|
{
|
|
specularFactor *= 1.0 - blendedAlpha; // Reversing alpha blows!
|
|
}
|
|
float4 albedo = float4( 1.0f, 1.0f, 1.0f, 1.0f );
|
|
float alpha = 1.0f;
|
|
albedo *= baseColor;
|
|
if ( !bBaseAlphaEnvmapMask && !bSelfIllum )
|
|
{
|
|
alpha *= baseColor.a;
|
|
}
|
|
|
|
if ( bDetailTexture )
|
|
{
|
|
albedo = TextureCombine( albedo, detailColor, c.g_DetailBlendMode.x, g_DetailBlendFactor );
|
|
}
|
|
|
|
// The vertex color contains the modulation color + vertex color combined
|
|
#if ( SEAMLESS == 0 )
|
|
albedo.xyz *= i.vertexColor.xyz;
|
|
#endif
|
|
alpha *= i.vertexColor.a * g_flAlpha2; // not sure about this one
|
|
|
|
// Save this off for single-pass flashlight, since we'll still need the SSBump vector, not a real normal
|
|
float3 vSSBumpVector = vNormal.xyz;
|
|
|
|
float3 diffuseLighting;
|
|
if ( bBumpmap && bDiffuseBumpmap )
|
|
{
|
|
// ssbump
|
|
#if ( BUMPMAP == 2 )
|
|
diffuseLighting = vNormal.x * lightmapColor1 +
|
|
vNormal.y * lightmapColor2 +
|
|
vNormal.z * lightmapColor3;
|
|
diffuseLighting *= c.g_TintValuesAndLightmapScale.rgb;
|
|
|
|
// now, calculate vNormal for reflection purposes. if vNormal isn't needed, hopefully
|
|
// the compiler will eliminate these calculations
|
|
vNormal.xyz = normalize( bumpBasis[0] * vNormal.x + bumpBasis[1] * vNormal.y + bumpBasis[2] * vNormal.z );
|
|
#else
|
|
float3 dp;
|
|
dp.x = saturate( dot( vNormal.xyz, bumpBasis[0] ) );
|
|
dp.y = saturate( dot( vNormal.xyz, bumpBasis[1] ) );
|
|
dp.z = saturate( dot( vNormal.xyz, bumpBasis[2] ) );
|
|
dp *= dp;
|
|
|
|
if ( c.g_DetailBlendMode.x == TCOMBINE_SSBUMP_BUMP )
|
|
dp *= 2 * detailColor;
|
|
|
|
diffuseLighting = dp.x * lightmapColor1 +
|
|
dp.y * lightmapColor2 +
|
|
dp.z * lightmapColor3;
|
|
float sum = dot( dp, float3( 1.0f, 1.0f, 1.0f ) );
|
|
diffuseLighting *= c.g_TintValuesAndLightmapScale.xyz / sum;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
diffuseLighting = lightmapColor1 * c.g_TintValuesAndLightmapScale.xyz;
|
|
}
|
|
|
|
#if WARPLIGHTING && ( SEAMLESS == 0 )
|
|
float len = 0.5 * length( diffuseLighting );
|
|
// FIXME: 8-bit lookup textures like this need a "nice filtering" VTF option, which converts
|
|
// them to 16-bit on load or does filtering in the shader (since most hardware - 360
|
|
// included - interpolates 8-bit textures at 8-bit precision, which causes banding)
|
|
diffuseLighting *= 2.0 * WarpLightingTexture.Sample( WarpLightingSampler,float2( len,0 ) );
|
|
#endif
|
|
|
|
#if CUBEMAP || LIGHTING_PREVIEW
|
|
float3 worldSpaceNormal = mul( vNormal.xyz, i.tangentSpaceTranspose );
|
|
#endif
|
|
float3 diffuseComponent = albedo.xyz * diffuseLighting;
|
|
//return float4( diffuseLighting, 1.0f );
|
|
|
|
if ( bSelfIllum )
|
|
{
|
|
float3 selfIllumComponent = g_SelfIllumTint.xyz * albedo.xyz;
|
|
diffuseComponent = lerp( diffuseComponent, selfIllumComponent, baseColor.a );
|
|
}
|
|
|
|
float3 specularLighting = float3( 0.0f, 0.0f, 0.0f );
|
|
#if CUBEMAP
|
|
if ( bCubemap )
|
|
{
|
|
float3 worldVertToEyeVector = g_EyePos - i.worldPos_projPosZ.xyz;
|
|
float3 reflectVect = CalcReflectionVectorUnnormalized( worldSpaceNormal, worldVertToEyeVector );
|
|
//return float4( reflectVect, 1.0f );
|
|
|
|
// Calc Fresnel factor
|
|
half3 eyeVect = normalize( worldVertToEyeVector );
|
|
float fresnel = 1.0 - dot( worldSpaceNormal, eyeVect );
|
|
fresnel = pow( fresnel, 5.0 );
|
|
fresnel = fresnel * g_OneMinusFresnelReflection + g_FresnelReflection;
|
|
|
|
//return float4( specularFactor, 1.0f );
|
|
|
|
specularLighting = ENV_MAP_SCALE * EnvmapTexture.Sample( EnvmapSampler, reflectVect ).rgb;
|
|
//return float4( specularLighting, 1.0f );
|
|
specularLighting *= specularFactor;
|
|
|
|
specularLighting *= c.g_EnvmapTint.rgb;
|
|
//return float4( c.g_EnvmapTint.rgb, 1.0f );
|
|
#if FANCY_BLENDING == 0
|
|
float3 specularLightingSquared = specularLighting * specularLighting;
|
|
specularLighting = lerp( specularLighting, specularLightingSquared, g_EnvmapContrast );
|
|
float3 greyScale = dot( specularLighting, float3( 0.299f, 0.587f, 0.114f ) );
|
|
specularLighting = lerp( greyScale, specularLighting, g_EnvmapSaturation );
|
|
#endif
|
|
specularLighting *= fresnel;
|
|
|
|
//return float4( specularLighting, 1.0f );
|
|
}
|
|
#endif
|
|
|
|
float3 result = diffuseComponent + specularLighting;
|
|
|
|
#if ALPHATEST
|
|
if ( !GreaterEqualAlphaTest( alpha, c.g_AlphaTestRef ) )
|
|
discard;
|
|
#endif
|
|
|
|
bool bWriteDepthToAlpha = false;
|
|
|
|
// ps_2_b and beyond
|
|
#if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0))
|
|
bWriteDepthToAlpha = ( WRITE_DEPTH_TO_DESTALPHA != 0 ) && ( WRITEWATERFOGTODESTALPHA == 0 );
|
|
#endif
|
|
|
|
float fogFactor = CalcPixelFogFactor( PIXELFOGTYPE, c.g_FogParams, cEyePos.z, i.worldPos_projPosZ.z, length( i.eyePos ) );
|
|
#if WRITEWATERFOGTODESTALPHA && (PIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT)
|
|
alpha = fogFactor;
|
|
#endif
|
|
|
|
#if ALPHATEST
|
|
if ( !GreaterEqualAlphaTest( alpha, c.g_AlphaTestRef ) )
|
|
discard;
|
|
#endif
|
|
|
|
return FinalOutput( float4( result.rgb, alpha ), fogFactor, PIXELFOGTYPE, c.g_FogColor,
|
|
TONEMAP_SCALE_LINEAR, cToneMappingScale, bWriteDepthToAlpha, i.worldPos_projPosZ.w );
|
|
}
|
|
|