//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: Common pixel shader code // // $NoKeywords: $ // //=============================================================================// #ifndef COMMON_PS_FXC_H_ #define COMMON_PS_FXC_H_ #include "common_fxc.h" // Put global skip commands here. . make sure and check that the appropriate vars are defined // so these aren't used on the wrong shaders! // -------------------------------------------------------------------------------- // HDR should never be enabled if we don't aren't running in float or integer HDR mode. // SKIP: defined $HDRTYPE && defined $HDRENABLED && !$HDRTYPE && $HDRENABLED // -------------------------------------------------------------------------------- // We don't ever write water fog to dest alpha if we aren't doing water fog. // SKIP: defined $PIXELFOGTYPE && defined $WRITEWATERFOGTODESTALPHA && ( $PIXELFOGTYPE != 1 ) && $WRITEWATERFOGTODESTALPHA // -------------------------------------------------------------------------------- // We don't need fog in the pixel shader if we aren't in float fog mode2 // NOSKIP: defined $HDRTYPE && defined $HDRENABLED && defined $PIXELFOGTYPE && $HDRTYPE != HDR_TYPE_FLOAT && $FOGTYPE != 0 // -------------------------------------------------------------------------------- // We don't do HDR and LIGHTING_PREVIEW at the same time since it's running LDR in hammer. // SKIP: defined $LIGHTING_PREVIEW && defined $HDRTYPE && $LIGHTING_PREVIEW && $HDRTYPE != 0 // -------------------------------------------------------------------------------- // Ditch all fastpath attempts if we are doing LIGHTING_PREVIEW. // SKIP: defined $LIGHTING_PREVIEW && defined $FASTPATHENVMAPTINT && $LIGHTING_PREVIEW && $FASTPATHENVMAPTINT // SKIP: defined $LIGHTING_PREVIEW && defined $FASTPATHENVMAPCONTRAST && $LIGHTING_PREVIEW && $FASTPATHENVMAPCONTRAST // SKIP: defined $LIGHTING_PREVIEW && defined $FASTPATH && $LIGHTING_PREVIEW && $FASTPATH // -------------------------------------------------------------------------------- // Ditch flashlight depth when flashlight is disabled // SKIP: ($FLASHLIGHT || $FLASHLIGHTSHADOWS) && $LIGHTING_PREVIEW // -------------------------------------------------------------------------------- // System defined pixel shader constants #if defined( _X360 ) const bool g_bHighQualityShadows : register( b0 ); #endif // NOTE: w == 1.0f / (Dest alpha compressed depth range). const float4 g_LinearFogColor : register( c29 ); #define OO_DESTALPHA_DEPTH_RANGE (g_LinearFogColor.w) // Linear and gamma light scale values const float4 cLightScale : register( c30 ); #define LINEAR_LIGHT_SCALE (cLightScale.x) #define LIGHT_MAP_SCALE (cLightScale.y) #define ENV_MAP_SCALE (cLightScale.z) #define GAMMA_LIGHT_SCALE (cLightScale.w) // Flashlight constants #if defined(SHADER_MODEL_PS_2_0) || defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0) const float4 cFlashlightColor : register( c28 ); const float4 cFlashlightScreenScale : register( c31 ); // .zw are currently unused #define flFlashlightNoLambertValue cFlashlightColor.w // This is either 0.0 or 2.0 #endif #define HDR_INPUT_MAP_SCALE 16.0f #define TONEMAP_SCALE_NONE 0 #define TONEMAP_SCALE_LINEAR 1 #define TONEMAP_SCALE_GAMMA 2 #define PIXEL_FOG_TYPE_NONE -1 //MATERIAL_FOG_NONE is handled by PIXEL_FOG_TYPE_RANGE, this is for explicitly disabling fog in the shader #define PIXEL_FOG_TYPE_RANGE 0 //range+none packed together in ps2b. Simply none in ps20 (instruction limits) #define PIXEL_FOG_TYPE_HEIGHT 1 // If you change these, make the corresponding change in hardwareconfig.cpp #define NVIDIA_PCF_POISSON 0 #define ATI_NOPCF 1 #define ATI_NO_PCF_FETCH4 2 struct LPREVIEW_PS_OUT { float4 color : COLOR0; float4 normal : COLOR1; float4 position : COLOR2; float4 flags : COLOR3; }; /* // unused HALF Luminance( HALF3 color ) { return dot( color, HALF3( HALF_CONSTANT(0.30f), HALF_CONSTANT(0.59f), HALF_CONSTANT(0.11f) ) ); } */ /* // unused HALF LuminanceScaled( HALF3 color ) { return dot( color, HALF3( HALF_CONSTANT(0.30f) / MAX_HDR_OVERBRIGHT, HALF_CONSTANT(0.59f) / MAX_HDR_OVERBRIGHT, HALF_CONSTANT(0.11f) / MAX_HDR_OVERBRIGHT ) ); } */ /* // unused HALF AvgColor( HALF3 color ) { return dot( color, HALF3( HALF_CONSTANT(0.33333f), HALF_CONSTANT(0.33333f), HALF_CONSTANT(0.33333f) ) ); } */ /* // unused HALF4 DiffuseBump( sampler lightmapSampler, float2 lightmapTexCoord1, float2 lightmapTexCoord2, float2 lightmapTexCoord3, HALF3 normal ) { HALF3 lightmapColor1 = tex2D( lightmapSampler, lightmapTexCoord1 ); HALF3 lightmapColor2 = tex2D( lightmapSampler, lightmapTexCoord2 ); HALF3 lightmapColor3 = tex2D( lightmapSampler, lightmapTexCoord3 ); HALF3 diffuseLighting; diffuseLighting = saturate( dot( normal, bumpBasis[0] ) ) * lightmapColor1 + saturate( dot( normal, bumpBasis[1] ) ) * lightmapColor2 + saturate( dot( normal, bumpBasis[2] ) ) * lightmapColor3; return HALF4( diffuseLighting, LuminanceScaled( diffuseLighting ) ); } */ /* // unused HALF Fresnel( HALF3 normal, HALF3 eye, HALF2 scaleBias ) { HALF fresnel = HALF_CONSTANT(1.0f) - dot( normal, eye ); fresnel = pow( fresnel, HALF_CONSTANT(5.0f) ); return fresnel * scaleBias.x + scaleBias.y; } */ /* // unused HALF4 GetNormal( sampler normalSampler, float2 normalTexCoord ) { HALF4 normal = tex2D( normalSampler, normalTexCoord ); normal.rgb = HALF_CONSTANT(2.0f) * normal.rgb - HALF_CONSTANT(1.0f); return normal; } */ // Needs to match NormalDecodeMode_t enum in imaterialsystem.h #define NORM_DECODE_NONE 0 #define NORM_DECODE_ATI2N 1 #define NORM_DECODE_ATI2N_ALPHA 2 float4 DecompressNormal( sampler NormalSampler, float2 tc, int nDecompressionMode, sampler AlphaSampler ) { float4 normalTexel = tex2D( NormalSampler, tc ); float4 result; if ( nDecompressionMode == NORM_DECODE_NONE ) { result = float4(normalTexel.xyz * 2.0f - 1.0f, normalTexel.a ); } else if ( nDecompressionMode == NORM_DECODE_ATI2N ) { result.xy = normalTexel.xy * 2.0f - 1.0f; result.z = sqrt( 1.0f - dot(result.xy, result.xy) ); result.a = 1.0f; } else // ATI2N plus ATI1N for alpha { result.xy = normalTexel.xy * 2.0f - 1.0f; result.z = sqrt( 1.0f - dot(result.xy, result.xy) ); result.a = tex2D( AlphaSampler, tc ).x; // Note that this comes in on the X channel } return result; } float4 DecompressNormal( sampler NormalSampler, float2 tc, int nDecompressionMode ) { return DecompressNormal( NormalSampler, tc, nDecompressionMode, NormalSampler ); } HALF3 NormalizeWithCubemap( sampler normalizeSampler, HALF3 input ) { // return texCUBE( normalizeSampler, input ) * 2.0f - 1.0f; return texCUBE( normalizeSampler, input ); } /* HALF4 EnvReflect( sampler envmapSampler, sampler normalizeSampler, HALF3 normal, float3 eye, HALF2 fresnelScaleBias ) { HALF3 normEye = NormalizeWithCubemap( normalizeSampler, eye ); HALF fresnel = Fresnel( normal, normEye, fresnelScaleBias ); HALF3 reflect = CalcReflectionVectorUnnormalized( normal, eye ); return texCUBE( envmapSampler, reflect ); } */ float CalcWaterFogAlpha( const float flWaterZ, const float flEyePosZ, const float flWorldPosZ, const float flProjPosZ, const float flFogOORange ) { // float flDepthFromWater = flWaterZ - flWorldPosZ + 2.0f; // hackity hack . .this is for the DF_FUDGE_UP in view_scene.cpp float flDepthFromWater = flWaterZ - flWorldPosZ; // if flDepthFromWater < 0, then set it to 0 // This is the equivalent of moving the vert to the water surface if it's above the water surface // We'll do this with the saturate at the end instead. // flDepthFromWater = max( 0.0f, flDepthFromWater ); // Calculate the ratio of water fog to regular fog (ie. how much of the distance from the viewer // to the vert is actually underwater. float flDepthFromEye = flEyePosZ - flWorldPosZ; float f = saturate(flDepthFromWater * (1.0/flDepthFromEye)); // $tmp.w is now the distance that we see through water. return saturate(f * flProjPosZ * flFogOORange); } float CalcRangeFog( const float flProjPosZ, const float flFogStartOverRange, const float flFogMaxDensity, const float flFogOORange ) { #if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) //Minimum requirement of ps2b return saturate( min( flFogMaxDensity, (flProjPosZ * flFogOORange) - flFogStartOverRange ) ); #else return 0.0f; //ps20 shaders will never have range fog enabled because too many ran out of slots. #endif } float CalcPixelFogFactor( int iPIXELFOGTYPE, const float4 fogParams, const float flEyePosZ, const float flWorldPosZ, const float flProjPosZ ) { float retVal; if ( iPIXELFOGTYPE == PIXEL_FOG_TYPE_NONE ) { retVal = 0.0f; } if ( iPIXELFOGTYPE == PIXEL_FOG_TYPE_RANGE ) //range fog, or no fog depending on fog parameters { retVal = CalcRangeFog( flProjPosZ, fogParams.x, fogParams.z, fogParams.w ); } else if ( iPIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT ) //height fog { retVal = CalcWaterFogAlpha( fogParams.y, flEyePosZ, flWorldPosZ, flProjPosZ, fogParams.w ); } return retVal; } //g_FogParams not defined by default, but this is the same layout for every shader that does define it #define g_FogEndOverRange g_FogParams.x #define g_WaterZ g_FogParams.y #define g_FogMaxDensity g_FogParams.z #define g_FogOORange g_FogParams.w float3 BlendPixelFog( const float3 vShaderColor, float pixelFogFactor, const float3 vFogColor, const int iPIXELFOGTYPE ) { if( iPIXELFOGTYPE == PIXEL_FOG_TYPE_RANGE ) //either range fog or no fog depending on fog parameters and whether this is ps20 or ps2b { # if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) //Minimum requirement of ps2b pixelFogFactor = saturate( pixelFogFactor ); return lerp( vShaderColor.rgb, vFogColor.rgb, pixelFogFactor * pixelFogFactor ); //squaring the factor will get the middle range mixing closer to hardware fog # else return vShaderColor; # endif } else if( iPIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT ) { return lerp( vShaderColor.rgb, vFogColor.rgb, saturate( pixelFogFactor ) ); } else if( iPIXELFOGTYPE == PIXEL_FOG_TYPE_NONE ) { return vShaderColor; } } #if ((defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)) && ( CONVERT_TO_SRGB != 0 ) ) sampler1D GammaTableSampler : register( s15 ); float3 SRGBOutput( const float3 vShaderColor ) { //On ps2b capable hardware we always have the linear->gamma conversion table texture in sampler s15. float3 result; result.r = tex1D( GammaTableSampler, vShaderColor.r ).r; result.g = tex1D( GammaTableSampler, vShaderColor.g ).r; result.b = tex1D( GammaTableSampler, vShaderColor.b ).r; return result; } #else float3 SRGBOutput( const float3 vShaderColor ) { return vShaderColor; //ps 1.1, 1.4, and 2.0 never do srgb conversion in the pixel shader } #endif float SoftParticleDepth( float flDepth ) { return flDepth * OO_DESTALPHA_DEPTH_RANGE; } float DepthToDestAlpha( const float flProjZ ) { #if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) //Minimum requirement of ps2b return SoftParticleDepth( flProjZ ); #else return 1.0f; #endif } float4 FinalOutput( const float4 vShaderColor, float pixelFogFactor, const int iPIXELFOGTYPE, const int iTONEMAP_SCALE_TYPE, const bool bWriteDepthToDestAlpha = false, const float flProjZ = 1.0f ) { float4 result; if( iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_LINEAR ) { result.rgb = vShaderColor.rgb * LINEAR_LIGHT_SCALE; } else if( iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_GAMMA ) { result.rgb = vShaderColor.rgb * GAMMA_LIGHT_SCALE; } else if( iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_NONE ) { result.rgb = vShaderColor.rgb; } if( bWriteDepthToDestAlpha ) result.a = DepthToDestAlpha( flProjZ ); else result.a = vShaderColor.a; result.rgb = BlendPixelFog( result.rgb, pixelFogFactor, g_LinearFogColor.rgb, iPIXELFOGTYPE ); #if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) //Minimum requirement of ps2b result.rgb = SRGBOutput( result.rgb ); //SRGB in pixel shader conversion #endif return result; } LPREVIEW_PS_OUT FinalOutput( const LPREVIEW_PS_OUT vShaderColor, float pixelFogFactor, const int iPIXELFOGTYPE, const int iTONEMAP_SCALE_TYPE ) { LPREVIEW_PS_OUT result; result.color = FinalOutput( vShaderColor.color, pixelFogFactor, iPIXELFOGTYPE, iTONEMAP_SCALE_TYPE ); result.normal.rgb = SRGBOutput( vShaderColor.normal.rgb ); result.normal.a = vShaderColor.normal.a; result.position.rgb = SRGBOutput( vShaderColor.position.rgb ); result.position.a = vShaderColor.position.a; result.flags.rgb = SRGBOutput( vShaderColor.flags.rgb ); result.flags.a = vShaderColor.flags.a; return result; } float RemapValClamped( float val, float A, float B, float C, float D) { float cVal = (val - A) / (B - A); cVal = saturate( cVal ); return C + (D - C) * cVal; } //===================================================================================// // This is based on Natasha Tatarchuk's Parallax Occlusion Mapping (ATI) //===================================================================================// // INPUT: // inTexCoord: // the texcoord for the height/displacement map before parallaxing // // vParallax: // Compute initial parallax displacement direction: // float2 vParallaxDirection = normalize( vViewTS.xy ); // float fLength = length( vViewTS ); // float fParallaxLength = sqrt( fLength * fLength - vViewTS.z * vViewTS.z ) / vViewTS.z; // Out.vParallax = vParallaxDirection * fParallaxLength * fProjectedBumpHeight; // // vNormal: // tangent space normal // // vViewW: // float3 vViewW = /*normalize*/(mul( matViewInverse, float4( 0, 0, 0, 1)) - inPosition ); // // OUTPUT: // the new texcoord after parallaxing float2 CalcParallaxedTexCoord( float2 inTexCoord, float2 vParallax, float3 vNormal, float3 vViewW, sampler HeightMapSampler ) { const int nMinSamples = 8; const int nMaxSamples = 50; // Normalize the incoming view vector to avoid artifacts: // vView = normalize( vView ); vViewW = normalize( vViewW ); // vLight = normalize( vLight ); // Change the number of samples per ray depending on the viewing angle // for the surface. Oblique angles require smaller step sizes to achieve // more accurate precision int nNumSteps = (int) lerp( nMaxSamples, nMinSamples, dot( vViewW, vNormal ) ); float4 cResultColor = float4( 0, 0, 0, 1 ); //===============================================// // Parallax occlusion mapping offset computation // //===============================================// float fCurrHeight = 0.0; float fStepSize = 1.0 / (float) nNumSteps; float fPrevHeight = 1.0; float fNextHeight = 0.0; int nStepIndex = 0; // bool bCondition = true; float2 dx = ddx( inTexCoord ); float2 dy = ddy( inTexCoord ); float2 vTexOffsetPerStep = fStepSize * vParallax; float2 vTexCurrentOffset = inTexCoord; float fCurrentBound = 1.0; float x = 0; float y = 0; float xh = 0; float yh = 0; float2 texOffset2 = 0; bool bCondition = true; while ( bCondition == true && nStepIndex < nNumSteps ) { vTexCurrentOffset -= vTexOffsetPerStep; fCurrHeight = tex2Dgrad( HeightMapSampler, vTexCurrentOffset, dx, dy ).r; fCurrentBound -= fStepSize; if ( fCurrHeight > fCurrentBound ) { x = fCurrentBound; y = fCurrentBound + fStepSize; xh = fCurrHeight; yh = fPrevHeight; texOffset2 = vTexCurrentOffset - vTexOffsetPerStep; bCondition = false; } else { nStepIndex++; fPrevHeight = fCurrHeight; } } // End of while ( bCondition == true && nStepIndex > -1 )#else fCurrentBound -= fStepSize; float fParallaxAmount; float numerator = (x * (y - yh) - y * (x - xh)); float denomenator = ((y - yh) - (x - xh)); // avoid NaN generation if( ( numerator == 0.0f ) && ( denomenator == 0.0f ) ) { fParallaxAmount = 0.0f; } else { fParallaxAmount = numerator / denomenator; } float2 vParallaxOffset = vParallax * (1 - fParallaxAmount ); // Sample the height at the next possible step: fNextHeight = tex2Dgrad( HeightMapSampler, texOffset2, dx, dy ).r; // Original offset: float2 texSampleBase = inTexCoord - vParallaxOffset; return texSampleBase; #if 0 cResultColor.rgb = ComputeDiffuseColor( texSampleBase, vLight ); float fBound = 1.0 - fStepSize * nStepIndex; if ( fNextHeight < fCurrentBound ) // if( 0 ) { //void DoIteration( in float2 vParallaxJittered, in float3 vLight, inout float4 cResultColor ) //cResultColor.rgb = float3(1,0,0); DoIteration( vParallax + vPixelSize, vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor ); DoIteration( vParallax - vPixelSize, vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor ); DoIteration( vParallax + float2( -vPixelSize.x, vPixelSize.y ), vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor ); DoIteration( vParallax + float2( vPixelSize.x, -vPixelSize.y ), vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor ); cResultColor.rgb /= 5; // cResultColor.rgb = float3( 1.0f, 0.0f, 0.0f ); } // End of if ( fNextHeight < fCurrentBound ) #if DOSHADOWS { //============================================// // Soft shadow and self-occlusion computation // //============================================// // Compute the blurry shadows (note that this computation takes into // account self-occlusion for shadow computation): float sh0 = tex2D( sNormalMap, texSampleBase).w; float shA = (tex2D( sNormalMap, texSampleBase + inXY * 0.88 ).w - sh0 - 0.88 ) * 1 * fShadowSoftening; float sh9 = (tex2D( sNormalMap, texSampleBase + inXY * 0.77 ).w - sh0 - 0.77 ) * 2 * fShadowSoftening; float sh8 = (tex2D( sNormalMap, texSampleBase + inXY * 0.66 ).w - sh0 - 0.66 ) * 4 * fShadowSoftening; float sh7 = (tex2D( sNormalMap, texSampleBase + inXY * 0.55 ).w - sh0 - 0.55 ) * 6 * fShadowSoftening; float sh6 = (tex2D( sNormalMap, texSampleBase + inXY * 0.44 ).w - sh0 - 0.44 ) * 8 * fShadowSoftening; float sh5 = (tex2D( sNormalMap, texSampleBase + inXY * 0.33 ).w - sh0 - 0.33 ) * 10 * fShadowSoftening; float sh4 = (tex2D( sNormalMap, texSampleBase + inXY * 0.22 ).w - sh0 - 0.22 ) * 12 * fShadowSoftening; // Compute the actual shadow strength: float fShadow = 1 - max( max( max( max( max( max( shA, sh9 ), sh8 ), sh7 ), sh6 ), sh5 ), sh4 ); cResultColor.rgb *= fShadow * 0.6 + 0.4; } #endif return cResultColor; #endif } //======================================// // HSL Color space conversion routines // //======================================// #define HUE 0 #define SATURATION 1 #define LIGHTNESS 2 // Convert from RGB to HSL color space float4 RGBtoHSL( float4 inColor ) { float h, s; float flMax = max( inColor.r, max( inColor.g, inColor.b ) ); float flMin = min( inColor.r, min( inColor.g, inColor.b ) ); float l = (flMax + flMin) / 2.0f; if (flMax == flMin) // achromatic case { s = h = 0; } else // chromatic case { // Next, calculate the hue float delta = flMax - flMin; // First, calculate the saturation if (l < 0.5f) // If we're in the lower hexcone { s = delta/(flMax + flMin); } else { s = delta/(2 - flMax - flMin); } if ( inColor.r == flMax ) { h = (inColor.g - inColor.b)/delta; // color between yellow and magenta } else if ( inColor.g == flMax ) { h = 2 + (inColor.b - inColor.r)/delta; // color between cyan and yellow } else // blue must be max { h = 4 + (inColor.r - inColor.g)/delta; // color between magenta and cyan } h *= 60.0f; if (h < 0.0f) { h += 360.0f; } h /= 360.0f; } return float4 (h, s, l, 1.0f); } float HueToRGB( float v1, float v2, float vH ) { float fResult = v1; vH = fmod (vH + 1.0f, 1.0f); if ( ( 6.0f * vH ) < 1.0f ) { fResult = ( v1 + ( v2 - v1 ) * 6.0f * vH ); } else if ( ( 2.0f * vH ) < 1.0f ) { fResult = ( v2 ); } else if ( ( 3.0f * vH ) < 2.0f ) { fResult = ( v1 + ( v2 - v1 ) * ( ( 2.0f / 3.0f ) - vH ) * 6.0f ); } return fResult; } // Convert from HSL to RGB color space float4 HSLtoRGB( float4 hsl ) { float r, g, b; float h = hsl[HUE]; float s = hsl[SATURATION]; float l = hsl[LIGHTNESS]; if ( s == 0 ) { r = g = b = l; } else { float v1, v2; if ( l < 0.5f ) v2 = l * ( 1.0f + s ); else v2 = ( l + s ) - ( s * l ); v1 = 2 * l - v2; r = HueToRGB( v1, v2, h + ( 1.0f / 3.0f ) ); g = HueToRGB( v1, v2, h ); b = HueToRGB( v1, v2, h - ( 1.0f / 3.0f ) ); } return float4( r, g, b, 1.0f ); } // texture combining modes for combining base and detail/basetexture2 #define TCOMBINE_RGB_EQUALS_BASE_x_DETAILx2 0 // original mode #define TCOMBINE_RGB_ADDITIVE 1 // base.rgb+detail.rgb*fblend #define TCOMBINE_DETAIL_OVER_BASE 2 #define TCOMBINE_FADE 3 // straight fade between base and detail. #define TCOMBINE_BASE_OVER_DETAIL 4 // use base alpha for blend over detail #define TCOMBINE_RGB_ADDITIVE_SELFILLUM 5 // add detail color post lighting #define TCOMBINE_RGB_ADDITIVE_SELFILLUM_THRESHOLD_FADE 6 #define TCOMBINE_MOD2X_SELECT_TWO_PATTERNS 7 // use alpha channel of base to select between mod2x channels in r+a of detail #define TCOMBINE_MULTIPLY 8 #define TCOMBINE_MASK_BASE_BY_DETAIL_ALPHA 9 // use alpha channel of detail to mask base #define TCOMBINE_SSBUMP_BUMP 10 // use detail to modulate lighting as an ssbump #define TCOMBINE_SSBUMP_NOBUMP 11 // detail is an ssbump but use it as an albedo. shader does the magic here - no user needs to specify mode 11 float4 TextureCombine( float4 baseColor, float4 detailColor, int combine_mode, float fBlendFactor ) { if ( combine_mode == TCOMBINE_MOD2X_SELECT_TWO_PATTERNS) { float3 dc=lerp(detailColor.r,detailColor.a, baseColor.a); baseColor.rgb*=lerp(float3(1,1,1),2.0*dc,fBlendFactor); } if ( combine_mode == TCOMBINE_RGB_EQUALS_BASE_x_DETAILx2) baseColor.rgb*=lerp(float3(1,1,1),2.0*detailColor.rgb,fBlendFactor); if ( combine_mode == TCOMBINE_RGB_ADDITIVE ) baseColor.rgb += fBlendFactor * detailColor.rgb; if ( combine_mode == TCOMBINE_DETAIL_OVER_BASE ) { float fblend=fBlendFactor * detailColor.a; baseColor.rgb = lerp( baseColor.rgb, detailColor.rgb, fblend); } if ( combine_mode == TCOMBINE_FADE ) { baseColor = lerp( baseColor, detailColor, fBlendFactor); } if ( combine_mode == TCOMBINE_BASE_OVER_DETAIL ) { float fblend=fBlendFactor * (1-baseColor.a); baseColor.rgb = lerp( baseColor.rgb, detailColor.rgb, fblend ); baseColor.a = detailColor.a; } if ( combine_mode == TCOMBINE_MULTIPLY ) { baseColor = lerp( baseColor, baseColor*detailColor, fBlendFactor); } if (combine_mode == TCOMBINE_MASK_BASE_BY_DETAIL_ALPHA ) { baseColor.a = lerp( baseColor.a, baseColor.a*detailColor.a, fBlendFactor ); } if ( combine_mode == TCOMBINE_SSBUMP_NOBUMP ) { baseColor.rgb = baseColor.rgb * dot( detailColor.rgb, 2.0/3.0 ); } return baseColor; } float3 lerp5(float3 f1, float3 f2, float i1, float i2, float x) { return f1+(f2-f1)*(x-i1)/(i2-i1); } float3 TextureCombinePostLighting( float3 lit_baseColor, float4 detailColor, int combine_mode, float fBlendFactor ) { if ( combine_mode == TCOMBINE_RGB_ADDITIVE_SELFILLUM ) lit_baseColor += fBlendFactor * detailColor.rgb; if ( combine_mode == TCOMBINE_RGB_ADDITIVE_SELFILLUM_THRESHOLD_FADE ) { // fade in an unusual way - instead of fading out color, remap an increasing band of it from // 0..1 //if (fBlendFactor > 0.5) // lit_baseColor += min(1, (1.0/fBlendFactor)*max(0, detailColor.rgb-(1-fBlendFactor) ) ); //else // lit_baseColor += 2*fBlendFactor*2*max(0, detailColor.rgb-.5); float f = fBlendFactor - 0.5; float fMult = (f >= 0) ? 1.0/fBlendFactor : 4*fBlendFactor; float fAdd = (f >= 0) ? 1.0-fMult : -0.5*fMult; lit_baseColor += saturate(fMult * detailColor.rgb + fAdd); } return lit_baseColor; } //NOTE: On X360. fProjZ is expected to be pre-reversed for cheaper math here in the pixel shader float DepthFeathering( sampler DepthSampler, const float2 vScreenPos, float fProjZ, float fProjW, float4 vDepthBlendConstants ) { # if ( !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || defined(SHADER_MODEL_PS_2_0)) ) //minimum requirement of ps2b { float flFeatheredAlpha; float2 flDepths; #define flSceneDepth flDepths.x #define flSpriteDepth flDepths.y # if ( defined( _X360 ) ) { //Get depth from the depth texture. Need to sample with the offset of (0.5, 0.5) to fix rounding errors asm { tfetch2D flDepths.x___, vScreenPos, DepthSampler, OffsetX=0.5, OffsetY=0.5, MinFilter=point, MagFilter=point, MipFilter=point }; # if( !defined( REVERSE_DEPTH_ON_X360 ) ) flSceneDepth = 1.0f - flSceneDepth; # endif //get the sprite depth into the same range as the texture depth flSpriteDepth = fProjZ / fProjW; //unproject to get at the pre-projection z. This value is much more linear than depth flDepths = vDepthBlendConstants.z / flDepths; flDepths = vDepthBlendConstants.y - flDepths; flFeatheredAlpha = flSceneDepth - flSpriteDepth; flFeatheredAlpha *= vDepthBlendConstants.x; flFeatheredAlpha = saturate( flFeatheredAlpha ); } # else { flSceneDepth = tex2D( DepthSampler, vScreenPos ).a; // PC uses dest alpha of the frame buffer flSpriteDepth = SoftParticleDepth( fProjZ ); flFeatheredAlpha = abs(flSceneDepth - flSpriteDepth) * vDepthBlendConstants.x; flFeatheredAlpha = max( smoothstep( 0.75f, 1.0f, flSceneDepth ), flFeatheredAlpha ); //as the sprite approaches the edge of our compressed depth space, the math stops working. So as the sprite approaches the far depth, smoothly remove feathering. flFeatheredAlpha = saturate( flFeatheredAlpha ); } # endif #undef flSceneDepth #undef flSpriteDepth return flFeatheredAlpha; } # else { return 1.0f; } # endif } #endif //#ifndef COMMON_PS_FXC_H_