UnrealEngineUWP/Engine/Shaders/PostProcessTonemap.usf

// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.

/*=============================================================================
	PostProcessTonemap.usf: PostProcessing tone mapping
=============================================================================*/

#include "Common.usf"
#include "PostProcessCommon.usf"
#include "TonemapCommon.usf"
#include "GammaCorrectionCommon.usf"
#include "EyeAdaptationCommon.usf"

// 0 / 1(slower, visualize multiple internals side by side for the same image portion, see DebugTile)
#define DEBUG_TONEMAPPER 0

// 64x64 tiling noise texture, optimized to have mostly high frequency content
Texture2D NoiseTexture;
SamplerState NoiseTextureSampler;

// xyz:SceneColorTint.rgb, w:unused
float4 ColorScale0;
// xyz:Bloom1Tint.rgb, w:unused
float4 ColorScale1;

// to scale UV (with border) to NormaizedUV (without border)
float2 TexScale;

// from the postprocess settings, x:VignetteIntensity, y:SharpenDiv6
float2 TonemapperParams;

// Fine film grain
float3 GrainRandomFull;
float3 GrainScaleBiasJitter;

#if EYEADAPTATION_EXPOSURE_FIX != 1
// Default value used when eye adaptation is disabled (e.g fixed exposure) or not available.
float DefaultEyeExposure;
#endif

half GrainFromUV(float2 GrainUV) 
{
	half Grain = frac(sin(GrainUV.x + GrainUV.y * 543.31) *  493013.0);
	return Grain;
}

uint InvertTonemapping;
uint ACESInversion;

uint OutputDevice;

// LUT for color grading
#if USE_VOLUME_LUT == 1
	Texture3D		ColorGradingLUT;
	SamplerState	ColorGradingLUTSampler;
#endif

static const float LUTSize = 32;

half3 ColorLookupTable( half3 LinearColor )
{
	float3 LUTEncodedColor;
	// Encode as ST-2084 (Dolby PQ) values
	if( OutputDevice >= 3 )
		LUTEncodedColor = LinearToST2084( LinearColor );
	// Encode as log values
	else
		LUTEncodedColor = LinToLog( LinearColor );
	
	float3 UVW = LUTEncodedColor * ((LUTSize - 1) / LUTSize) + (0.5f / LUTSize);

#if USE_VOLUME_LUT == 1
	half3 OutDeviceColor = ColorGradingLUT.Sample( ColorGradingLUTSampler, UVW ).rgb;
#else
	half3 OutDeviceColor = UnwrappedTexture3DSample( PostprocessInput3, PostprocessInput3Sampler, UVW, LUTSize ).rgb;
#endif
	
	return OutDeviceColor * 1.05;
}

// xy should be a integer position (e.g. pixel position on the screen)
// use the PseudoRandom() function if you have ALU performance left
// and this if you have TEX performance left.
float PseudoRandomTex(float2 xy)
{
	return Texture2DSample(NoiseTexture, NoiseTextureSampler, xy / 64.0f).r;
}

float SwitchVerticalAxis;

#define NEEDTOSWITCHVERTICLEAXIS (ES2_PROFILE && COMPILER_GLSL_ES2) || (ES3_1_PROFILE && COMPILER_GLSL_ES3_1)

// can be optimized
float2 ScreenPosToUV(float2 ScreenPos)
{
	float2 UV = (ScreenPos * ScreenPosToPixel.xy + ScreenPosToPixel.zw) * PostprocessInput0Size.zw;

#if NEEDTOSWITCHVERTICLEAXIS
	UV.y = 1.0 - UV.y;
#endif

	return UV;
}

float2 UVToScreenPos(float2 UV)
{
#if NEEDTOSWITCHVERTICLEAXIS
	UV.y = 1.0 - UV.y;
#endif

	return (UV * PostprocessInput0Size.xy - ScreenPosToPixel.zw) / ScreenPosToPixel.xy;
}

float4 FringeUVParams;

