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.
175 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 94916a20ce
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '94916a20ce'
${ noResults }
source-engine/materialsystem/stdshaders/eye_refract_ps2x.fxc

494 lines
21 KiB
Raw Blame History

//====== Copyright © 1996-2007, Valve Corporation, All rights reserved. ===========================
// STATIC: "FLASHLIGHT" "0..1"
// STATIC: "LIGHTWARPTEXTURE" "0..1"
// STATIC: "SPHERETEXKILLCOMBO" "0..1" [ps20b]
// STATIC: "SPHERETEXKILLCOMBO" "0..1" [ps30]
// STATIC: "RAYTRACESPHERE" "0..1" [ps20b]
// STATIC: "RAYTRACESPHERE" "0..1" [ps30]
// STATIC: "FLASHLIGHTDEPTHFILTERMODE" "0..2" [ps20b] [PC]
// STATIC: "FLASHLIGHTDEPTHFILTERMODE" "0..2" [ps30] [PC]
// STATIC: "FLASHLIGHTDEPTHFILTERMODE" "0..0" [ps20b] [XBOX]
// DYNAMIC: "NUM_LIGHTS" "0..2" [ps20]
// DYNAMIC: "NUM_LIGHTS" "0..4" [ps20b]
// DYNAMIC: "NUM_LIGHTS" "0..4" [ps30]
// DYNAMIC: "FLASHLIGHTSHADOWS" "0..1" [ps20b]
// DYNAMIC: "FLASHLIGHTSHADOWS" "0..1" [ps30]
// We don't use other lights when doing the flashlight
// SKIP: ( $FLASHLIGHT != 0 ) && ( $NUM_LIGHTS > 0 )
// We don't care about flashlight depth unless the flashlight is on
// SKIP: ( $FLASHLIGHT == 0 ) && ( $FLASHLIGHTSHADOWS == 1 ) [ps20b]
// SKIP: ( $FLASHLIGHT == 0 ) && ( $FLASHLIGHTSHADOWS == 1 ) [ps30]
// SKIP: ( $RAYTRACESPHERE == 0 ) && ( $SPHERETEXKILLCOMBO == 1 ) [ps30]
// SKIP: ( $RAYTRACESPHERE == 0 ) && ( $SPHERETEXKILLCOMBO == 1 ) [ps20b]
// Debug 2.0 shader locally
//#ifdef SHADER_MODEL_PS_2_B
//#undef SHADER_MODEL_PS_2_B
//#define SHADER_MODEL_PS_2_0
//#endif
// Includes =======================================================================================
#include "common_flashlight_fxc.h"
#include "shader_constant_register_map.h"
// Texture Samplers ===============================================================================
sampler g_tCorneaSampler : register( s0 );
sampler g_tIrisSampler : register( s1 );
sampler g_tEyeReflectionCubemapSampler : register( s2 );
sampler g_tEyeAmbientOcclSampler : register( s3 );
sampler g_tLightwarpSampler : register( s4 ); // 1D texture for TF NPR lighting
sampler g_tFlashlightCookieSampler : register( s5 );
sampler g_tFlashlightDepthSampler : register( s6 );
sampler g_tRandomRotationSampler : register( s7 );
// Shaders Constants and Globals ==================================================================
const float4 g_vPackedConst0 : register( c0 );
#define g_flDilationFactor g_vPackedConst0.x
#define g_flGlossiness g_vPackedConst0.y
#define g_flAverageAmbient g_vPackedConst0.z
#define g_flCorneaBumpStrength g_vPackedConst0.w
const float3 g_vEyeOrigin : register( c1 );
const float4 g_vIrisProjectionU : register( c2 );
const float4 g_vIrisProjectionV : register( c3 );
const float4 g_vCameraPosition : register( c4 );
const float3 g_cAmbientOcclColor : register( c5 );
const float4 g_vPackedConst6 : register( c6 );
#define g_flEyeballRadius g_vPackedConst6.y //0.51f
//#define g_bRaytraceSphere g_vPackedConst6.z //1.0f
#define g_flParallaxStrength g_vPackedConst6.w //0.25f
// Flashlight constants
const float4 g_vFlashlightAttenuationFactors : register( c7 ); // FarZ in w
const float3 g_vFlashlightPos : register( c8 );
const float4 g_vShadowTweaks : register( c9 );
const float4 g_ShaderControls : register( c10 );
#define g_fPixelFogType g_ShaderControls.x
const float4 g_FogParams : register( PSREG_FOG_PARAMS );
PixelShaderLightInfo g_sLightInfo[3] : register( PSREG_LIGHT_INFO_ARRAY ); // 2 registers each - 6 registers total
// Interpolated values ============================================================================
struct PS_INPUT
{
float4 vAmbientOcclUv_fallbackCorneaUv : TEXCOORD0;
float4 cVertexLight : TEXCOORD1; // w is used for the flashlight pass
float4 vTangentViewVector : TEXCOORD2; // Tangent view vector (Note: w is used for flashlight pass)
float4 vWorldPosition_ProjPosZ : TEXCOORD3;
float3 vWorldNormal : TEXCOORD4; // World-space normal
float3 vWorldTangent : TEXCOORD5; // World-space tangent
float4 vLightFalloffCosine01 : TEXCOORD6; // Light falloff and cosine terms for first two local lights
float4 vLightFalloffCosine23 : TEXCOORD7; // Light falloff and cosine terms for next two local lights
float3 vWorldBinormal : COLOR0; // World-space normal
};
// Ray sphere intersect returns distance along ray to intersection ================================
float IntersectRaySphere ( float3 cameraPos, float3 ray, float3 sphereCenter, float sphereRadius)
{
float3 dst = cameraPos.xyz - sphereCenter.xyz;
float B = dot(dst, ray);
float C = dot(dst, dst) - (sphereRadius * sphereRadius);
float D = B*B - C;
return (D > 0) ? (-B - sqrt(D)) : 0;
}
// Calculate both types of Fog and lerp to get result
float CalcPixelFogFactorConst( float fPixelFogType, const float4 fogParams, const float flEyePosZ, const float flWorldPosZ, const float flProjPosZ )
{
float fRangeFog = CalcRangeFog( flProjPosZ, fogParams.x, fogParams.z, fogParams.w );
float fHeightFog = CalcWaterFogAlpha( fogParams.y, flEyePosZ, flWorldPosZ, flProjPosZ, fogParams.w );
return lerp( fRangeFog, fHeightFog, fPixelFogType );
}
// Blend both types of Fog and lerp to get result
float3 BlendPixelFogConst( const float3 vShaderColor, float pixelFogFactor, const float3 vFogColor, float fPixelFogType )
{
pixelFogFactor = saturate( pixelFogFactor );
float3 fRangeResult = lerp( vShaderColor.rgb, vFogColor.rgb, pixelFogFactor * pixelFogFactor ); //squaring the factor will get the middle range mixing closer to hardware fog
float3 fHeightResult = lerp( vShaderColor.rgb, vFogColor.rgb, saturate( pixelFogFactor ) );
return lerp( fRangeResult, fHeightResult, fPixelFogType );
}
float4 FinalOutputConst( const float4 vShaderColor, float pixelFogFactor, float fPixelFogType, const int iTONEMAP_SCALE_TYPE )
{
float4 result = vShaderColor;
if( iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_LINEAR )
{
result.rgb *= LINEAR_LIGHT_SCALE;
}
else if( iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_GAMMA )
{
result.rgb *= GAMMA_LIGHT_SCALE;
}
result.rgb = BlendPixelFogConst( result.rgb, pixelFogFactor, g_LinearFogColor.rgb, fPixelFogType );
result.rgb = SRGBOutput( result.rgb ); //SRGB in pixel shader conversion
return result;
}
// Main ===========================================================================================
float4 main( PS_INPUT i ) : COLOR
{
// Set bools to compile out code
bool bFlashlight = ( FLASHLIGHT != 0 ) ? true : false;
bool bDoDiffuseWarp = LIGHTWARPTEXTURE ? true : false;
int nNumLights = FLASHLIGHT ? 1 : NUM_LIGHTS; // Flashlight is considered one light, otherwise, use numlights combo
#if !defined( SHADER_MODEL_PS_2_0 )
bool bRayCast = RAYTRACESPHERE ? true : false;
bool bRayCastTexKill = SPHERETEXKILLCOMBO ? true : false;
#endif
float flFlashlightNDotL = i.vTangentViewVector.w;
float4 vFlashlightTexCoord = { 0.0f, 0.0f, 0.0f, 0.0f };
if ( bFlashlight )
{
vFlashlightTexCoord.xyzw = i.cVertexLight.xyzw; // This was hidden in this interpolator
i.cVertexLight.rgba = float4( 0.0f, 0.0f, 0.0f, 0.0f );
}
// Interpolated vectors
float3 vWorldNormal = i.vWorldNormal.xyz;
float3 vWorldTangent = i.vWorldTangent.xyz;
float3 vWorldBinormal = ( i.vWorldBinormal.xyz * 2.0f ) - 1.0f; // normalize( cross( vWorldNormal.xyz, vWorldTangent.xyz ) );
float3 vTangentViewVector = i.vTangentViewVector.xyz;
// World position
float3 vWorldPosition = i.vWorldPosition_ProjPosZ.xyz;
// World view vector to pixel
float3 vWorldViewVector = normalize( vWorldPosition.xyz - g_vCameraPosition.xyz );
//=================//
// TF NPR lighting //
//=================//
if ( bDoDiffuseWarp )
{
// Replace the interpolated vertex light
if ( bFlashlight == true )
{
// Deal with this below in the flashlight section
}
else
{
if ( nNumLights > 0 )
{
float3 cWarpedLight = 2.0f * tex1D( g_tLightwarpSampler, i.vLightFalloffCosine01.z ).rgb;
i.cVertexLight.rgb += i.vLightFalloffCosine01.x * PixelShaderGetLightColor( g_sLightInfo, 0 ) * cWarpedLight.rgb;
}
if ( nNumLights > 1 )
{
float3 cWarpedLight = 2.0f * tex1D( g_tLightwarpSampler, i.vLightFalloffCosine01.w ).rgb;
i.cVertexLight.rgb += i.vLightFalloffCosine01.y * PixelShaderGetLightColor( g_sLightInfo, 1 ) * cWarpedLight.rgb;
}
if ( nNumLights > 2 )
{
float3 cWarpedLight = 2.0f * tex1D( g_tLightwarpSampler, i.vLightFalloffCosine23.z ).rgb;
i.cVertexLight.rgb += i.vLightFalloffCosine23.x * PixelShaderGetLightColor( g_sLightInfo, 2 ) * cWarpedLight.rgb;
}
if ( nNumLights > 3 )
{
float3 cWarpedLight = 2.0f * tex1D( g_tLightwarpSampler, i.vLightFalloffCosine23.w ).rgb;
i.cVertexLight.rgb += i.vLightFalloffCosine23.y * PixelShaderGetLightColor( g_sLightInfo, 3 ) * cWarpedLight.rgb;
}
}
}
//==========================================================================================================//
// Ray cast against sphere representing eyeball to reduce artifacts from non-spherical morphed eye geometry //
//==========================================================================================================//
#if !defined( SHADER_MODEL_PS_2_0 )
if ( bRayCast )
{
float fSphereRayCastDistance = IntersectRaySphere( g_vCameraPosition.xyz, vWorldViewVector.xyz, g_vEyeOrigin.xyz, g_flEyeballRadius );
vWorldPosition.xyz = g_vCameraPosition.xyz + ( vWorldViewVector.xyz * fSphereRayCastDistance );
if (fSphereRayCastDistance == 0)
{
if ( bRayCastTexKill )
clip(-1); // texkill to get a better silhouette
vWorldPosition.xyz = g_vEyeOrigin.xyz + ( vWorldNormal.xyz * g_flEyeballRadius );
}
}
#endif
//=================================//
// Generate sphere and cornea uv's //
//=================================//
#if !defined( SHADER_MODEL_PS_2_0 )
float2 vCorneaUv; // Note: Cornea texture is a cropped version of the iris texture
vCorneaUv.x = dot( g_vIrisProjectionU, float4( vWorldPosition, 1.0f ) );
vCorneaUv.y = dot( g_vIrisProjectionV, float4( vWorldPosition, 1.0f ) );
float2 vSphereUv = ( vCorneaUv.xy * 0.5f ) + 0.25f;
#else // ps_20
float2 vCorneaUv = i.vAmbientOcclUv_fallbackCorneaUv.wz; // Note: Cornea texture is a cropped version of the iris texture
float2 vSphereUv = ( vCorneaUv.xy * 0.5f ) + 0.25f;
#endif
//=================================//
// Hacked parallax mapping on iris //
//=================================//
float fIrisOffset = tex2D( g_tCorneaSampler, vCorneaUv.xy ).b;
#if !defined( SHADER_MODEL_PS_2_0 )
float2 vParallaxVector = ( ( vTangentViewVector.xy * fIrisOffset * g_flParallaxStrength ) / ( 1.0f - vTangentViewVector.z ) ); // Note: 0.25 is a magic number
vParallaxVector.x = -vParallaxVector.x; //Need to flip x...not sure why.
//vParallaxVector.x *= -1.0; //Need to flip x...not sure why.
//vParallaxVector = 0.0f; //Disable parallax for debugging
#else // Disable parallax effect in 2.0 version
float2 vParallaxVector = { 0.0f, 0.0f };
#endif
float2 vIrisUv = vSphereUv.xy - vParallaxVector.xy;
// Note: We fetch from this texture twice right now with different uv's for the color and alpha
float2 vCorneaNoiseUv = vSphereUv.xy + ( vParallaxVector.xy * 0.5 );
float fCorneaNoise = tex2D( g_tIrisSampler, vCorneaNoiseUv.xy ).a;
//===============//
// Cornea normal //
//===============//
// Sample 2D normal from texture
float3 vCorneaTangentNormal = { 0.0, 0.0, 1.0 };
float4 vCorneaSample = tex2D( g_tCorneaSampler, vCorneaUv.xy );
vCorneaTangentNormal.xy = vCorneaSample.rg - 0.5f; // Note: This scales the bump to 50% strength
// Scale strength of normal
vCorneaTangentNormal.xy *= g_flCorneaBumpStrength;
// Add in surface noise and imperfections (NOTE: This should be baked into the normal map!)
vCorneaTangentNormal.xy += fCorneaNoise * 0.1f;
// Normalize tangent vector
#if !defined( SHADER_MODEL_PS_2_0 )
// Since this isn't used later in 2.0, skip the normalize to save shader instructions
vCorneaTangentNormal.xyz = normalize( vCorneaTangentNormal.xyz );
#endif
// Transform into world space
float3 vCorneaWorldNormal = Vec3TangentToWorldNormalized( vCorneaTangentNormal.xyz, vWorldNormal.xyz, vWorldTangent.xyz, vWorldBinormal.xyz );
//============//
// Flashlight //
//============//
float3 vFlashlightVector = { 0.0f, 0.0f, 0.0f };
float3 cFlashlightColorFalloff = { 0.0f, 0.0f, 0.0f };
if ( bFlashlight == true )
{
// Flashlight vector
vFlashlightVector.xyz = normalize( g_vFlashlightPos.xyz - i.vWorldPosition_ProjPosZ.xyz );
// Distance attenuation for flashlight and to fade out shadow over distance
float3 vDelta = g_vFlashlightPos.xyz - i.vWorldPosition_ProjPosZ.xyz;
float flDistSquared = dot( vDelta, vDelta );
float flDist = sqrt( flDistSquared );
float flFlashlightAttenuation = dot( g_vFlashlightAttenuationFactors.xyz, float3( 1.0f, 1.0f/flDist, 1.0f/flDistSquared ) );
// Flashlight cookie
#if !defined( SHADER_MODEL_PS_2_0 )
float3 vProjCoords = vFlashlightTexCoord.xyz / vFlashlightTexCoord.w;
float3 cFlashlightCookieColor = tex2D( g_tFlashlightCookieSampler, vProjCoords );
#else
float3 cFlashlightCookieColor = tex2Dproj( g_tFlashlightCookieSampler, vFlashlightTexCoord.xyzw );
#endif
// Shadow depth map
#if FLASHLIGHTSHADOWS && !defined( SHADER_MODEL_PS_2_0 )
int nShadowLevel = FLASHLIGHTDEPTHFILTERMODE;
float flShadow = DoFlashlightShadow( g_tFlashlightDepthSampler, g_tRandomRotationSampler, vProjCoords, float2(0,0), nShadowLevel, g_vShadowTweaks, false );
float flAttenuated = lerp( flShadow, 1.0f, g_vShadowTweaks.y ); // Blend between fully attenuated and not attenuated
flShadow = lerp( flAttenuated, flShadow, flFlashlightAttenuation ); // Blend between shadow and above, according to light attenuation
cFlashlightCookieColor *= flShadow; // Apply shadow term to cookie color
#endif
// Flashlight color intensity (needs to be multiplied by global flashlight color later)
cFlashlightColorFalloff.rgb = flFlashlightAttenuation * cFlashlightCookieColor.rgb;
// Add this into the interpolated lighting
if ( bDoDiffuseWarp )
{
//float3 cWarpedLight = 2.0f * tex1D( g_tLightwarpSampler, flFlashlightNDotL ).rgb;
//i.cVertexLight.rgb += cFlashlightColorFalloff.rgb * cFlashlightColor.rgb * cWarpedLight.rgb;
i.cVertexLight.rgb += cFlashlightColorFalloff.rgb * cFlashlightColor.rgb * flFlashlightNDotL; // No light warp for now
}
else
{
i.cVertexLight.rgb += cFlashlightColorFalloff.rgb * cFlashlightColor.rgb * flFlashlightNDotL;
}
}
//==============//
// Dilate pupil //
//==============//
#if !defined( SHADER_MODEL_PS_2_0 )
vIrisUv.xy -= 0.5f; // Center around (0,0)
float fPupilCenterToBorder = saturate( length( vIrisUv.xy ) / 0.2f ); //Note: 0.2 is the uv radius of the iris
float fPupilDilateFactor = g_flDilationFactor; // This value should be between 0-1
vIrisUv.xy *= lerp (1.0f, fPupilCenterToBorder, saturate( fPupilDilateFactor ) * 2.5f - 1.25f );
vIrisUv.xy += 0.5f;
#endif
//============//
// Iris color //
//============//
float4 cIrisColor = tex2D( g_tIrisSampler, vIrisUv.xy );
//==========================//
// Iris lighting highlights //
//==========================//
float3 cIrisLighting = float3( 0.0f, 0.0f, 0.0f );
#if !defined( SHADER_MODEL_PS_2_0 )
// Mask off everything but the iris pixels
float fIrisHighlightMask = tex2D( g_tCorneaSampler, vCorneaUv.xy ).a;
// Generate the normal
float3 vIrisTangentNormal = vCorneaTangentNormal.xyz;
vIrisTangentNormal.xy *= -2.5f; // I'm not normalizing on purpose
for ( int j=0; j < nNumLights; j++ )
{
// World light vector
float3 vWorldLightVector;
if ( ( j == 0 ) && ( bFlashlight == true ) )
vWorldLightVector = vFlashlightVector.xyz;
else
vWorldLightVector = PixelShaderGetLightVector( i.vWorldPosition_ProjPosZ.xyz, g_sLightInfo, j );
// Tangent light vector
float3 vTangentLightVector = Vec3WorldToTangent( vWorldLightVector.xyz, vWorldNormal.xyz, vWorldTangent.xyz, vWorldBinormal.xyz );
// Adjust the tangent light vector to generate the iris lighting
float3 tmpv = -vTangentLightVector.xyz;
tmpv.xy *= -0.5f; //Flatten tangent view
tmpv.z = max( tmpv.z, 0.5f ); //Clamp z of tangent view to help maintain highlight
tmpv.xyz = normalize( tmpv.xyz );
// Core iris lighting math
float fIrisFacing = pow( abs( dot( vIrisTangentNormal.xyz, tmpv.xyz ) ), 6.0f ) * 0.5f; // Yes, 6.0 and 0.5 are magic numbers
// Cone of darkness to darken iris highlights when light falls behind eyeball past a certain point
float flConeOfDarkness = pow( 1.0f - saturate( ( -vTangentLightVector.z - 0.25f ) / 0.75f ), 4.0f );
//float flConeOfDarkness = pow( 1.0f - saturate( ( -dot( vIrisTangentNormal.xyz, vTangentLightVector.xyz ) - 0.15f ) / 0.85f ), 8.0f );
// Tint by iris color and cone of darkness
float3 cIrisLightingTmp = fIrisFacing * fIrisHighlightMask * flConeOfDarkness;
// Attenuate by light color and light falloff
if ( ( j == 0 ) && ( bFlashlight == true ) )
cIrisLightingTmp.rgb *= cFlashlightColorFalloff.rgb * cFlashlightColor.rgb;
else if ( j == 0 )
cIrisLightingTmp.rgb *= i.vLightFalloffCosine01.x * PixelShaderGetLightColor( g_sLightInfo, 0 );
else if ( j == 1 )
cIrisLightingTmp.rgb *= i.vLightFalloffCosine01.y * PixelShaderGetLightColor( g_sLightInfo, 1 );
else if ( j == 2 )
cIrisLightingTmp.rgb *= i.vLightFalloffCosine23.x * PixelShaderGetLightColor( g_sLightInfo, 2 );
else
cIrisLightingTmp.rgb *= i.vLightFalloffCosine23.y * PixelShaderGetLightColor( g_sLightInfo, 3 );
// Sum into final variable
cIrisLighting.rgb += cIrisLightingTmp.rgb;
}
// Add slight view dependent iris lighting based on ambient light intensity to enhance situations with no local lights (0.5f is to help keep it subtle)
cIrisLighting.rgb += saturate( dot( vIrisTangentNormal.xyz, -vTangentViewVector.xyz ) ) * g_flAverageAmbient * fIrisHighlightMask * 0.5f;
#else
// Else, intensify light over cornea to simulate the brightening that happens above
cIrisLighting.rgb += i.cVertexLight.rgb * vCorneaSample.a;
#endif
//===================//
// Ambient occlusion //
//===================//
float3 cAmbientOcclFromTexture = tex2D( g_tEyeAmbientOcclSampler, i.vAmbientOcclUv_fallbackCorneaUv.xy ).rgb;
float3 cAmbientOcclColor = lerp( g_cAmbientOcclColor, 1.0f, cAmbientOcclFromTexture.rgb ); // Color the ambient occlusion
i.cVertexLight.rgb *= cAmbientOcclColor.rgb;
//==========================//
// Reflection from cube map //
//==========================//
float3 vCorneaReflectionVector = reflect ( vWorldViewVector.xyz, vCorneaWorldNormal.xyz );
//float3 cReflection = ENV_MAP_SCALE * texCUBE( g_tEyeReflectionCubemapSampler, vCorneaReflectionVector.xyz ).rgb;
float3 cReflection = g_flGlossiness * texCUBE( g_tEyeReflectionCubemapSampler, vCorneaReflectionVector.xyz ).rgb;
// Hack: Only add in half of the env map for the flashlight pass. This looks reasonable.
if ( bFlashlight )
{
cReflection.rgb *= 0.5f;
}
//===========================//
// Glint specular highlights //
//===========================//
float3 cSpecularHighlights = 0.0f;
if ( bFlashlight )
{
cSpecularHighlights.rgb += pow( saturate( dot( vCorneaReflectionVector.xyz, vFlashlightVector.xyz ) ), 128.0f ) * cFlashlightColorFalloff.rgb * cFlashlightColor.rgb;
}
else // no flashlight
{
if ( nNumLights > 0 )
cSpecularHighlights.rgb += pow( saturate( dot( vCorneaReflectionVector.xyz, PixelShaderGetLightVector( i.vWorldPosition_ProjPosZ.xyz, g_sLightInfo, 0 ) ) ), 128.0f ) * i.vLightFalloffCosine01.x * PixelShaderGetLightColor( g_sLightInfo, 0 );
if ( nNumLights > 1 )
cSpecularHighlights.rgb += pow( saturate( dot( vCorneaReflectionVector.xyz, PixelShaderGetLightVector( i.vWorldPosition_ProjPosZ.xyz, g_sLightInfo, 1 ) ) ), 128.0f ) * i.vLightFalloffCosine01.y * PixelShaderGetLightColor( g_sLightInfo, 1 );
if ( nNumLights > 2 )
cSpecularHighlights.rgb += pow( saturate( dot( vCorneaReflectionVector.xyz, PixelShaderGetLightVector( i.vWorldPosition_ProjPosZ.xyz, g_sLightInfo, 2 ) ) ), 128.0f ) * i.vLightFalloffCosine23.x * PixelShaderGetLightColor( g_sLightInfo, 2 );
if ( nNumLights > 3 )
cSpecularHighlights.rgb += pow( saturate( dot( vCorneaReflectionVector.xyz, PixelShaderGetLightVector( i.vWorldPosition_ProjPosZ.xyz, g_sLightInfo, 3 ) ) ), 128.0f ) * i.vLightFalloffCosine23.y * PixelShaderGetLightColor( g_sLightInfo, 3 );
}
//===============//
// Combine terms //
//===============//
float4 result;
// Unlit iris, pupil, and sclera color
result.rgb = cIrisColor.rgb;
// Add in slight cornea noise to help define raised cornea layer for close-ups
result.rgb += fCorneaNoise * 0.1f;
// Diffuse light (Vertex lighting + extra iris caustic lighting)
result.rgb *= i.cVertexLight.rgb + cIrisLighting.rgb;
// Environment map
result.rgb += cReflection.rgb * i.cVertexLight.rgb;
// Local light glints
result.rgb += cSpecularHighlights.rgb;
// Set alpha to 1.0 by default
result.a = 1.0;
#if !defined( SHADER_MODEL_PS_2_0 )
float fogFactor = CalcPixelFogFactorConst( g_fPixelFogType, g_FogParams, g_vCameraPosition.z, i.vWorldPosition_ProjPosZ.z, i.vWorldPosition_ProjPosZ.w );
return FinalOutputConst( result, fogFactor, g_fPixelFogType, TONEMAP_SCALE_LINEAR );
#else
float fogFactor = CalcPixelFogFactor( PIXEL_FOG_TYPE_NONE, g_FogParams, g_vCameraPosition.z, i.vWorldPosition_ProjPosZ.z, i.vWorldPosition_ProjPosZ.w );
return FinalOutput( result, fogFactor, PIXEL_FOG_TYPE_NONE, TONEMAP_SCALE_LINEAR );
#endif
}