tf2/tf2_src/materialsystem/stdshaders/Engine_Post_ps2x.fxc

// STATIC: "CONVERT_TO_SRGB"				"0..1"	[ps20b][= g_pHardwareConfig->NeedsShaderSRGBConversion()] [PC]
// STATIC: "CONVERT_TO_SRGB"				"0..0"	[= 0] [XBOX]
// STATIC: "LINEAR_INPUT"					"0..1"  [ps20b]
// STATIC: "LINEAR_OUTPUT"					"0..1"  [ps20b]

// DYNAMIC: "AA_ENABLE"						"0..1"
// rem DYNAMIC: "AA_DEBUG_MODE"				"0..3"
#define AA_DEBUG_MODE						0	
// DYNAMIC: "AA_QUALITY_MODE"				"0..0"  [ps20]
// DYNAMIC: "AA_QUALITY_MODE"				"0..1"  [ps20b]
// DYNAMIC: "AA_QUALITY_MODE"				"0..1"  [ps30]
// DYNAMIC: "AA_REDUCE_ONE_PIXEL_LINE_BLUR"	"0..0"	[ps20]
// DYNAMIC: "AA_REDUCE_ONE_PIXEL_LINE_BLUR"	"0..1"	[ps20b]
// DYNAMIC: "AA_REDUCE_ONE_PIXEL_LINE_BLUR"	"0..1"	[ps30]
// DYNAMIC: "COL_CORRECT_NUM_LOOKUPS"		"0..4"

#define HDRTYPE HDR_TYPE_NONE
#include "common_ps_fxc.h"


#if !(defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0))
// Only allow debug modes and high-quality mode if in ps2b or higher (not enough instruction slots in ps20)
#undef  AA_DEBUG_MODE
#define AA_DEBUG_MODE					0
#endif


/* 
 * Engine_Post combines bloom (the final simple addition) with software anti-aliasing
 * and colour-correction. Combining them has these benefits:
 *  (a) saves fillrate+bandwidth (big on PC)
 *  (b) saves calls to UpdateScreenEffectTexture (big on 360)
 *  (c) reduces quantization errors caused by multiple passes
 *  (d) improves AA quality (it works better on sRGB values than linear)
 *
 *
 * Software AA Summary
 * -------------------
 *
 * This AA process works by sampling neighbour pixels (4 or 8 of them):
 *
 *   5-tap filter:         #     9-tap filter:        ###
 *   (AA_QUALITY_MODE 0)  ###    (AA_QUALITY_MODE 1)  ###
 *                         #                          ###
 *
 * It then figures out which of these neighbours are 'unlike' the centre pixel.
 * This is based on RGB distance, weighted by the maximum luminance of the samples
 * (so the difference between 0.1 and 0.2 is the same as between 0.5 and 1.0).
 * This detects high-contrast edges in both dark and bright scenes.
 *
 * It then counts how many 'unlike' samples there are. Some example cases for 5-tap:
 *
 *         O      #      #      #      #      #
 *        OOO    OOO    #OO    OOO    #O#    #O#
 *         O      O      O      #      O      #
 *        Zero   One    TwoA   TwoB  Three   Four
 *
 * We then blend towards the average of the unlike neighbours, based on how many
 * unlike neighbours there are. The key case is 'TwoA' - this detects stairstep pixels
 * on non-axis-aligned edges. In that case, we blend the output colour towards the
 * average of the unlike samples by 33%. This yields a 3-pixel transition (0->33->66->100)
 * where before there was a 1-pixel transition (0->100).
 *
 * The 9-tap filter (which works the same as 5-tap, just with more samples and different
 * weights) has two advantages over the 5-tap filter:
 *  - it can differentiate between stairsteps on 45-degree edges and near-horizontal edges
 *    (so the 5-tap version smudges 45-degree edges more than you want, e.g. chain-link fences)
 *  - it blurs less texture detail, by virtue of averaging out noise over more samples
 *
 * One problem case that both filters have to consider is one-pixel-thick lines (this is
 * case 'TwoB' above). Sometimes you do want to soften these lines (for slivers of brightly-lit
 * geometry in a dark area, e.g. a window frame), but sometimes you do NOT want to soften them
 * (for thin geometry which is alternating between 1-pixel and 2-pixel thickness, e.g. cables,
 * and also where 1-pixel lines appear in textures, e.g. roof tiles). So, blurring of 1-pixel
 * lines is tunable (it defaults to half-blurred as a compromise between the want/don't cases),
 * in the 'AA_REDUCE_ONE_PIXEL_LINE_BLUR' section below. Case TwoB is differentiated from TwoA by
 * computing the centroid of the unlike samples (the centroid will be at zero for case TwoB,
 * but not for TwoA).
 *
 */