// vertex shader entry point
void MainVS(
	in 					float4 InPosition 				: ATTRIBUTE0,
	in 					float2 InTexCoord 				: ATTRIBUTE1,
	out noperspective 	float2 OutTexCoord 				: TEXCOORD0,
	out noperspective 	float3 OutExposureScaleVignette : TEXCOORD1,
	out noperspective 	float4 OutGrainUV 				: TEXCOORD2,
	out noperspective 	float4 OutFringe 				: TEXCOORD3,
	out noperspective 	float4 OutFullViewUV 			: TEXCOORD4,
	out 				float4 OutPosition 				: SV_POSITION
	)
{
#if NEEDTOSWITCHVERTICLEAXIS
	// This is currently the last pass, so flip the texture on V to match D3D
	InTexCoord.y = 1.0 - InTexCoord.y;
#endif

	DrawRectangle(InPosition, InTexCoord, OutPosition, OutTexCoord.xy);

	// Forward renderer uses view size texture
	// TODO: Looks to be Ronin specific.. check this:
	OutFullViewUV.xy = OutPosition.xy * float2(0.5,-0.5) + 0.5;

#if NEEDTOSWITCHVERTICLEAXIS
	OutFullViewUV.y = 1.0 - OutFullViewUV.y;
#endif

#if EYEADAPTATION_EXPOSURE_FIX == 1
	// texture can be GWhiteTexture which is 1x1. It's important we don't read outside bounds.
	OutExposureScaleVignette.x = EyeAdaptation.Load(int3(0, 0, 0)).r;
#else
	// If eye adaptation is disabled (e.g. fixed exposure level ) or  not available.  
	OutExposureScaleVignette.x = DefaultEyeExposure;
#endif

	// Scale vignette to always be a circle with consistent corner intensity.
	OutExposureScaleVignette.yz = VignetteSpace(OutPosition.xy);

	// Grain
	OutGrainUV.xy = OutTexCoord + PostprocessInput0Size.zw * float2(-0.5,0.5);
	OutGrainUV.zw = OutTexCoord + GrainRandomFull.xy;

	// Fringe
	float2 ScreenPos = UVToScreenPos(OutTexCoord);
	OutFringe.xy = ScreenPosToUV(ScreenPos * FringeUVParams.r);
	OutFringe.zw = ScreenPosToUV(ScreenPos * FringeUVParams.g);
}

// Function graphing
float F0( float x )
{
	return x*saturate( (x - 0.5)/2 );
}

float F1( float x )
{
	return x;
}

float F2( float x )
{
	return x;
}

float F3( float x )
{
	return x;
}

float LineShade( float fx, float y, float dydx, float LineWidth )
{
	return 1 - smoothstep( 0.5 * LineWidth, LineWidth, abs( fx - y ) / sqrt( 1 + Square( dydx ) ) );
}

float3 Graph( float2 ScreenSpacePos )
{
	float2 WindowMin = float2( 0, 0 );
	float2 WindowMax = float2( 1, 1 );
	
	float2 p = ( (ScreenSpacePos + 1) * 0.5 - WindowMin ) * ( WindowMax - WindowMin );
	float LineWidth = dot( WindowMax - WindowMin, 0.0005 );
	
	float3 Color;
	Color  = float3( 1, 0, 0 ) * LineShade( F0(p.x), p.y, ( F0(p.x + LineWidth) - F0(p.x - LineWidth) ) / (2 * LineWidth), LineWidth );
	Color += float3( 0, 1, 0 ) * LineShade( F1(p.x), p.y, ( F1(p.x + LineWidth) - F1(p.x - LineWidth) ) / (2 * LineWidth), LineWidth );
	Color += float3( 0, 0, 1 ) * LineShade( F2(p.x), p.y, ( F2(p.x + LineWidth) - F2(p.x - LineWidth) ) / (2 * LineWidth), LineWidth );
	Color += float3( 1, 1, 0 ) * LineShade( F3(p.x), p.y, ( F3(p.x + LineWidth) - F3(p.x - LineWidth) ) / (2 * LineWidth), LineWidth );
	//Color += float3( 0, 1, 1 ) * LineShade( F4(p.x), p.y, ( F4(p.x + LineWidth) - F4(p.x - LineWidth) ) / (2 * LineWidth), LineWidth );
	//Color += float3( 1, 1, 1 ) * LineShade( F5(p.x), p.y, ( F5(p.x + LineWidth) - F5(p.x - LineWidth) ) / (2 * LineWidth), LineWidth );
	return Color;
}

// @return color in SRGB
float3 SimpleToneMap(float3 HDRColor)
{
	// from http://filmicgames.com/archives/75
//	float3 x = max(0, HDRColor - 0.004f);	return (x * (6.2f * x + 0.5f)) / (x * (6.2f * x + 1.7f) + 0.06f);
	
	// linear/no tonemapper 
	return HDRColor;
}

float max3(float3 In)
{
	return max(In.x, max(In.y, In.z));
}

