H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
windows
source-engine/materialsystem/stdshaders/common_ps_fxc.h

805 lines
26 KiB
C
Raw Permalink Normal View History

1
2020-04-22 16:56:21 +00:00
//========= 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_
Reference in New Issue Copy Permalink