You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
290 lines
7.0 KiB
290 lines
7.0 KiB
#ifndef __COLOR_GRADING__
|
|
#define __COLOR_GRADING__
|
|
|
|
#include "ACES.cginc"
|
|
#include "Common.cginc"
|
|
|
|
// Set to 1 to use more precise but more expensive log/linear conversions. I haven't found a proper
|
|
// use case for the high precision version yet so I'm leaving this to 0.
|
|
#define COLOR_GRADING_PRECISE_LOG 0
|
|
|
|
//
|
|
// Alexa LogC converters (El 1000)
|
|
// See http://www.vocas.nl/webfm_send/964
|
|
// It's a good fit to store HDR values in log as the range is pretty wide (1 maps to ~58.85666) and
|
|
// is quick enough to compute.
|
|
//
|
|
struct ParamsLogC
|
|
{
|
|
half cut;
|
|
half a, b, c, d, e, f;
|
|
};
|
|
|
|
static const ParamsLogC LogC =
|
|
{
|
|
0.011361, // cut
|
|
5.555556, // a
|
|
0.047996, // b
|
|
0.244161, // c
|
|
0.386036, // d
|
|
5.301883, // e
|
|
0.092819 // f
|
|
};
|
|
|
|
half LinearToLogC_Precise(half x)
|
|
{
|
|
half o;
|
|
if (x > LogC.cut)
|
|
o = LogC.c * log10(LogC.a * x + LogC.b) + LogC.d;
|
|
else
|
|
o = LogC.e * x + LogC.f;
|
|
return o;
|
|
}
|
|
|
|
half3 LinearToLogC(half3 x)
|
|
{
|
|
#if COLOR_GRADING_PRECISE_LOG
|
|
return half3(
|
|
LinearToLogC_Precise(x.x),
|
|
LinearToLogC_Precise(x.y),
|
|
LinearToLogC_Precise(x.z)
|
|
);
|
|
#else
|
|
return LogC.c * log10(LogC.a * x + LogC.b) + LogC.d;
|
|
#endif
|
|
}
|
|
|
|
half LogCToLinear_Precise(half x)
|
|
{
|
|
half o;
|
|
if (x > LogC.e * LogC.cut + LogC.f)
|
|
o = (pow(10.0, (x - LogC.d) / LogC.c) - LogC.b) / LogC.a;
|
|
else
|
|
o = (x - LogC.f) / LogC.e;
|
|
return o;
|
|
}
|
|
|
|
half3 LogCToLinear(half3 x)
|
|
{
|
|
#if COLOR_GRADING_PRECISE_LOG
|
|
return half3(
|
|
LogCToLinear_Precise(x.x),
|
|
LogCToLinear_Precise(x.y),
|
|
LogCToLinear_Precise(x.z)
|
|
);
|
|
#else
|
|
return (pow(10.0, (x - LogC.d) / LogC.c) - LogC.b) / LogC.a;
|
|
#endif
|
|
}
|
|
|
|
//
|
|
// White balance
|
|
// Recommended workspace: ACEScg (linear)
|
|
//
|
|
static const half3x3 LIN_2_LMS_MAT = {
|
|
3.90405e-1, 5.49941e-1, 8.92632e-3,
|
|
7.08416e-2, 9.63172e-1, 1.35775e-3,
|
|
2.31082e-2, 1.28021e-1, 9.36245e-1
|
|
};
|
|
|
|
static const half3x3 LMS_2_LIN_MAT = {
|
|
2.85847e+0, -1.62879e+0, -2.48910e-2,
|
|
-2.10182e-1, 1.15820e+0, 3.24281e-4,
|
|
-4.18120e-2, -1.18169e-1, 1.06867e+0
|
|
};
|
|
|
|
half3 WhiteBalance(half3 c, half3 balance)
|
|
{
|
|
half3 lms = mul(LIN_2_LMS_MAT, c);
|
|
lms *= balance;
|
|
return mul(LMS_2_LIN_MAT, lms);
|
|
}
|
|
|
|
//
|
|
// Luminance (Rec.709 primaries according to ACES specs)
|
|
//
|
|
half AcesLuminance(half3 c)
|
|
{
|
|
return dot(c, half3(0.2126, 0.7152, 0.0722));
|
|
}
|
|
|
|
//
|
|
// Offset, Power, Slope (ASC-CDL)
|
|
// Works in Log & Linear. Results will be different but still correct.
|
|
//
|
|
half3 OffsetPowerSlope(half3 c, half3 offset, half3 power, half3 slope)
|
|
{
|
|
half3 so = c * slope + offset;
|
|
so = so > (0.0).xxx ? pow(so, power) : so;
|
|
return so;
|
|
}
|
|
|
|
//
|
|
// Lift, Gamma (pre-inverted), Gain
|
|
// Recommended workspace: ACEScg (linear)
|
|
//
|
|
half3 LiftGammaGain(half3 c, half3 lift, half3 invgamma, half3 gain)
|
|
{
|
|
//return gain * (lift * (1.0 - c) + pow(max(c, kEpsilon), invgamma));
|
|
//return pow(gain * (c + lift * (1.0 - c)), invgamma);
|
|
|
|
half3 power = invgamma;
|
|
half3 offset = lift * gain;
|
|
half3 slope = ((1.0).xxx - lift) * gain;
|
|
return OffsetPowerSlope(c, offset, power, slope);
|
|
}
|
|
|
|
//
|
|
// Saturation (should be used after offset/power/slope)
|
|
// Recommended workspace: ACEScc (log)
|
|
// Optimal range: [0.0, 2.0]
|
|
//
|
|
half3 Saturation(half3 c, half sat)
|
|
{
|
|
half luma = AcesLuminance(c);
|
|
return luma.xxx + sat * (c - luma.xxx);
|
|
}
|
|
|
|
//
|
|
// Basic contrast curve
|
|
// Recommended workspace: ACEScc (log)
|
|
// Optimal range: [0.0, 2.0]
|
|
//
|
|
half3 ContrastLog(half3 c, half con)
|
|
{
|
|
return (c - ACEScc_MIDGRAY) * con + ACEScc_MIDGRAY;
|
|
}
|
|
|
|
//
|
|
// Hue, Saturation, Value
|
|
// Ranges:
|
|
// Hue [0.0, 1.0]
|
|
// Sat [0.0, 1.0]
|
|
// Lum [0.0, HALF_MAX]
|
|
//
|
|
half3 RgbToHsv(half3 c)
|
|
{
|
|
half4 K = half4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
|
|
half4 p = lerp(half4(c.bg, K.wz), half4(c.gb, K.xy), step(c.b, c.g));
|
|
half4 q = lerp(half4(p.xyw, c.r), half4(c.r, p.yzx), step(p.x, c.r));
|
|
half d = q.x - min(q.w, q.y);
|
|
half e = EPSILON;
|
|
return half3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
|
|
}
|
|
|
|
half3 HsvToRgb(half3 c)
|
|
{
|
|
half4 K = half4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
|
|
half3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
|
|
return c.z * lerp(K.xxx, saturate(p - K.xxx), c.y);
|
|
}
|
|
|
|
half RotateHue(half value, half low, half hi)
|
|
{
|
|
return (value < low)
|
|
? value + hi
|
|
: (value > hi)
|
|
? value - hi
|
|
: value;
|
|
}
|
|
|
|
//
|
|
// Remaps Y/R/G/B values
|
|
//
|
|
half3 YrgbCurve(half3 c, sampler2D curveTex)
|
|
{
|
|
const float kHalfPixel = (1.0 / 128.0) / 2.0;
|
|
|
|
// Y
|
|
c += kHalfPixel.xxx;
|
|
float mr = tex2D(curveTex, float2(c.r, 0.75)).a;
|
|
float mg = tex2D(curveTex, float2(c.g, 0.75)).a;
|
|
float mb = tex2D(curveTex, float2(c.b, 0.75)).a;
|
|
c = saturate(float3(mr, mg, mb));
|
|
|
|
// RGB
|
|
c += kHalfPixel.xxx;
|
|
float r = tex2D(curveTex, float2(c.r, 0.75)).r;
|
|
float g = tex2D(curveTex, float2(c.g, 0.75)).g;
|
|
float b = tex2D(curveTex, float2(c.b, 0.75)).b;
|
|
return saturate(half3(r, g, b));
|
|
}
|
|
|
|
//
|
|
// (X) Hue VS Hue - Remaps hue on a curve according to the current hue
|
|
// Input is Hue [0.0, 1.0]
|
|
// Output is Hue [0.0, 1.0]
|
|
//
|
|
half SecondaryHueHue(half hue, sampler2D curveTex)
|
|
{
|
|
half offset = saturate(tex2D(curveTex, half2(hue, 0.25)).x) - 0.5;
|
|
hue += offset;
|
|
hue = RotateHue(hue, 0.0, 1.0);
|
|
return hue;
|
|
}
|
|
|
|
//
|
|
// (Y) Hue VS Saturation - Remaps saturation on a curve according to the current hue
|
|
// Input is Hue [0.0, 1.0]
|
|
// Output is Saturation multiplier [0.0, 2.0]
|
|
//
|
|
half SecondaryHueSat(half hue, sampler2D curveTex)
|
|
{
|
|
return saturate(tex2D(curveTex, half2(hue, 0.25)).y) * 2.0;
|
|
}
|
|
|
|
//
|
|
// (Z) Saturation VS Saturation - Remaps saturation on a curve according to the current saturation
|
|
// Input is Saturation [0.0, 1.0]
|
|
// Output is Saturation multiplier [0.0, 2.0]
|
|
//
|
|
half SecondarySatSat(half sat, sampler2D curveTex)
|
|
{
|
|
return saturate(tex2D(curveTex, half2(sat, 0.25)).z) * 2.0;
|
|
}
|
|
|
|
//
|
|
// (W) Luminance VS Saturation - Remaps saturation on a curve according to the current luminance
|
|
// Input is Luminance [0.0, 1.0]
|
|
// Output is Saturation multiplier [0.0, 2.0]
|
|
//
|
|
half SecondaryLumSat(half lum, sampler2D curveTex)
|
|
{
|
|
return saturate(tex2D(curveTex, half2(lum, 0.25)).w) * 2.0;
|
|
}
|
|
|
|
//
|
|
// Channel mixing (same as Photoshop's and DaVinci's Resolve)
|
|
// Recommended workspace: ACEScg (linear)
|
|
// Input mixers should be in range [-2.0;2.0]
|
|
//
|
|
half3 ChannelMixer(half3 c, half3 red, half3 green, half3 blue)
|
|
{
|
|
return half3(
|
|
dot(c, red),
|
|
dot(c, green),
|
|
dot(c, blue)
|
|
);
|
|
}
|
|
|
|
//
|
|
// LUT grading
|
|
// scaleOffset = (1 / lut_width, 1 / lut_height, lut_height - 1)
|
|
//
|
|
half3 ApplyLut2d(sampler2D tex, half3 uvw, half3 scaleOffset)
|
|
{
|
|
// Strip format where `height = sqrt(width)`
|
|
uvw.z *= scaleOffset.z;
|
|
half shift = floor(uvw.z);
|
|
uvw.xy = uvw.xy * scaleOffset.z * scaleOffset.xy + scaleOffset.xy * 0.5;
|
|
uvw.x += shift * scaleOffset.y;
|
|
uvw.xyz = lerp(tex2D(tex, uvw.xy).rgb, tex2D(tex, uvw.xy + half2(scaleOffset.y, 0)).rgb, uvw.z - shift);
|
|
return uvw;
|
|
}
|
|
|
|
half3 ApplyLut3d(sampler3D tex, half3 uvw)
|
|
{
|
|
return tex3D(tex, uvw).rgb;
|
|
}
|
|
|
|
#endif // __COLOR_GRADING__
|