// @return 0 at low, 1 at high and linear interpolated inbetween
float RemapScalar(float Low, float High, float x)
{
	return (x - Low) / (High - Low);
}

uint OutputGamut;

// Doesn't work with PQ output
float3 InvertACESTonemapping( float3 OutColor )
{
	const float3x3 AP1_2_sRGB    = mul( XYZ_2_sRGB_MAT, mul( D60_2_D65_CAT, AP1_2_XYZ_MAT ) );
	const float3x3 sRGB_2_AP1    = mul( XYZ_2_AP1_MAT, mul( D65_2_D60_CAT, sRGB_2_XYZ_MAT ) );

	const float3x3 AP1_2_Output = OuputGamutMappingMatrix( OutputGamut );
	const float3x3 Output_2_AP1  = OuputInverseGamutMappingMatrix( OutputGamut );

	const float3x3 sRGB_2_Output = mul( AP1_2_Output, sRGB_2_AP1 );
	const float3x3 Output_2_sRGB = mul( AP1_2_Output, Output_2_AP1 );

	half3 PseudoLinearColor, Approach0, Approach1;
	PseudoLinearColor = saturate(sRGBToLinear( OutColor.rgb ));

	// Approximate inversion
	//Approach0 = mul( Output_2_AP1, PseudoLinearColor );

	// FIXME: Workaround for UE-29935, pushing all colors with a 0 component to black output
	// Workaround in PostProcessCombineLUTs.usf mean that the output color is always in the
	// sRGB gamut. Once that is resolved, the matrix multiply above should be re-enabled.
	Approach0 = PseudoLinearColor;

	Approach0 = aces100nitFitInverse( Approach0 );
	Approach0 = max(0, mul( AP1_2_Output, Approach0 ));

	// Exact inversion
	//Approach1 = mul(Output_2_sRGB, PseudoLinearColor);

	// FIXME: Workaround for UE-29935, pushing all colors with a 0 component to black output
	// Workaround in PostProcessCombineLUTs.usf mean that the output color is always in the
	// sRGB gamut. Once that is resolved, the matrix multiply above should be re-enabled.
	Approach1 = PseudoLinearColor;

	Approach1 = InverseACESOutputTransformsRGBD65( Approach1 );
	Approach1 = max(0, mul( sRGB_2_Output, Approach1 ));

	return lerp(Approach0, Approach1, ACESInversion);
}

float max4(float4 x)
{
	return max(max(x.r, x.g), max(x.b, x.a));
}

// useful debug helper (not optimized), could be moved into a more common place
// @param DebugTile 0,0 is center, -1,0 is left, 1,0 is right, ...
float2 ComputeCounterStepForTileDebugging(float4 SvPosition, int2 TileSize, out int2 DebugTile, out int2 LocalDebugTilePosition)
{
	// ViewportRect is defined for postprocessing passes
	float2 CenterPos = (ViewportRect.xy + ViewportRect.zw) / 2.0f;
	float2 LeftTopPos = CenterPos - TileSize / 2;

	float2 LocalPos = SvPosition.xy - LeftTopPos;

	DebugTile = floor(LocalPos / TileSize);

	LocalDebugTilePosition = LocalPos - DebugTile * TileSize;

	float2 CounterStep = -DebugTile * TileSize;

	return CounterStep;
}
// useful debug helper (works with ComputeCounterStepForTileDebugging()), could be moved into a more common place
#define OffsetInterpolator(CounterStep, InterpolatorName) \
		InterpolatorName += ddx(InterpolatorName) * CounterStep.x + ddy(InterpolatorName) * CounterStep.y;

half3 LookupSceneColor(float2 SceneUV, int2 PixelOffset)
{
#if (ES2_PROFILE && COMPILER_GLSL_ES2) || (ES3_1_PROFILE && COMPILER_GLSL_ES3_1)
	// slower but always works
	// to prevent "error: Texture offset not supported on GLSL ES"
	return Texture2DSample(PostprocessInput0, PostprocessInput0Sampler, SceneUV + PixelOffset * PostprocessInput0Size.zw).rgb;
#else
	// faster
	return PostprocessInput0.SampleLevel(PostprocessInput0Sampler, SceneUV, 0, PixelOffset).rgb;
#endif
}