sampler	BaseTextureSampler				: register( s0 );
sampler	FBTextureSampler				: register( s1 );
sampler	ColorCorrectionVolumeTexture0	: register( s2 );
sampler	ColorCorrectionVolumeTexture1	: register( s3 );
sampler	ColorCorrectionVolumeTexture2	: register( s4 );
sampler	ColorCorrectionVolumeTexture3	: register( s5 );

float4	psTapOffs_Packed				: register( c0 ); // psTapOffs_packed contains 1-pixel offsets: ( +dX, 0, +dY, -dX )
float4	tweakables						: register( c1 ); // (x - AA strength/unused) (y - reduction of 1-pixel-line blur)
														  // (z - edge threshold multipler) (w - tap offset multiplier)
float4	uvTransform						: register( c2 ); // Transform BaseTexture UVs for use with the FBTexture

float	ColorCorrectionDefaultWeight	: register( c3 );
float4	ColorCorrectionVolumeWeights	: register( c4 );
float	BloomFactor						: register( c5 );

float4 GetBloomColor( float2 bloomUV )
{
	#if ( LINEAR_INPUT == 1 )
	{
		// In this case, which is only used on OpenGL, we want sRGB data from this tex2D.
		// Hence, we have to undo the sRGB conversion that we are forced to apply by OpenGL
		return LinearToGamma( tex2D( BaseTextureSampler, bloomUV ) );
	}
	#else
	{
		return tex2D( BaseTextureSampler, bloomUV );
	}
	#endif
}

float4 PerformColorCorrection( float4 outColor, float2 fbTexCoord )
{
	#if ( COL_CORRECT_NUM_LOOKUPS > 0 )
	{
		// NOTE: This code requires the color correction texture to be 32 units to be correct.
		// This code will cause (0,0,0) to be read from 0.5f/32
		// and (1,1,1) to be read from 31.5f/32
		float4 offsetOutColor = outColor*(31.0f/32.0f) + (0.5f/32.0f);

		outColor.rgb  = outColor.rgb * ColorCorrectionDefaultWeight;
		outColor.rgb += tex3D( ColorCorrectionVolumeTexture0, offsetOutColor.rgb ) * ColorCorrectionVolumeWeights.x;
		#if ( COL_CORRECT_NUM_LOOKUPS > 1 )
		{
			outColor.rgb += tex3D( ColorCorrectionVolumeTexture1, offsetOutColor.rgb ) * ColorCorrectionVolumeWeights.y;
			#if ( COL_CORRECT_NUM_LOOKUPS > 2 )
			{
				outColor.rgb += tex3D( ColorCorrectionVolumeTexture2, offsetOutColor.rgb ) * ColorCorrectionVolumeWeights.z;
				#if ( COL_CORRECT_NUM_LOOKUPS > 3 )
				{
					outColor.rgb += tex3D( ColorCorrectionVolumeTexture3, offsetOutColor.rgb ) * ColorCorrectionVolumeWeights.w;
				}
				#endif
			}
			#endif
		}
		#endif
	}
	#endif

	return outColor;
}

