//========== Copyright (c) Valve Corporation, All rights reserved. ==========// // STATIC: "LIGHTWARPTEXTURE" "0..1" #include "common_fog_ps_fxc.h" // 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 samplerCUBE 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_color_return_type 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, 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 ).rgb; vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[0].xy * fBlurAmount ).rgb; vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[0].wz * fBlurAmount ).rgb; vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[1].xy * fBlurAmount ).rgb; vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[1].wz * fBlurAmount ).rgb; vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[2].xy * fBlurAmount ).rgb; vRefract += tex2D( RefractSampler, vRefractTexCoord + gPoissonOffset[2].wz * fBlurAmount ).rgb; // 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.rgb, 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, BaseSampler, // this sampler isn't actually used; it just needs a value passed in 1.0f, true, g_RimExponent, 1.0f, // 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.rgb * 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.rgb * 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.xyz, i.worldPos.xyz, i.projPos.z ); #if WRITEWATERFOGTODESTALPHA && (PIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT) alpha = fogFactor; #endif return FinalOutput( float4( result, alpha ), fogFactor, PIXELFOGTYPE, TONEMAP_SCALE_NONE ); }