// pixel shader entry point
void MainPS(
	in noperspective float2 UV : TEXCOORD0,
	in noperspective float3 InExposureScaleVignette : TEXCOORD1,
	in noperspective float4 GrainUV : TEXCOORD2,
	in noperspective float4 FringeUV : TEXCOORD3,
	in noperspective float4 FullViewUV : TEXCOORD4,
	float4 SvPosition : SV_POSITION,		// after all interpolators
	out float4 OutColor : SV_Target0
	)
{
	OutColor = 0;

#if DEBUG_TONEMAPPER
	// @param DebugTile 0,0 is center, -1,0 is left, 1,0 is right, ...
	int2 DebugTile;
	int2 LocalDebugTilePosition;
	bool bOutputDebugTile = false;
	{
		// split the screen in a 3x3 layout and add some border (0.3)
		int2 TileSize = floor(ViewportSize.xy / float2(3.3f, 3.3f));
		bool bBorder;

		float2 CounterStep = ComputeCounterStepForTileDebugging(SvPosition, TileSize, DebugTile, LocalDebugTilePosition);

		OffsetInterpolator(CounterStep, UV);
		OffsetInterpolator(CounterStep, GrainUV);
		OffsetInterpolator(CounterStep, FringeUV);
		OffsetInterpolator(CounterStep, FullViewUV);
	}
	if (all(DebugTile == int2(0, 0)))
	{
		// center is unaltered tonemapper output
		bOutputDebugTile = true;
	}
#endif

	#if USE_GRAIN_JITTER || USE_GRAIN_INTENSITY || USE_GRAIN_QUANTIZATION
		half Grain = GrainFromUV(GrainUV.zw);
	#endif
	float2 SceneUV = UV.xy;
	#if USE_GRAIN_JITTER
		SceneUV = lerp(UV.xy, GrainUV.xy, (1.0 - Grain*Grain) * GrainScaleBiasJitter.z);
	#endif

	#if USE_COLOR_FRINGE
		float2 SceneUVJitter = float2(0.0, 0.0);
		#if USE_GRAIN_JITTER
			SceneUVJitter = SceneUV.xy - UV.xy;
		#endif
		half3 SceneColor = Texture2DSample(PostprocessInput0, PostprocessInput0Sampler, FringeUV.zw + SceneUVJitter.xy).rgb;
		half SceneColorG = Texture2DSample(PostprocessInput0, PostprocessInput0Sampler, FringeUV.xy + SceneUVJitter.xy).g;
		half SceneColorB = Texture2DSample(PostprocessInput0, PostprocessInput0Sampler, SceneUV).b;
		SceneColor.g = SceneColorG;
		SceneColor.b = SceneColorB;
	#else
		half3 SceneColor = Texture2DSample(PostprocessInput0, PostprocessInput0Sampler, SceneUV).rgb;
	#endif

	float ExposureScale = InExposureScaleVignette.x;

#if DEBUG_TONEMAPPER
	if (all(DebugTile == int2(-1, 1)))
	{
		// left below to the center is: no ExposureScale
		ExposureScale = 1.0f;
		bOutputDebugTile = true;
	}
#endif

	// 0..x, 0:no effect .. 1:strong, from r.Tonemapper.Sharpen
	// Div6 is to save one instruction
	float SharpenMultiplierDiv6 = TonemapperParams.y;

#if DEBUG_TONEMAPPER
	if (all(DebugTile == int2(0, -1)) || all(DebugTile == int2(-1, -1)))
	{
		// top row: no sharpen
		SharpenMultiplierDiv6 = 0;
		bOutputDebugTile = true;
	}
#endif //DEBUG_TONEMAPPER

#if USE_SHARPEN
	{
		half3 C1 = LookupSceneColor(SceneUV, int2(-1,  0));
		half3 C2 = LookupSceneColor(SceneUV, int2( 1,  0));
		half3 C3 = LookupSceneColor(SceneUV, int2(-1, -1));
		half3 C4 = LookupSceneColor(SceneUV, int2(-1,  1));

		// reference solution
//		half A0 = max3(SceneColor);
//		half4 LuminanceNeightbors = half4(max3(C1), max3(C2), max3(C3), max3(C4));
		// 5 instructiopns less than reference
//		half A0 = Luminance(SceneColor);
//		half4 LuminanceNeightbors = half4(Luminance(C1), Luminance(C2), Luminance(C3), Luminance(C4));
		// 9 instructions less than reference (green is often a good approximation for the luminance)
		half A0 = SceneColor.g;
		half4 LuminanceNeightbors = half4(C1.g, C2.g, C3.g, C4.g);

		// compute mask to not sharpen near very bright HDR content
		// Note: using max instead of summming up saves 1 instruction
		// Note: We could multiply this to tweak the edge weight but it might instroduce a cost
//		half HDREdge = ExposureScale * max4(abs(A0 - LuminanceNeightbors));
		// 3 instructions less but less accurate (faint black dots near bright edges)
		half HDREdge = ExposureScale * max(abs(A0 * 2 - (LuminanceNeightbors.r + LuminanceNeightbors.g)), abs(A0 * 2 - (LuminanceNeightbors.b + LuminanceNeightbors.a)));

		// 0..1
		half EdgeMask = saturate(1.0f - HDREdge);

#if DEBUG_TONEMAPPER
		if (all(DebugTile == int2(1, 0)))
		{
			// right to the center is: Sharpen EdgeMask
			OutColor = EdgeMask; return;
		}
#endif //DEBUG_TONEMAPPER


		// -1:sharpen, 0:no effect, 1:blur
		float LerpFactor = -EdgeMask * SharpenMultiplierDiv6;



		// reference
		// same instruction count as if the center weight is 1.0
//		half3 BlurredSceneColor = ((C1 + C2 + C3 + C4) + SceneColor * 2) / 6;
//		SceneColor = lerp(SceneColor, BlurredSceneColor, LerpFactor);
		// optimized, Div6 went into the C++ code
		half3 DeltaColor = (C1 + C2 + C3 + C4) - SceneColor * 4;
		SceneColor += DeltaColor * LerpFactor;
	}
#endif

	#if USE_GAMMA_ONLY

		OutColor.rgb = pow(SceneColor, InverseGamma.x);

	#else 

		half3 LinearColor = SceneColor * ColorScale0.rgb;

		#if USE_BLOOM
			float2 BloomUV = UV;
			#if ES2_PROFILE || ES3_1_PROFILE
				BloomUV = FullViewUV.xy;
			#endif
			float4 CombinedBloom = Texture2DSample(PostprocessInput1, PostprocessInput1Sampler, BloomUV);
			float3 BloomDirtMaskColor = Texture2DSample(BloomDirtMask.Mask, BloomDirtMask.MaskSampler, SvPositionToViewportUV(SvPosition)).rgb * BloomDirtMask.Tint.rgb;

#if DEBUG_TONEMAPPER
			if (all(DebugTile == int2(-1, -1)))
			{
				// left to the center is: no bloom
				CombinedBloom = 0;
				bOutputDebugTile = true;
			}
			if (all(DebugTile == int2(1, -1)))
			{
				// right to the center is: bloom only
				LinearColor = 0;
				bOutputDebugTile = true;
			}
#endif //DEBUG_TONEMAPPER

			LinearColor += CombinedBloom.rgb * (ColorScale1.rgb + BloomDirtMaskColor); 
		#endif

		#if NO_EYEADAPTATION_EXPOSURE_FIX == 1
			ExposureScale = BloomDirtMask.Tint.w;
		#endif

		LinearColor *= ExposureScale;

		#if USE_VIGNETTE
			LinearColor.rgb *= ComputeVignetteMask( InExposureScaleVignette.yz, TonemapperParams.x );
		#endif

		#if USE_GRAIN_INTENSITY
			// Needs to go before tonemapping.
			half GrainMul = Grain * GrainScaleBiasJitter.x + GrainScaleBiasJitter.y;
			LinearColor.rgb *= GrainMul;
		#endif

		half3 OutDeviceColor = ColorLookupTable( LinearColor );

		//OutDeviceColor = Graph(SvPositionToScreenPosition(SvPosition).xy);
	
		half LuminanceForPostProcessAA  = dot(OutDeviceColor, half3(0.299f, 0.587f, 0.114f));

		#if USE_GRAIN_QUANTIZATION
			// Needs to go after tonemapping.
			half GrainQuantization = 1.0/256.0;
			half GrainAdd = (Grain * GrainQuantization) + (-0.5 * GrainQuantization);
			OutDeviceColor.rgb += GrainAdd;
		#endif

		// RETURN_COLOR not needed unless writing to SceneColor
		OutColor = float4(OutDeviceColor, saturate(LuminanceForPostProcessAA));

		#if USE_INVERSE_TONEMAPPING
			// Post-tonemap linearization. Used when writing out EXRs
			OutColor.rgb = InvertACESTonemapping( OutColor.rgb );
		#endif
	#endif


#if DEBUG_TONEMAPPER
	if (!bOutputDebugTile)
	{
		// the original tonemapped color is only in the center
		// other tiles can output like this:
		//  if(all(DebugTile == int2(1, 0)))
		//    { OutColor = ..; return; }
		// or
		//  if(all(DebugTile == int2(1, 0)))
		//    { ..; bOutputDebugTile = true; }
		OutColor = 0;
	}
	if (any(LocalDebugTilePosition == int2(0, 0)))
	{
		// border grid
		OutColor = 1;
	}
#endif //DEBUG_TONEMAPPER
}