float3 PerformAA( float3 baseColor, float2 fbTexCoord, out float3 unlike, out float unlikeSum, out float lerpFactor )
{
	float3  a,  b,  c,  d,  e,  f,  g,  h;
	float3 dA, dB, dC, dD, dE, dF, dG, dH;
	float4 deltas, deltas2;
	float4 weights, weights2;
	float4 lumS;
	float  maxLumS;

	// Set FAST_DELTAS to '1' to use Manhattan distance (in colour-space) rather than Euclidean distance:
	const int	FAST_DELTAS					= 1;
#if AA_QUALITY_MODE == 0
	const float COLOUR_DELTA_BASE			= (FAST_DELTAS == 0) ? 0.11f : 0.5f;
	const float COLOUR_DELTA_CONTRAST		= 100;
	// Scaling down colour deltas (DELTA_SCALE) reduces the over-blurring of 45-degree edges
	// by the 5-tap filter. Conversely, increasing it smooths stairsteps more strongly.
	const float DELTA_SCALE					= 0.75f;
#else // AA_QUALITY_MODE == 0
	const float COLOUR_DELTA_BASE			= (FAST_DELTAS == 0) ? 0.24f : 0.65f;
	const float COLOUR_DELTA_CONTRAST		= 100;
	const float DELTA_SCALE					= 1.0f;
#endif // AA_QUALITY_MODE == 0
	const float MAX_LERP_FACTOR				= 0.66f;
	const float SQRT3						= 1.73205080757f;
	float		onePixelLineBlurReduction	= tweakables.y;


	// psTapOffs_packed contains 1-pixel offsets: ( +dX, 0, +dY, -dX )
	float4 texelDelta = psTapOffs_Packed*tweakables.w;

	// Allowed ps20 swizzles:
	//   .xyzw on (+dX,0,+dY,-dX) gives: (+dX,  0) & (-dX,  0)  (former with 'add', latter with 'sub')
	//   .yzxw on (+dX,0,+dY,-dX) gives: (  0,+dY) & (  0,-dY)
	//   .wzyx on (+dX,0,+dY,-dX) gives: (-dX,+dY) & (+dX,-dY)
	//   .zxyw on (not used)
	// NOTE: These don't give us (+dX,+dY) and (-dX,-dY), we need to copy +dY: ( +dX, 0, +dY, -dX ) -> ( +dX, +dY, +dY, -dX )
	// NOTE: tex2D() can't swizzle the source register in ps2x, so we have no
	//       choice but to add each float2 offset to fbTexCoord one at a time :o/
 	a = tex2D( FBTextureSampler, fbTexCoord + texelDelta.yz ).rgb;	// ( 0,+1)
	b = tex2D( FBTextureSampler, fbTexCoord + texelDelta.xy ).rgb;	// (+1, 0)
	c = tex2D( FBTextureSampler, fbTexCoord - texelDelta.yz ).rgb;	// ( 0,-1)
	d = tex2D( FBTextureSampler, fbTexCoord - texelDelta.xy ).rgb;	// (-1, 0)
#if AA_QUALITY_MODE == 1
	// 9-tap method (do diagonal neighbours too)
	e = tex2D( FBTextureSampler, fbTexCoord + texelDelta.wz ).rgb;	// (-1,+1)
	f = tex2D( FBTextureSampler, fbTexCoord - texelDelta.wz ).rgb;	// (+1,-1)
	texelDelta.y = texelDelta.z; // Can't quite get all 8 sample offsets from a single float4 with the allowed swizzles! :o/
	g = tex2D( FBTextureSampler, fbTexCoord + texelDelta.xy ).rgb;	// (+1,+1)
	h = tex2D( FBTextureSampler, fbTexCoord - texelDelta.xy ).rgb;	// (-1,-1)
#endif // AA_QUALITY_MODE == 1

	// Compute the like<-->unlike weights
	dA = a - baseColor;
	dB = b - baseColor;
	dC = c - baseColor;
	dD = d - baseColor;
#if AA_QUALITY_MODE == 1
	dE = e - baseColor;
	dF = f - baseColor;
	dG = g - baseColor;
	dH = h - baseColor;
#endif // AA_QUALITY_MODE == 1
	#if ( FAST_DELTAS == 0 )
	{
		// Colour-space Euclidean distance
		deltas = float4( dot(dA, dA), dot(dB, dB), dot(dC, dC), dot(dD, dD) );
		deltas = DELTA_SCALE*DELTA_SCALE*(deltas / 3);
		deltas = sqrt(deltas);
	}
	#else
	{
		// Colour-space Manhattan distance
		// OPT: to avoid the 'abs', try dividing colours by maxLumS then dotprodding w/ baseColor
		deltas.x = dot( abs( dA ), 1 );
		deltas.y = dot( abs( dB ), 1 );
		deltas.z = dot( abs( dC ), 1 );
		deltas.w = dot( abs( dD ), 1 );
		deltas  *= DELTA_SCALE;
	}
	#endif

	weights = deltas;
#if AA_QUALITY_MODE == 1
	#if ( FAST_DELTAS == 0 )
	{
		deltas2 = float4( dot(dE, dE), dot(dF, dF), dot(dG, dG), dot(dH, dH) );
		deltas2 = DELTA_SCALE*DELTA_SCALE*(deltas2 / 3);
		deltas2 = sqrt(deltas2);
	}
	#else
	{
		deltas2.x = dot( abs( dE ), 1);
		deltas2.y = dot( abs( dF ), 1);
		deltas2.z = dot( abs( dG ), 1);
		deltas2.w = dot( abs( dH ), 1);
		deltas2  *= DELTA_SCALE;
	}
	#endif

	weights2 = deltas2;
#endif // AA_QUALITY_MODE == 1

	// Adjust weights relative to maximum sample luminance (local, relative contrast: 0.1 Vs 0.2 is the same as 0.5 Vs 1.0)
	lumS	= float4( dot(a, a), dot(b, b), dot(c, c), dot(d, d) );
	lumS.xy	= max( lumS.xy, lumS.wz );
	lumS.x	= max( lumS.x,  lumS.y  );
	maxLumS	= max( lumS.x, dot( baseColor, baseColor ) );
#if AA_QUALITY_MODE == 1
	lumS	= float4( dot(e, e), dot(f, f), dot(g, g), dot(h, h) );
	lumS.xy	= max( lumS.xy, lumS.wz );
	lumS.x	= max( lumS.x,  lumS.y  );
	maxLumS	= max( lumS.x,  maxLumS );
#endif // AA_QUALITY_MODE == 1
	float lumScale	= 1.0f / sqrt( maxLumS );
	weights		   *= lumScale;
#if AA_QUALITY_MODE == 1
	weights2	   *= lumScale;
#endif // AA_QUALITY_MODE == 1

	// Contrast-adjust weights such that only large contrast differences are taken into account
	// (pushes weights to 0.0 for 'like' neighbours and to 1.0 for 'unlike' neighbours)
	float colourDeltaBase = tweakables.z*COLOUR_DELTA_BASE;
	weights		= saturate(colourDeltaBase + COLOUR_DELTA_CONTRAST*(weights - colourDeltaBase));
#if AA_QUALITY_MODE == 1
	weights2	= saturate(colourDeltaBase + COLOUR_DELTA_CONTRAST*(weights2 - colourDeltaBase));
#endif // AA_QUALITY_MODE == 1

	// Determine the average 'unlike' colour
	unlikeSum	= dot(weights, 1);
	unlike		= weights.x*a  + weights.y*b  + weights.z*c  + weights.w*d;
#if AA_QUALITY_MODE == 1
	unlikeSum  += dot(weights2, 1);
	unlike	   += weights2.x*e + weights2.y*f + weights2.z*g + weights2.w*h;
#endif // AA_QUALITY_MODE == 1
	// NOTE: this can cause div-by-zero, but lerpFactor ends up at zero in that case so it doesn't matter
	unlike		= unlike / unlikeSum;


#if AA_REDUCE_ONE_PIXEL_LINE_BLUR
	// Reduce lerpFactor for 1-pixel-thick lines - otherwise you lose texture detail, and it looks
	// really weird where geometry (e.g. cables) alternates between being 1 and 2 pixels thick.
	// [ The "*2" below is because the values here were tuned to reduce blurring one 1-pixel lines
	//   by about half (which is a good compromise between the bad cases at either end). So you
	//   want the controlling convar to default to 0.5 ]
	const float ONE_PIXEL_LINE_BIAS_BASE		= 0.4f;
	const float ONE_PIXEL_LINE_BIAS_CONTRAST	= 16.0f;
	float2 unlikeCentroid = 0;
	unlikeCentroid.x += dot( 1-weights,  float4(  0, +1,  0, -1 ) ); // This 2x4 matrix is the transpose of
	unlikeCentroid.y += dot( 1-weights,  float4( +1,  0, -1,  0 ) ); // the neighbour sample texel offsets
#if AA_QUALITY_MODE == 0
	unlikeCentroid /= 4 - unlikeSum;
#else // AA_QUALITY_MODE == 0
	unlikeCentroid.x += dot( 1-weights2, float4( -1, +1, +1, -1 ) );
	unlikeCentroid.y += dot( 1-weights2, float4( +1, -1, +1, -1 ) );
	unlikeCentroid /= 8 - unlikeSum;
#endif // AA_QUALITY_MODE == 0
	float onePixelLineBias = 1 - saturate( length(unlikeCentroid) ); // OPTIMIZE: try using distSquared, remove this sqrt
	onePixelLineBias = onePixelLineBlurReduction*saturate(ONE_PIXEL_LINE_BIAS_BASE + ONE_PIXEL_LINE_BIAS_CONTRAST*(onePixelLineBias - ONE_PIXEL_LINE_BIAS_BASE));
#if AA_QUALITY_MODE == 0
	unlikeSum -= 2*onePixelLineBias*0.4f*saturate( 3 - unlikeSum ); // The 'min' thing avoids this affecting lone/pair pixels
#else // AA_QUALITY_MODE == 0
	unlikeSum -= 2*onePixelLineBias*1.9f*saturate( 7 - unlikeSum );
#endif // AA_QUALITY_MODE == 0
#endif // AA_REDUCE_ONE_PIXEL_LINE_BLUR


	// Compute the lerp factor we use to blend between 'baseColor' and 'unlike'.
	// We want to lerp 'stairstep' pixels (which have 2 unlike neighbours)
	// 33% towards the 'unlike' colour, such that these hard, 1-pixel transitions
	// (0% -> 100%) become soft, 3-pixel transitions (0% -> 33% -> 66% -> 100%).
	float strengthMultiplier = tweakables.x;
	#if ( AA_QUALITY_MODE == 0 )
	{
		lerpFactor = saturate( strengthMultiplier*DELTA_SCALE*( (unlikeSum - 1) / 3 ) );
		// Uncomment the following to blend slightly across vertical/horizontal edges (better for 45-degree edges, worse for 90-degree edges)
		//lerpFactor = saturate( strengthMultiplier*DELTA_SCALE*( unlikeSum / 6 ) );
	}
	#else // AA_QUALITY_MODE != 0
	{
		lerpFactor = saturate( strengthMultiplier*DELTA_SCALE*( (unlikeSum - 3) / 3 ) );
	}
	#endif

	// Clamp the blend factor so that lone dot pixels aren't blurred into oblivion
	lerpFactor = min( lerpFactor, MAX_LERP_FACTOR );
	baseColor = lerp( baseColor, unlike, lerpFactor );

	return baseColor;
}

