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.
 
 
 
 
 
 

201 lines
9.1 KiB

//====== Copyright © 1996-2005, Valve Corporation, All rights reserved. =======
//
// Purpose:
//
//=============================================================================
// STATIC: "CONVERT_TO_SRGB" "0..1" [ps20b][= g_pHardwareConfig->NeedsShaderSRGBConversion()] [PC]
// STATIC: "CONVERT_TO_SRGB" "0..1" [ps30][= g_pHardwareConfig->NeedsShaderSRGBConversion()] [PC]
// STATIC: "CONVERT_TO_SRGB" "0..0" [= 0] [XBOX]
// STATIC: "LIGHTWARPTEXTURE" "0..1"
// DYNAMIC: "PIXELFOGTYPE" "0..1"
// DYNAMIC: "WRITEWATERFOGTODESTALPHA" "0..1"
// DYNAMIC: "NUM_LIGHTS" "0..2" [ps20]
// DYNAMIC: "NUM_LIGHTS" "0..4" [ps20b]
// DYNAMIC: "NUM_LIGHTS" "0..4" [ps30]
#include "shader_constant_register_map.h"
sampler BaseSampler : register( s0 ); // Base map
sampler DiffuseWarpSampler : register( s1 ); // 1D texture for diffuse lighting modification
sampler RefractSampler : register( s2 ); // Refraction map copied from back buffer
sampler NormalSampler : register( s3 ); // Normal map
sampler SpecExponentSampler : register( s4 ); // Flashlight cookie
sampler NormalizeSampler : register( s5 ); // Normalization cube map
const float3x3 g_ViewProj : register( c0 ); // 1st row of Projection matrix
// c1 // 2nd row
// c2 // 4th row
const float2 g_CloakControl : register( c3 ); // { refract amount, cloak, ?, ? }
const float3 cAmbientCube[6] : register( PSREG_AMBIENT_CUBE );
const float4 g_EyePos_SpecExponent : register( PSREG_EYEPOS_SPEC_EXPONENT );
const float4 g_FogParams : register( PSREG_FOG_PARAMS );
const float4 g_FlashlightAttenuationFactors_RimMask : register( PSREG_FLASHLIGHT_ATTENUATION ); // On non-flashlight pass, x has rim mask control
const float4 g_RimBoost : register( PSREG_FLASHLIGHT_POSITION_RIM_BOOST );
const float4 g_FresnelSpecParams : register( PSREG_FRESNEL_SPEC_PARAMS ); // xyz are fresnel, w is specular boost
const float4 g_SpecularRimParams : register( PSREG_SPEC_RIM_PARAMS ); // xyz are specular tint color, w is rim power
PixelShaderLightInfo cLightInfo[3] : register( PSREG_LIGHT_INFO_ARRAY ); // 2 registers each - 6 registers total
#define g_fRimBoost g_RimBoost.w
#define g_FresnelRanges g_FresnelSpecParams.xyz
#define g_SpecularBoost g_FresnelSpecParams.w
#define g_SpecularTint g_SpecularRimParams.xyz
#define g_RimExponent g_SpecularRimParams.w
#define g_FlashlightAttenuationFactors g_FlashlightAttenuationFactors_RimMask
#define g_RimMaskControl g_FlashlightAttenuationFactors_RimMask.x
// 8 2D Poisson offsets (designed to use .xy and .wz swizzles (not .zw)
static const float4 gPoissonOffset[4] = { float4 (-0.0876f, 0.9703f, 0.5651f, 0.4802f ),
float4 ( 0.1851f, 0.1580f, -0.0617f, -0.2616f ),
float4 (-0.5477f, -0.6603f, 0.0711f, -0.5325f ),
float4 (-0.0751f, -0.8954f, 0.4054f, 0.6384f ) };
struct PS_INPUT
{
float2 vBaseTexCoord : TEXCOORD0;
float3x3 tangentSpaceTranspose : TEXCOORD1;
// second row : TEXCOORD2;
// third row : TEXCOORD3;
float3 worldPos : TEXCOORD4;
float3 projPos : TEXCOORD5;
float4 lightAtten : TEXCOORD6;
};
float4 main( PS_INPUT i ) : COLOR
{
float3 vSpecular = float3( 0.0f, 0.0f, 0.0f );
bool bDoDiffuseWarp = LIGHTWARPTEXTURE ? true : false;
int nNumLights = NUM_LIGHTS;
// Base color
float4 albedo = tex2D( BaseSampler, i.vBaseTexCoord );
// Load normal and expand range
float4 vNormalSample = tex2D( NormalSampler, i.vBaseTexCoord );
float3 tangentSpaceNormal = 2.0f * vNormalSample.xyz - 1.0f;
// We need a world space normal if we're doing any lighting
float3 vWorldNormal = normalize( mul( i.tangentSpaceTranspose, tangentSpaceNormal ) );
float3 vWorldEyeDir = normalize( g_EyePos_SpecExponent.xyz - i.worldPos );
// Vanilla 1-(N.V) fresnel term used later in transition lerp
float fresnel = 1-saturate( dot( vWorldNormal, vWorldEyeDir ) );
// Summation of diffuse illumination from all local lights
float3 diffuseLighting = PixelShaderDoLighting( i.worldPos, vWorldNormal,
float3( 0.0f, 0.0f, 0.0f ), false,
true, i.lightAtten, cAmbientCube, NormalizeSampler,
nNumLights, cLightInfo, true, false, 1.0f,
bDoDiffuseWarp, DiffuseWarpSampler );
// Transform world space normal into clip space and project
float2 vProjNormal;
vProjNormal.x = dot( vWorldNormal, g_ViewProj[0] ); // 1st row
vProjNormal.y = dot( vWorldNormal, g_ViewProj[1] ); // 2nd row
// Compute coordinates for sampling refraction
float2 vRefractTexCoordNoWarp = i.projPos.xy / i.projPos.z;
float2 vRefractTexCoord = vProjNormal.xy;
float scale = lerp( g_CloakControl.x, 0.0f, g_CloakControl.y );
vRefractTexCoord *= scale;
vRefractTexCoord += vRefractTexCoordNoWarp;
#ifdef SHADER_MODEL_PS_2_0
float3 vRefract = tex2D( RefractSampler, vRefractTexCoordNoWarp );
#endif
// Extra refraction rays, specular, rim etc are only done on ps_2_b
#if defined( SHADER_MODEL_PS_2_B ) || defined( SHADER_MODEL_PS_3_0 )
// Blur by scalable Poisson filter
float fBlurAmount = lerp( 0.05f, 0.0f, g_CloakControl.y );
float3 vRefract = tex2D( RefractSampler, vRefractTexCoord );
vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[0].xy * fBlurAmount );
vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[0].wz * fBlurAmount );
vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[1].xy * fBlurAmount );
vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[1].wz * fBlurAmount );
vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[2].xy * fBlurAmount );
vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[2].wz * fBlurAmount );
// We're right at the hairy edge of constant register usage and hence have to drop these taps...
// vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[3].xy * fBlurAmount );
// vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[3].wz * fBlurAmount );
vRefract /= 7.0f;
float3 rimLighting = float3( 0.0f, 0.0f, 0.0f );
float3 specularLighting = float3( 0.0f, 0.0f, 0.0f );
float fSpecExp = g_EyePos_SpecExponent.w;
float fSpecMask = vNormalSample.a;
float4 vSpecExpMap = tex2D( SpecExponentSampler, i.vBaseTexCoord );
float fSpecExpMap = vSpecExpMap.r;
float fRimMask = 1.0f;//lerp( 1.0f, vSpecExpMap.a, g_RimMaskControl ); // Select rim mask
float3 vSpecularTint;
// If the exponent passed in as a constant is zero, use the value from the map as the exponent
if ( fSpecExp == 0 )
fSpecExp = 1.0f - fSpecExpMap + 150.0f * fSpecExpMap;
// If constant tint is negative, tint with albedo, based upon scalar tint map
if ( g_SpecularTint.r == -1 )
vSpecularTint = lerp( float3(1.0f, 1.0f, 1.0f), albedo, vSpecExpMap.g );
else
vSpecularTint = g_SpecularTint.rgb;
// Fresnel to match regular specular lighting
float fFresnelRanges = Fresnel( vWorldNormal, vWorldEyeDir, g_FresnelRanges );
// Summation of specular from all local lights besides the flashlight
PixelShaderDoSpecularLighting( i.worldPos, vWorldNormal, fSpecExp, vWorldEyeDir,
i.lightAtten, nNumLights, cLightInfo, false, 1.0f, false,
NormalizeSampler, 1.0f, true, g_RimExponent,
// Outputs
specularLighting, rimLighting );
// Modulate with spec mask, boost, tint and fresnel ranges
specularLighting *= fSpecMask * g_SpecularBoost * fFresnelRanges * vSpecularTint;
float fRimFresnel = Fresnel4( vWorldNormal, vWorldEyeDir );
// Add in rim light modulated with tint, mask and traditional Fresnel (not using Fresnel ranges)
rimLighting *= vSpecularTint * fRimMask * fRimFresnel;
// Fold rim lighting into specular term by using the max so that we don't really add light twice...
specularLighting = max (specularLighting, rimLighting);
// Add in view-ray lookup from ambient cube
specularLighting += fRimFresnel * fRimMask * vSpecularTint /* g_fRimBoost */ * PixelShaderAmbientLight( vWorldEyeDir, cAmbientCube) * saturate(dot(vWorldNormal, float3(0, 0 , 1)) );
float tintLerpFactor = saturate(lerp( 1, fresnel-1.1, saturate(g_CloakControl.y)));
tintLerpFactor = smoothstep( 0.4f, 0.425f, tintLerpFactor );
float3 vTintedRefract = lerp( vRefract, albedo * vRefract, 0.7f );
vRefract = lerp( vRefract, vTintedRefract, tintLerpFactor );
vSpecular = specularLighting * smoothstep( 0.98, 0.8, saturate(g_CloakControl.y ));
#endif
// Blend refraction component with diffusely lit model
float diffuseLerpFactor = saturate(lerp( 1, fresnel - 1.35, saturate(g_CloakControl.y)));
diffuseLerpFactor = smoothstep( 0.4f, 0.425f, diffuseLerpFactor );
float3 fDiffuse = lerp( vRefract, albedo * diffuseLighting, diffuseLerpFactor );
float3 result = fDiffuse + vSpecular;
float alpha = 1.0f;
// Emulate LinearColorToHDROutput() when uncloaked
result = lerp( result.xyz * LINEAR_LIGHT_SCALE, result, saturate(g_CloakControl.y) );
float fogFactor = CalcPixelFogFactor( PIXELFOGTYPE, g_FogParams, g_EyePos_SpecExponent.z, i.worldPos.z, i.projPos.z );
#if WRITEWATERFOGTODESTALPHA && (PIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT)
alpha = fogFactor;
#endif
return FinalOutput( float4( result, alpha ), fogFactor, PIXELFOGTYPE, TONEMAP_SCALE_NONE );
}