// ES2 version
// TODO: Convert float to half.

float FringeIntensity;

// vertex shader entry point
void MainVS_ES2(
	in float4 InPosition : ATTRIBUTE0,
	in float2 InTexCoord : ATTRIBUTE1,
	out float4 OutTexCoord : TEXCOORD0,
	out float4 OutFineDofGrain : TEXCOORD1,
	out float4 OutFullViewUV : TEXCOORD2,
	out float2 OutVignette : TEXCOORD3,
	out float2 OutTexCoords[4] : TEXCOORD4,
	out float4 OutFringeTexCoords : FRINGE_COORDS,
	out float4 OutPosition : SV_POSITION
	)
{
#if NEEDTOSWITCHVERTICLEAXIS
	// This is currently the last pass, so flip the texture on V to match D3D
	InTexCoord.y = 1.0-InTexCoord.y;
#endif

	DrawRectangle(InPosition, InTexCoord, OutPosition, OutTexCoord.xy);
	OutTexCoord = float4(OutTexCoord.xy, OutPosition.xy);

	// Fine adjustment is inside the possible non-full viewport in the full resolution texture.
	OutFineDofGrain.xy = OutTexCoord.xy + PostprocessInput0Size.zw * float2(-0.5,0.5);
	// Want grain and a second UV based on the knowledge that the source texture has a full viewport.
	OutFullViewUV.xy = OutPosition.xy * float2(0.5,-0.5) + 0.5;
	#if NEEDTOSWITCHVERTICLEAXIS
		// This is currently the last pass, so flip the texture on V to match D3D
		OutFullViewUV.y = 1.0 - OutFullViewUV.y;
	#endif
	// For DOF attempt to undo sampling bias for the first transition region.
	// This is better for the fine transition, breaks down for the larger bokeh.
	// This is the best compromise for mobile using 4 bilinear taps only.
	OutFullViewUV.zw = OutFullViewUV.xy + PostprocessInput2Size.zw * float2(0.25,-0.5);
	OutFineDofGrain.zw = OutFullViewUV.xy + GrainRandomFull.xy;
	// NEWS
	OutTexCoords[0] = OutTexCoord.xy + PostprocessInput0Size.zw * float2( 0,-1);
	OutTexCoords[1] = OutTexCoord.xy + PostprocessInput0Size.zw * float2( 1, 0);
	OutTexCoords[2] = OutTexCoord.xy + PostprocessInput0Size.zw * float2(-1, 0);
	OutTexCoords[3] = OutTexCoord.xy + PostprocessInput0Size.zw * float2( 0, 1);

	// Scale vignette to always be a circle with consistent corner intensity.
	OutVignette.xy = VignetteSpace(InPosition.xy);

	// Compute fringe tex coord offsets
	BRANCH
	if (FringeIntensity > 0.0)
	{
		half2 FringeOffset = OutTexCoord.xy;
		FringeOffset -= 0.5;
		FringeOffset = abs(FringeOffset * 2.0);
		FringeOffset *= FringeIntensity;
		OutFringeTexCoords.xy = OutTexCoord.xy * half2(1.0 - FringeOffset.x * 0.5, 1.0 - FringeOffset.y * 0.5);
		OutFringeTexCoords.zw = OutTexCoord.xy * half2(1.0 - FringeOffset.x, 1.0 - FringeOffset.y);
	}
	else
	{
		OutFringeTexCoords = 0.0;
	}
}