float4 GenerateAADebugColor( float4 outColor, float3 unlike, float unlikeSum, float lerpFactor )
{
	#if ( AA_DEBUG_MODE == 1 )
	{
		// Debug: Visualize the number of 'unlike' samples
		outColor.rgb = 0;
		if ( AA_QUALITY_MODE == 0 )
		{
			if (unlikeSum >= 0.95f) outColor.rgb = float3(1,0,0);
			if (unlikeSum >= 1.95f) outColor.rgb = float3(0,1,0);
			if (unlikeSum >= 2.95f) outColor.rgb = float3(0,0,1);
		}
		else
		{
			if (unlikeSum >= 2.95f) outColor.rgb = float3(1,0,0);
			if (unlikeSum >= 3.95f) outColor.rgb = float3(0,1,0);
			if (unlikeSum >= 4.95f) outColor.rgb = float3(0,0,1);
		}
		// Don't sRGB-write
	}
	#elif ( AA_DEBUG_MODE == 2 )
	{
		// Debug: Visualize the strength of lerpFactor
		outColor.rgb = 0;
		outColor.g   = lerpFactor;
		// Don't sRGB-write
	}
	#elif ( AA_DEBUG_MODE == 3 )
	{
		// Debug: Visualize the 'unlike' colour that we blend towards
		outColor.rgb = lerp( 0, unlike, saturate(5*lerpFactor) );
		// Do sRGB-write (if it's enabled)
		outColor = FinalOutput( outColor, 0, PIXEL_FOG_TYPE_NONE, TONEMAP_SCALE_NONE );
	}
	#endif

	return outColor;
}

