640 lines
21 KiB
HLSL
640 lines
21 KiB
HLSL
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
/*=============================================================================
|
|
TonemapCommon.usf: PostProcessing tone mapping common
|
|
=============================================================================*/
|
|
|
|
#pragma once
|
|
|
|
#ifndef USE_ACES_2
|
|
#define USE_ACES_2 0
|
|
#endif
|
|
|
|
#include "GammaCorrectionCommon.ush"
|
|
#include "ACES/ACESCommon.ush"
|
|
#if USE_ACES_2
|
|
#include "ACES/ACESOutputTransform.ush"
|
|
#include "ACES/ACESDisplayEncoding.ush"
|
|
#else
|
|
#include "ACES/ACES_v1.3.ush"
|
|
#endif
|
|
|
|
/** Values of output device (matching C++'s EDisplayOutputFormat) */
|
|
#define TONEMAPPER_OUTPUT_sRGB 0
|
|
#define TONEMAPPER_OUTPUT_Rec709 1
|
|
#define TONEMAPPER_OUTPUT_ExplicitGammaMapping 2
|
|
#define TONEMAPPER_OUTPUT_ACES1000nitST2084 3
|
|
#define TONEMAPPER_OUTPUT_ACES2000nitST2084 4
|
|
#define TONEMAPPER_OUTPUT_ACES1000nitScRGB 5
|
|
#define TONEMAPPER_OUTPUT_ACES2000nitScRGB 6
|
|
#define TONEMAPPER_OUTPUT_LinearEXR 7
|
|
#define TONEMAPPER_OUTPUT_NoToneCurve 8
|
|
#define TONEMAPPER_OUTPUT_WithToneCurve 9
|
|
|
|
/** Values of output device (matching C++'s EDisplayColorGamut) */
|
|
#define TONEMAPPER_GAMUT_sRGB_D65 0
|
|
#define TONEMAPPER_GAMUT_DCIP3_D65 1
|
|
#define TONEMAPPER_GAMUT_Rec2020_D65 2
|
|
#define TONEMAPPER_GAMUT_ACES_D60 3
|
|
#define TONEMAPPER_GAMUT_ACEScg_D60 4
|
|
|
|
|
|
// usually 1/2.2, the .y is used for inverse gamma when "gamma only" mode is not used
|
|
half3 InverseGamma;
|
|
|
|
// Scale factor for converting pixel values to nits.
|
|
// This value is required for PQ (ST2084) conversions, because PQ linear values are in nits.
|
|
// The purpose is to make good use of PQ lut entries. A scale factor of 100 conveniently places
|
|
// about half of the PQ lut indexing below 1.0, with the other half for input values over 1.0.
|
|
// Also, 100nits is the expected monitor brightness for a 1.0 pixel value without a tone curve.
|
|
static const float LinearToNitsScale = 100.0;
|
|
static const float LinearToNitsScaleInverse = 1.0 / 100.0;
|
|
|
|
half3 TonemapAndGammaCorrect(half3 LinearColor)
|
|
{
|
|
// Clamp input to be positive
|
|
// This displays negative colors as black
|
|
LinearColor = max(LinearColor, 0);
|
|
|
|
half3 GammaColor = pow(LinearColor, InverseGamma.x);
|
|
|
|
// in all cases it's good to clamp into the 0..1 range (e.g for LUT color grading)
|
|
GammaColor = saturate(GammaColor);
|
|
|
|
return GammaColor;
|
|
}
|
|
|
|
|
|
/*
|
|
============================================
|
|
// Uncharted settings
|
|
Slope = 0.63;
|
|
Toe = 0.55;
|
|
Shoulder = 0.47;
|
|
BlackClip= 0;
|
|
WhiteClip = 0.01;
|
|
|
|
// HP settings
|
|
Slope = 0.65;
|
|
Toe = 0.63;
|
|
Shoulder = 0.45;
|
|
BlackClip = 0;
|
|
WhiteClip = 0;
|
|
|
|
// Legacy settings
|
|
Slope = 0.98;
|
|
Toe = 0.3;
|
|
Shoulder = 0.22;
|
|
BlackClip = 0;
|
|
WhiteClip = 0.025;
|
|
|
|
// ACES settings
|
|
Slope = 0.91;
|
|
Toe = 0.53;
|
|
Shoulder = 0.23;
|
|
BlackClip = 0;
|
|
WhiteClip = 0.035;
|
|
===========================================
|
|
*/
|
|
float FilmSlope;
|
|
float FilmToe;
|
|
float FilmShoulder;
|
|
float FilmBlackClip;
|
|
float FilmWhiteClip;
|
|
|
|
half3 FilmToneMap( half3 LinearColor )
|
|
{
|
|
const float3x3 sRGB_2_AP0 = mul( XYZ_2_AP0_MAT, mul( D65_2_D60_CAT, sRGB_2_XYZ_MAT ) );
|
|
const float3x3 sRGB_2_AP1 = mul( XYZ_2_AP1_MAT, mul( D65_2_D60_CAT, sRGB_2_XYZ_MAT ) );
|
|
|
|
const float3x3 AP0_2_sRGB = mul( XYZ_2_sRGB_MAT, mul( D60_2_D65_CAT, AP0_2_XYZ_MAT ) );
|
|
const float3x3 AP1_2_sRGB = mul( XYZ_2_sRGB_MAT, mul( D60_2_D65_CAT, AP1_2_XYZ_MAT ) );
|
|
|
|
const float3x3 AP0_2_AP1 = mul( XYZ_2_AP1_MAT, AP0_2_XYZ_MAT );
|
|
const float3x3 AP1_2_AP0 = mul( XYZ_2_AP0_MAT, AP1_2_XYZ_MAT );
|
|
|
|
float3 ColorAP1 = LinearColor;
|
|
//float3 ColorAP1 = mul( sRGB_2_AP1, float3(LinearColor) );
|
|
|
|
#if 0
|
|
{
|
|
float3 oces = Inverse_ODT_sRGB_D65( LinearColor );
|
|
float3 aces = Inverse_RRT( oces );
|
|
ColorAP1 = mul( AP0_2_AP1, aces );
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
float3 ColorSRGB = mul( AP1_2_sRGB, ColorAP1 );
|
|
ColorSRGB = max( 0, ColorSRGB );
|
|
ColorAP1 = mul( sRGB_2_AP1, ColorSRGB );
|
|
#endif
|
|
|
|
float3 ColorAP0 = mul( AP1_2_AP0, ColorAP1 );
|
|
|
|
#if 0
|
|
{
|
|
float3 aces = ColorAP0;
|
|
float3 oces = RRT( aces );
|
|
LinearColor = ODT_sRGB_D65( oces );
|
|
}
|
|
return mul( sRGB_2_AP1, LinearColor );
|
|
#endif
|
|
|
|
#if 1
|
|
// "Glow" module constants
|
|
const float RRT_GLOW_GAIN = 0.05;
|
|
const float RRT_GLOW_MID = 0.08;
|
|
|
|
float saturation = rgb_2_saturation( ColorAP0 );
|
|
float ycIn = rgb_2_yc( ColorAP0 );
|
|
float s = sigmoid_shaper( (saturation - 0.4) / 0.2);
|
|
float addedGlow = 1 + glow_fwd( ycIn, RRT_GLOW_GAIN * s, RRT_GLOW_MID);
|
|
ColorAP0 *= addedGlow;
|
|
#endif
|
|
|
|
#if 1
|
|
// --- Red modifier --- //
|
|
const float RRT_RED_SCALE = 0.82;
|
|
const float RRT_RED_PIVOT = 0.03;
|
|
const float RRT_RED_HUE = 0;
|
|
const float RRT_RED_WIDTH = 135;
|
|
float hue = rgb_2_hue( ColorAP0 );
|
|
float centeredHue = center_hue( hue, RRT_RED_HUE );
|
|
float hueWeight = Square( smoothstep( 0, 1, 1 - abs( 2 * centeredHue / RRT_RED_WIDTH ) ) );
|
|
|
|
ColorAP0.r += hueWeight * saturation * (RRT_RED_PIVOT - ColorAP0.r) * (1. - RRT_RED_SCALE);
|
|
#endif
|
|
|
|
// Use ACEScg primaries as working space
|
|
float3 WorkingColor = mul( AP0_2_AP1_MAT, ColorAP0 );
|
|
|
|
WorkingColor = max( 0, WorkingColor );
|
|
|
|
// Pre desaturate
|
|
WorkingColor = lerp( dot( WorkingColor, AP1_RGB2Y ), WorkingColor, 0.96 );
|
|
|
|
const half ToeScale = 1 + FilmBlackClip - FilmToe;
|
|
const half ShoulderScale = 1 + FilmWhiteClip - FilmShoulder;
|
|
|
|
const float InMatch = 0.18;
|
|
const float OutMatch = 0.18;
|
|
|
|
float ToeMatch;
|
|
if( FilmToe > 0.8 )
|
|
{
|
|
// 0.18 will be on straight segment
|
|
ToeMatch = ( 1 - FilmToe - OutMatch ) / FilmSlope + log10( InMatch );
|
|
}
|
|
else
|
|
{
|
|
// 0.18 will be on toe segment
|
|
|
|
// Solve for ToeMatch such that input of InMatch gives output of OutMatch.
|
|
const float bt = ( OutMatch + FilmBlackClip ) / ToeScale - 1;
|
|
ToeMatch = log10( InMatch ) - 0.5 * log( (1+bt)/(1-bt) ) * (ToeScale / FilmSlope);
|
|
}
|
|
|
|
float StraightMatch = ( 1 - FilmToe ) / FilmSlope - ToeMatch;
|
|
float ShoulderMatch = FilmShoulder / FilmSlope - StraightMatch;
|
|
|
|
half3 LogColor = log10( WorkingColor );
|
|
half3 StraightColor = FilmSlope * ( LogColor + StraightMatch );
|
|
|
|
half3 ToeColor = ( -FilmBlackClip ) + (2 * ToeScale) / ( 1 + exp( (-2 * FilmSlope / ToeScale) * ( LogColor - ToeMatch ) ) );
|
|
half3 ShoulderColor = ( 1 + FilmWhiteClip ) - (2 * ShoulderScale) / ( 1 + exp( ( 2 * FilmSlope / ShoulderScale) * ( LogColor - ShoulderMatch ) ) );
|
|
|
|
ToeColor = select(LogColor < ToeMatch, ToeColor, StraightColor);
|
|
ShoulderColor = select(LogColor > ShoulderMatch, ShoulderColor, StraightColor);
|
|
|
|
half3 t = saturate( ( LogColor - ToeMatch ) / ( ShoulderMatch - ToeMatch ) );
|
|
t = ShoulderMatch < ToeMatch ? 1 - t : t;
|
|
t = (3-2*t)*t*t;
|
|
half3 ToneColor = lerp( ToeColor, ShoulderColor, t );
|
|
|
|
// Post desaturate
|
|
ToneColor = lerp( dot( float3(ToneColor), AP1_RGB2Y ), ToneColor, 0.93 );
|
|
|
|
// Returning positive AP1 values
|
|
return max( 0, ToneColor );
|
|
}
|
|
|
|
half3 FilmToneMapInverse( half3 ToneColor )
|
|
{
|
|
const float3x3 sRGB_2_AP1 = mul( XYZ_2_AP1_MAT, mul( D65_2_D60_CAT, sRGB_2_XYZ_MAT ) );
|
|
const float3x3 AP1_2_sRGB = mul( XYZ_2_sRGB_MAT, mul( D60_2_D65_CAT, AP1_2_XYZ_MAT ) );
|
|
|
|
// Use ACEScg primaries as working space
|
|
half3 WorkingColor = mul( sRGB_2_AP1, saturate( ToneColor ) );
|
|
|
|
WorkingColor = max( 0, WorkingColor );
|
|
|
|
// Post desaturate
|
|
WorkingColor = lerp( dot( WorkingColor, AP1_RGB2Y ), WorkingColor, 1.0 / 0.93 );
|
|
|
|
half3 ToeColor = 0.374816 * pow( 0.9 / min( WorkingColor, 0.8 ) - 1, -0.588729 );
|
|
half3 ShoulderColor = 0.227986 * pow( 1.56 / ( 1.04 - WorkingColor ) - 1, 1.02046 );
|
|
|
|
half3 t = saturate( ( WorkingColor - 0.35 ) / ( 0.45 - 0.35 ) );
|
|
t = (3-2*t)*t*t;
|
|
half3 LinearColor = lerp( ToeColor, ShoulderColor, t );
|
|
|
|
// Pre desaturate
|
|
LinearColor = lerp( dot( LinearColor, AP1_RGB2Y ), LinearColor, 1.0 / 0.96 );
|
|
|
|
#if WORKING_COLOR_SPACE_IS_SRGB
|
|
LinearColor = mul( AP1_2_sRGB, LinearColor );
|
|
#else
|
|
LinearColor = mul( XYZ_TO_RGB_WORKING_COLOR_SPACE_MAT, mul( AP1_2_XYZ_MAT, LinearColor ) );
|
|
#endif
|
|
// Returning positive working color space values
|
|
return max( 0, LinearColor );
|
|
}
|
|
|
|
WhiteStandard GetWhiteStandard(uint OutputGamut)
|
|
{
|
|
if (OutputGamut == TONEMAPPER_GAMUT_DCIP3_D65)
|
|
return WhiteStandard_D65;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_Rec2020_D65)
|
|
return WhiteStandard_D65;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_ACES_D60)
|
|
return WhiteStandard_D60;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_ACEScg_D60)
|
|
return WhiteStandard_D60;
|
|
else
|
|
return WhiteStandard_D65;
|
|
}
|
|
|
|
float3x3 XYZtoRGBMatrix(uint OutputGamut)
|
|
{
|
|
if (OutputGamut == TONEMAPPER_GAMUT_DCIP3_D65)
|
|
return XYZ_2_P3D65_MAT;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_Rec2020_D65)
|
|
return XYZ_2_Rec2020_MAT;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_ACES_D60)
|
|
return XYZ_2_AP0_MAT;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_ACEScg_D60)
|
|
return XYZ_2_AP1_MAT;
|
|
else
|
|
return XYZ_2_sRGB_MAT;
|
|
}
|
|
|
|
float3x3 RGBtoXYZMatrix(uint OutputGamut)
|
|
{
|
|
if (OutputGamut == TONEMAPPER_GAMUT_DCIP3_D65)
|
|
return P3D65_2_XYZ_MAT;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_Rec2020_D65)
|
|
return Rec2020_2_XYZ_MAT;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_ACES_D60)
|
|
return AP0_2_XYZ_MAT;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_ACEScg_D60)
|
|
return AP1_2_XYZ_MAT;
|
|
else
|
|
return sRGB_2_XYZ_MAT;
|
|
}
|
|
|
|
FColorSpace GetColorSpace(uint OutputGamut)
|
|
{
|
|
FColorSpace OutColorSpace;
|
|
OutColorSpace.White = GetWhiteStandard(OutputGamut);
|
|
OutColorSpace.XYZtoRGB = XYZtoRGBMatrix(OutputGamut);
|
|
OutColorSpace.RGBtoXYZ = RGBtoXYZMatrix(OutputGamut);
|
|
return OutColorSpace;
|
|
}
|
|
|
|
static const int UE_ACES_EOTF = 4; // 0: ST-2084 (PQ)
|
|
// 1: BT.1886 (Rec.709/2020 settings)
|
|
// 2: sRGB (mon_curve w/ presets)
|
|
// 3: gamma 2.6
|
|
// 4: linear (no EOTF)
|
|
// 5: HLG
|
|
|
|
static const int UE_ACES_SURROUND = 0; // 0: dark ( NOTE: this is the only active setting! )
|
|
// 1: dim ( *inactive* - selecting this will have no effect )
|
|
// 2: normal ( *inactive* - selecting this will have no effect )
|
|
|
|
static const bool UE_ACES_STRETCH_BLACK = true; // stretch black luminance to a PQ code value of 0
|
|
static const bool UE_ACES_D60_SIM = false;
|
|
static const bool UE_ACES_LEGAL_RANGE = false;
|
|
// Scale white is usually only enabled when using a limiting white different from the encoding white
|
|
static const bool UE_ACES_SCALE_WHITE = false;
|
|
|
|
static const float UE_SCRGB_WHITE_NITS = 80.0; // ScRGB D65 white luminance (cd/m^2)
|
|
|
|
#if USE_ACES_2
|
|
float3 ACESOutputTransform(
|
|
float3 SceneReferredLinearColor,
|
|
const float3x3 WCS_2_AP0,
|
|
float PeakLuminance,
|
|
Texture2D<float> ReachTable,
|
|
Texture2D<float3> GamutTable,
|
|
Texture2D<float> GammaTable,
|
|
const bool bApplyWhiteLimiting = true
|
|
)
|
|
{
|
|
// TODO: The display limiting color space should be user-exposed as part of display characterization.
|
|
const FColorSpace LimitingColorSpace = GetColorSpace(TONEMAPPER_GAMUT_ACEScg_D60);
|
|
const FColorSpace EncodingColorSpace = GetColorSpace(TONEMAPPER_GAMUT_ACEScg_D60);
|
|
|
|
float3 Aces = mul( WCS_2_AP0, SceneReferredLinearColor );
|
|
|
|
ODTParams PARAMS = init_ODTParams(
|
|
PeakLuminance,
|
|
LimitingColorSpace.RGBtoXYZ,
|
|
LimitingColorSpace.XYZtoRGB,
|
|
EncodingColorSpace.RGBtoXYZ,
|
|
EncodingColorSpace.XYZtoRGB,
|
|
ReachTable,
|
|
GamutTable,
|
|
GammaTable
|
|
);
|
|
|
|
float3 ColorXYZ = outputTransform_fwd(Aces, PeakLuminance, PARAMS);
|
|
|
|
if(bApplyWhiteLimiting)
|
|
{
|
|
ColorXYZ = white_limiting(ColorXYZ, PARAMS, UE_ACES_SCALE_WHITE);
|
|
}
|
|
|
|
// Scale by reference luminance to return values in nits, matching our 1.3 transform
|
|
return mul(XYZ_2_AP1_MAT, ColorXYZ) * referenceLuminance;
|
|
}
|
|
|
|
float3 ACESInvOutputTransform(
|
|
float3 ColorAP1_Nits,
|
|
const float3x3 AP0_2_WCS,
|
|
float PeakLuminance,
|
|
Texture2D<float> ReachTable,
|
|
Texture2D<float3> GamutTable,
|
|
Texture2D<float> GammaTable,
|
|
const bool bApplyWhiteLimiting = true
|
|
)
|
|
{
|
|
float3 ColorXYZ = mul(AP1_2_XYZ_MAT, ColorAP1_Nits / referenceLuminance);
|
|
|
|
const FColorSpace LimitingColorSpace = GetColorSpace(TONEMAPPER_GAMUT_ACEScg_D60);
|
|
const FColorSpace EncodingColorSpace = GetColorSpace(TONEMAPPER_GAMUT_ACEScg_D60);
|
|
|
|
ODTParams PARAMS = init_ODTParams(
|
|
PeakLuminance,
|
|
LimitingColorSpace.RGBtoXYZ,
|
|
LimitingColorSpace.XYZtoRGB,
|
|
EncodingColorSpace.RGBtoXYZ,
|
|
EncodingColorSpace.XYZtoRGB,
|
|
ReachTable,
|
|
GamutTable,
|
|
GammaTable
|
|
);
|
|
|
|
if(bApplyWhiteLimiting)
|
|
{
|
|
ColorXYZ = white_limiting(ColorXYZ, PARAMS, UE_ACES_SCALE_WHITE, true);
|
|
}
|
|
|
|
float3 Aces = outputTransform_inv(ColorXYZ, PeakLuminance, PARAMS);
|
|
|
|
return mul(AP0_2_WCS, Aces);
|
|
}
|
|
|
|
#else // USE_ACES_2
|
|
struct FACESTonemapParams
|
|
{
|
|
TsParams AcesParams;
|
|
float SceneColorMultiplier;
|
|
float GamutCompression;
|
|
};
|
|
|
|
FACESTonemapParams ComputeACESTonemapParams(float4 InACESMinMaxData, float4 InACESMidData, float4 InACESCoefsLow_0, float4 InACESCoefsHigh_0, float InACESCoefsLow_4, float InACESCoefsHigh_4, float SceneColorMultiplier, float GamutCompression)
|
|
{
|
|
FACESTonemapParams OutACESTonemapParams;
|
|
OutACESTonemapParams.AcesParams.Min.x = InACESMinMaxData.x;
|
|
OutACESTonemapParams.AcesParams.Min.y = InACESMinMaxData.y;
|
|
OutACESTonemapParams.AcesParams.Min.slope = 0;
|
|
|
|
OutACESTonemapParams.AcesParams.Mid.x = InACESMidData.x;
|
|
OutACESTonemapParams.AcesParams.Mid.y = InACESMidData.y;
|
|
OutACESTonemapParams.AcesParams.Mid.slope = InACESMidData.z;
|
|
|
|
OutACESTonemapParams.AcesParams.Max.x = InACESMinMaxData.z;
|
|
OutACESTonemapParams.AcesParams.Max.y = InACESMinMaxData.w;
|
|
OutACESTonemapParams.AcesParams.Max.slope = 0;
|
|
|
|
OutACESTonemapParams.AcesParams.coefsLow[0] = InACESCoefsLow_0.x;
|
|
OutACESTonemapParams.AcesParams.coefsLow[1] = InACESCoefsLow_0.y;
|
|
OutACESTonemapParams.AcesParams.coefsLow[2] = InACESCoefsLow_0.z;
|
|
OutACESTonemapParams.AcesParams.coefsLow[3] = InACESCoefsLow_0.w;
|
|
OutACESTonemapParams.AcesParams.coefsLow[4] = InACESCoefsLow_4;
|
|
OutACESTonemapParams.AcesParams.coefsLow[5] = InACESCoefsLow_4;
|
|
|
|
OutACESTonemapParams.AcesParams.coefsHigh[0] = InACESCoefsHigh_0.x;
|
|
OutACESTonemapParams.AcesParams.coefsHigh[1] = InACESCoefsHigh_0.y;
|
|
OutACESTonemapParams.AcesParams.coefsHigh[2] = InACESCoefsHigh_0.z;
|
|
OutACESTonemapParams.AcesParams.coefsHigh[3] = InACESCoefsHigh_0.w;
|
|
OutACESTonemapParams.AcesParams.coefsHigh[4] = InACESCoefsHigh_4;
|
|
OutACESTonemapParams.AcesParams.coefsHigh[5] = InACESCoefsHigh_4;
|
|
|
|
OutACESTonemapParams.SceneColorMultiplier = SceneColorMultiplier;
|
|
OutACESTonemapParams.GamutCompression = GamutCompression;
|
|
|
|
return OutACESTonemapParams;
|
|
|
|
}
|
|
|
|
//
|
|
// ACES D65 nit Output Transform - Forward
|
|
// Input is scene-referred linear values in the working space gamut
|
|
// Output is output-referred linear values in the AP1 gamut
|
|
//
|
|
float3 ACESOutputTransform( float3 SceneReferredLinearColor, const float3x3 WCS_2_AP0, FACESTonemapParams InACESTonemapParams)
|
|
{
|
|
float3 aces = mul( WCS_2_AP0, SceneReferredLinearColor * InACESTonemapParams.SceneColorMultiplier);
|
|
float3 AcesCompressed = compressColor(aces);
|
|
aces = lerp(aces, AcesCompressed, InACESTonemapParams.GamutCompression);
|
|
|
|
const FColorSpace UE_ACES_AP1_DISPLAY_PRI = GetColorSpace(TONEMAPPER_GAMUT_ACEScg_D60);
|
|
const FColorSpace UE_ACES_AP1_LIMITING_PRI = GetColorSpace(TONEMAPPER_GAMUT_ACEScg_D60);
|
|
float3 OutputReferredLinearAP1Color = outputTransform(aces, InACESTonemapParams.AcesParams, UE_ACES_AP1_DISPLAY_PRI, UE_ACES_AP1_LIMITING_PRI, UE_ACES_EOTF,
|
|
UE_ACES_SURROUND, UE_ACES_STRETCH_BLACK, UE_ACES_D60_SIM, UE_ACES_LEGAL_RANGE);
|
|
|
|
return OutputReferredLinearAP1Color;
|
|
}
|
|
|
|
float3 ACESOutputTransform( float3 SceneReferredLinearsRGBColor, FACESTonemapParams InACESTonemapParams)
|
|
{
|
|
const float3x3 sRGB_2_AP0 = mul( XYZ_2_AP0_MAT, mul( D65_2_D60_CAT, sRGB_2_XYZ_MAT ) );
|
|
|
|
return ACESOutputTransform( SceneReferredLinearsRGBColor, sRGB_2_AP0, InACESTonemapParams);
|
|
}
|
|
#endif //USE_ACES_2
|
|
|
|
static const float3x3 GamutMappingIdentityMatrix = { 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 };
|
|
|
|
//
|
|
// Gamut conversion matrices
|
|
//
|
|
float3x3 OuputGamutMappingMatrix( uint OutputGamut )
|
|
{
|
|
// Gamut mapping matrices used later
|
|
const float3x3 AP1_2_sRGB = mul( XYZ_2_sRGB_MAT, mul( D60_2_D65_CAT, AP1_2_XYZ_MAT ) );
|
|
const float3x3 AP1_2_DCI_D65 = mul( XYZ_2_P3D65_MAT, mul( D60_2_D65_CAT, AP1_2_XYZ_MAT ) );
|
|
const float3x3 AP1_2_Rec2020 = mul( XYZ_2_Rec2020_MAT, mul( D60_2_D65_CAT, AP1_2_XYZ_MAT ) );
|
|
|
|
// Set gamut mapping matrix
|
|
// 0 = sRGB - D65
|
|
// 1 = P3 - D65
|
|
// 2 = Rec.2020 - D65
|
|
// 3 = ACES AP0 - D60
|
|
// 4 = ACES AP1 - D60
|
|
|
|
float3x3 GamutMappingMatrix = AP1_2_sRGB;
|
|
if( OutputGamut == TONEMAPPER_GAMUT_DCIP3_D65)
|
|
GamutMappingMatrix = AP1_2_DCI_D65;
|
|
else if( OutputGamut == TONEMAPPER_GAMUT_Rec2020_D65)
|
|
GamutMappingMatrix = AP1_2_Rec2020;
|
|
else if( OutputGamut == TONEMAPPER_GAMUT_ACES_D60)
|
|
GamutMappingMatrix = AP1_2_AP0_MAT;
|
|
else if( OutputGamut == TONEMAPPER_GAMUT_ACEScg_D60)
|
|
GamutMappingMatrix = GamutMappingIdentityMatrix;
|
|
|
|
return GamutMappingMatrix;
|
|
}
|
|
|
|
float3x3 OuputInverseGamutMappingMatrix( uint OutputGamut )
|
|
{
|
|
// Gamut mapping matrices used later
|
|
const float3x3 sRGB_2_AP1 = mul( XYZ_2_AP1_MAT, mul( D65_2_D60_CAT, sRGB_2_XYZ_MAT ) );
|
|
const float3x3 DCI_D65_2_AP1 = mul( XYZ_2_AP1_MAT, mul( D65_2_D60_CAT, P3D65_2_XYZ_MAT ) );
|
|
const float3x3 Rec2020_2_AP1 = mul( XYZ_2_AP1_MAT, mul( D65_2_D60_CAT, Rec2020_2_XYZ_MAT ) );
|
|
|
|
// Set gamut mapping matrix
|
|
// 0 = sRGB - D65
|
|
// 1 = P3 (DCI) - D65
|
|
// 2 = Rec.2020 - D65
|
|
// 3 = ACES AP0 - D60
|
|
float3x3 GamutMappingMatrix = sRGB_2_AP1;
|
|
if( OutputGamut == TONEMAPPER_GAMUT_DCIP3_D65)
|
|
GamutMappingMatrix = DCI_D65_2_AP1;
|
|
else if( OutputGamut == TONEMAPPER_GAMUT_Rec2020_D65)
|
|
GamutMappingMatrix = Rec2020_2_AP1;
|
|
else if( OutputGamut == TONEMAPPER_GAMUT_ACES_D60)
|
|
GamutMappingMatrix = AP0_2_AP1_MAT;
|
|
else if (OutputGamut == TONEMAPPER_GAMUT_ACEScg_D60)
|
|
GamutMappingMatrix = GamutMappingIdentityMatrix;
|
|
|
|
return GamutMappingMatrix;
|
|
}
|
|
|
|
// Accurate for 1000K < Temp < 15000K
|
|
// [Krystek 1985, "An algorithm to calculate correlated colour temperature"]
|
|
float2 PlanckianLocusChromaticity( float Temp )
|
|
{
|
|
float u = ( 0.860117757f + 1.54118254e-4f * Temp + 1.28641212e-7f * Temp*Temp ) / ( 1.0f + 8.42420235e-4f * Temp + 7.08145163e-7f * Temp*Temp );
|
|
float v = ( 0.317398726f + 4.22806245e-5f * Temp + 4.20481691e-8f * Temp*Temp ) / ( 1.0f - 2.89741816e-5f * Temp + 1.61456053e-7f * Temp*Temp );
|
|
|
|
float x = 3*u / ( 2*u - 8*v + 4 );
|
|
float y = 2*v / ( 2*u - 8*v + 4 );
|
|
|
|
return float2(x,y);
|
|
}
|
|
|
|
// Accurate for 4000K < Temp < 25000K
|
|
// in: correlated color temperature
|
|
// out: CIE 1931 chromaticity
|
|
float2 D_IlluminantChromaticity( float Temp )
|
|
{
|
|
// Correct for revision of Plank's law
|
|
// This makes 6500 == D65
|
|
Temp *= 1.4388 / 1.438;
|
|
float OneOverTemp = 1.0/Temp;
|
|
float x = Temp <= 7000 ?
|
|
0.244063 + ( 0.09911e3 + ( 2.9678e6 - 4.6070e9 * OneOverTemp ) * OneOverTemp) * OneOverTemp:
|
|
0.237040 + ( 0.24748e3 + ( 1.9018e6 - 2.0064e9 * OneOverTemp ) * OneOverTemp ) * OneOverTemp;
|
|
|
|
float y = -3 * x*x + 2.87 * x - 0.275;
|
|
|
|
return float2(x,y);
|
|
}
|
|
|
|
// Find closest color temperature to chromaticity
|
|
// [McCamy 1992, "Correlated color temperature as an explicit function of chromaticity coordinates"]
|
|
float CorrelatedColorTemperature( float x, float y )
|
|
{
|
|
float n = (x - 0.3320) / (y - 0.1858);
|
|
return -449 * n*n*n + 3525 * n*n - 6823.3 * n + 5520.33;
|
|
}
|
|
|
|
float2 PlanckianIsothermal( float Temp, float Tint )
|
|
{
|
|
float u = ( 0.860117757f + 1.54118254e-4f * Temp + 1.28641212e-7f * Temp*Temp ) / ( 1.0f + 8.42420235e-4f * Temp + 7.08145163e-7f * Temp*Temp );
|
|
float v = ( 0.317398726f + 4.22806245e-5f * Temp + 4.20481691e-8f * Temp*Temp ) / ( 1.0f - 2.89741816e-5f * Temp + 1.61456053e-7f * Temp*Temp );
|
|
|
|
float ud = ( -1.13758118e9f - 1.91615621e6f * Temp - 1.53177f * Temp*Temp ) / Square( 1.41213984e6f + 1189.62f * Temp + Temp*Temp );
|
|
float vd = ( 1.97471536e9f - 705674.0f * Temp - 308.607f * Temp*Temp ) / Square( 6.19363586e6f - 179.456f * Temp + Temp*Temp );
|
|
|
|
float2 uvd = normalize(float2(ud, vd));
|
|
|
|
// Correlated color temperature is meaningful within +/- 0.05
|
|
u += uvd.y * Tint * 0.05;
|
|
v += -uvd.x * Tint * 0.05;
|
|
|
|
float x = 3*u / ( 2*u - 8*v + 4 );
|
|
float y = 2*v / ( 2*u - 8*v + 4 );
|
|
|
|
return float2(x,y);
|
|
}
|
|
|
|
float3 WhiteBalance(float3 LinearColor, float WhiteTemp, float WhiteTint, bool bIsTemperatureWhiteBalance, const float3x3 WCS_2_XYZ, const float3x3 XYZ_2_WCS)
|
|
{
|
|
float2 SrcWhiteDaylight = D_IlluminantChromaticity(WhiteTemp);
|
|
float2 SrcWhitePlankian = PlanckianLocusChromaticity(WhiteTemp);
|
|
|
|
float2 SrcWhite = WhiteTemp < 4000 ? SrcWhitePlankian : SrcWhiteDaylight;
|
|
float2 D65White = float2(0.31270, 0.32900);
|
|
|
|
{
|
|
// Offset along isotherm
|
|
float2 Isothermal = PlanckianIsothermal(WhiteTemp, WhiteTint) - SrcWhitePlankian;
|
|
SrcWhite += Isothermal;
|
|
}
|
|
|
|
if (!bIsTemperatureWhiteBalance)
|
|
{
|
|
float2 Temp = SrcWhite;
|
|
SrcWhite = D65White;
|
|
D65White = Temp;
|
|
}
|
|
|
|
float3x3 WhiteBalanceMat = ChromaticAdaptation(SrcWhite, D65White);
|
|
WhiteBalanceMat = mul( XYZ_2_WCS, mul( WhiteBalanceMat, WCS_2_XYZ ) );
|
|
|
|
return mul(WhiteBalanceMat, LinearColor);
|
|
}
|
|
|
|
float3 HableToneMapCurve(float3 X)
|
|
{
|
|
const float A = 0.15f;
|
|
const float B = 0.50f;
|
|
const float C = 0.10f;
|
|
const float D = 0.20f;
|
|
const float E = 0.02f;
|
|
const float F = 0.30f;
|
|
|
|
return ((X*(A*X+C*B)+D*E)/(X*(A*X+B)+D*F))-E/F;
|
|
}
|
|
|
|
float3 HableToneMap(float3 LinearColor)
|
|
{
|
|
LinearColor = max(0, LinearColor);
|
|
|
|
const float3 W = 11.2f;
|
|
const float3 WhiteScale = 1.0f / HableToneMapCurve(W);
|
|
const float ExposureBias = 2.0f;
|
|
|
|
return HableToneMapCurve(LinearColor * ExposureBias) * WhiteScale;
|
|
}
|
|
|
|
float3 SimpleReinhardToneMap(float3 LinearColor)
|
|
{
|
|
return LinearColor / (1.0f + LinearColor);
|
|
}
|