// Constants for DOF blend in.
half CocMaxRadiusInPixelsRcp() 
{ 
	half2 MaxOffset = half2(-2.125,-0.50)*2.0; 
	return rcp(sqrt(dot(MaxOffset, MaxOffset))); 
}

half2 CocBlendScaleBias() 
{
	half Start = 0.25 * CocMaxRadiusInPixelsRcp();
	half End = 1.0 * CocMaxRadiusInPixelsRcp();
	half2 ScaleBias;
	ScaleBias.x = 1.0/(End-Start);
	ScaleBias.y = (-Start)*ScaleBias.x;
	return ScaleBias;
}

half2 CocBlendScaleBiasFine() 
{
	half Start = 0.0 * CocMaxRadiusInPixelsRcp();
	half End = 0.5 * CocMaxRadiusInPixelsRcp();
	half2 ScaleBias;
	ScaleBias.x = 1.0/(End-Start);
	ScaleBias.y = (-Start)*ScaleBias.x;
	return ScaleBias;
}

float4 OverlayColor;

void MainPS_ES2(
	in float4 UVAndScreenPos : TEXCOORD0,
	in float4 FineDofGrain : TEXCOORD1,
	in float4 FullViewUV : TEXCOORD2,
	in float2 InVignette : TEXCOORD3,
	in float2 InTexCoords[4] : TEXCOORD4,
	in float4 InFringeTexCoords : FRINGE_COORDS,
	#if USE_32BPP_HDR
		in float4 SvPosition : SV_Position,		// after all interpolators
	#endif
	out half4 OutColor : SV_Target0
	)
{
	float2 UV = UVAndScreenPos.xy;
	float2 ScreenSpacePos = UVAndScreenPos.zw;

	half4 SceneColor;
	
#if !USE_32BPP_HDR
	BRANCH
	if (FringeIntensity > 0.0)
	{
		SceneColor.r = PostprocessInput0.Sample(PostprocessInput0Sampler, UV).r;
		SceneColor.g = PostprocessInput0.Sample(PostprocessInput0Sampler, InFringeTexCoords.xy).g;
		SceneColor.b = PostprocessInput0.Sample(PostprocessInput0Sampler, InFringeTexCoords.zw).b;
		SceneColor.a = 1.0;
	}
	else
#endif
	{
		SceneColor = PostprocessInput0.Sample(PostprocessInput0Sampler, UV);
	}

	#if USE_GAMMA_ONLY
		#if USE_MSAA
			SceneColor.rgb *= rcp(SceneColor.r*(-0.299) + SceneColor.g*(-0.587) + SceneColor.b*(-0.114) + 1.0);
		#endif
		OutColor.rgb = sqrt(SceneColor.rgb);
	#else

		#if USE_GRAIN_JITTER || USE_GRAIN_INTENSITY || USE_GRAIN_QUANTIZATION
			half Grain = GrainFromUV(FineDofGrain.zw);
		#endif

		#if USE_DOF
			half4 DofFine = PostprocessInput0.Sample(PostprocessInput0Sampler, FineDofGrain.xy);
			half4 Dof = PostprocessInput2.Sample(PostprocessInput2Sampler, FullViewUV.zw);
			// Convert alpha back into circle of confusion.
			SceneColor.a = max(Dof.a, abs(SceneColor.a * 2.0 - 1.0));
			// Convert circle of confusion into blend factors.		
			half2 ScaleBias = CocBlendScaleBias(); // Constant.
			half DofAmount = saturate(SceneColor.a * ScaleBias.x + ScaleBias.y);
			half2 ScaleBias2 = CocBlendScaleBiasFine(); // Constant.
			half DofAmountFine = saturate(SceneColor.a * ScaleBias2.x + ScaleBias2.y);
			#if USE_GRAIN_JITTER
				// Grain can increase fine DOF.
				DofAmountFine = max((1.0-Grain*Grain) * GrainScaleBiasJitter.z, DofAmountFine);
			#endif
			// Blend in fine DOF.
			SceneColor.rgb = lerp(SceneColor.rgb, DofFine.rgb, DofAmountFine);
			// Blend in coarse DOF.
			SceneColor.rgb = lerp(SceneColor.rgb, Dof.rgb, DofAmount);
		#else
			#if USE_GRAIN_JITTER
				#if USE_32BPP_HDR
					// This has grain jitter off.
				#else
					// Do jitter for grain.
					half4 DofFine = PostprocessInput0.Sample(PostprocessInput0Sampler, FineDofGrain.xy);
					// Grain jitter.
					SceneColor.rgb = lerp(SceneColor.rgb, DofFine.rgb, (1.0-Grain*Grain) * GrainScaleBiasJitter.z);
				#endif
			#endif
		#endif

		#if USE_MSAA
			// Do after jitter for grain as an optimization.
			SceneColor.rgb *= rcp(SceneColor.r*(-0.299) + SceneColor.g*(-0.587) + SceneColor.b*(-0.114) + 1.0);
			// Try to kill negatives and NaNs here
			SceneColor.rgb = max(SceneColor.rgb, 0);
		#endif

		#if USE_32BPP_HDR
		{
			// TODO: Support odd frame inversion of mosaic pattern?
			#if 0
				half3 SceneColorE = PostprocessInput0.Sample(PostprocessInput0Sampler, InTexCoords[1].xy).rgb;
				SceneColor.rgb = HdrDemosaic(SceneColor.rgb, SceneColorE, SvPosition.xy);
			#endif
			#if 1
				// Higher quality path.
				half3 SceneColorN = PostprocessInput0.Sample(PostprocessInput0Sampler, InTexCoords[0].xy).rgb;
				half3 SceneColorE = PostprocessInput0.Sample(PostprocessInput0Sampler, InTexCoords[1].xy).rgb;
				half3 SceneColorW = PostprocessInput0.Sample(PostprocessInput0Sampler, InTexCoords[2].xy).rgb;
				half3 SceneColorS = PostprocessInput0.Sample(PostprocessInput0Sampler, InTexCoords[3].xy).rgb;
				half3 SceneColorV = SceneColorN * 0.5 + SceneColorS * 0.5;
				half3 SceneColorH = SceneColorW * 0.5 + SceneColorE * 0.5;
				if(abs(SceneColorN.g - SceneColorS.g) < abs(SceneColorW.g - SceneColorE.g)) 
				{
					SceneColorH = SceneColorV;
				}
				SceneColor.rgb = Decode32BPPHDR(SceneColor, SceneColorH, SvPosition.xy).rgb;
				SceneColor.a = 0.0;
			#endif
		}
		#endif

		#if !USE_DOF
			// Set so temporal AA shader knows everything is in focus.
			SceneColor.a = 0.0;
		#endif

		// Match PC naming.
		half3 LinearColor = SceneColor.rgb;

		#if USE_32BPP_HDR && USE_VIGNETTE
			LinearColor.rgb *= ComputeVignetteMask( InVignette, TonemapperParams.x );
			LinearColor = max(LinearColor, float3(0, 0, 0));
		#endif

		// It is faster to do vignette as a texture lookup + mad because this is an ALU bound shader.
		#if (USE_BLOOM || USE_LIGHT_SHAFTS || USE_VIGNETTE)
		{
			half4 CombinedBloomSunVignette = Texture2DSample(PostprocessInput1, PostprocessInput1Sampler, FullViewUV.xy);
			if (GetHDR32bppEncodeMode() != HDR_ENCODE_MOSAIC)
			{
				#if USE_32BPP_HDR
					CombinedBloomSunVignette.rgb = Decode32BPPHDR(CombinedBloomSunVignette).rgb;
					LinearColor.rgb = LinearColor.rgb + CombinedBloomSunVignette.rgb;
				#else
					LinearColor.rgb = LinearColor.rgb * CombinedBloomSunVignette.a + CombinedBloomSunVignette.rgb;
				#endif
			}
		}
		#endif

		#if USE_GRAIN_INTENSITY
			// Needs to go before tonemapping.
			half GrainMul = Grain * GrainScaleBiasJitter.x + GrainScaleBiasJitter.y;
			LinearColor.rgb *= GrainMul;
		#endif

		half3 FilmColor = FilmPostProcess(LinearColor.rgb);
		#if IOS
			// Note, iOS native output is raw gamma 2.2 not sRGB!
			half3 TonemappedColor = pow(FilmColor.rgb, 1.0/2.2);
		#else
			// Apply conversion to sRGB (this must be an exact sRGB conversion else darks are bad).
			half3 TonemappedColor = LinearToSrgbBranchless(FilmColor);
		#endif

		// Blend with custom LDR color, used for Fade track in Matinee.
		// This is the 101% wrong way to do this,
		//  - It adds an extra redundant lerp.
		//  - It is not going to work with the future-forward ES3 fast path of sRGB output.
		//  - And it does super ugly non-linear blending.
		// The right way is to adjust exposure instead.
		TonemappedColor = lerp(TonemappedColor.rgb, OverlayColor.rgb, OverlayColor.a);

		#if USE_GRAIN_QUANTIZATION
			// Needs to go after tonemapping.
			half GrainQuantization = 1.0/256.0;
			half GrainAdd = (Grain * GrainQuantization) + (-0.5 * GrainQuantization);
			TonemappedColor.rgb += GrainAdd;
		#endif
			
			OutColor = half4(TonemappedColor, SceneColor.a);

	#endif
}