float2 PerformUVTransform( float2 bloomUVs )
{
	// NOTE: 'wz' is used since 'zw' is not a valid swizzle for ps20 shaders
	return bloomUVs*uvTransform.wz + uvTransform.xy;
}

struct PS_INPUT
{
	float2 baseTexCoord : TEXCOORD0;
	
#if defined( _X360 ) //avoid a shader patch on 360 due to pixel shader inputs being fewer than vertex shader outputs
	float2 ZeroTexCoord			: TEXCOORD1;
	float2 bloomTexCoord		: TEXCOORD2;
#endif	
};
	   
float4 main( PS_INPUT i ) : COLOR
{
	float2 fbTexCoord = PerformUVTransform( i.baseTexCoord );
	float3 baseColor  = tex2D( FBTextureSampler, fbTexCoord ).rgb;

	#if ( LINEAR_INPUT == 1 )
	{
		// In this case, which is only used on OpenGL, we want sRGB data from this tex2D.
		// Hence, we have to undo the sRGB conversion that we are forced to apply by OpenGL
		baseColor = LinearToGamma( baseColor );
	}
	#endif

	float4 outColor = float4( baseColor, 1 );

	#if ( AA_ENABLE == 1 )
	{
		float  unlikeSum, lerpFactor;
		float3 unlike;

		outColor.rgb = PerformAA( outColor.rgb, fbTexCoord, unlike, unlikeSum, lerpFactor );

		#if ( AA_DEBUG_MODE > 0 )
		{
			return GenerateAADebugColor( outColor, unlike, unlikeSum, lerpFactor );
		}
		#endif
	}
	#endif

	float4 bloomColor = BloomFactor * GetBloomColor( i.baseTexCoord );
	outColor.rgb += bloomColor.rgb;
	outColor = PerformColorCorrection( outColor, fbTexCoord );
	outColor = FinalOutput( outColor, 0, PIXEL_FOG_TYPE_NONE, TONEMAP_SCALE_NONE );

	// Go to linear since we're forced to do an sRGB write on OpenGL in ps2b
	#if ( LINEAR_OUTPUT == 1 )
	{
		outColor = GammaToLinear( outColor );
	}
	#endif

	return outColor;
}