#version 450 // build_shaders: keep functions // // Copyright (c) 2025 Carlos Lopez Jr. // Copyright (C) 2026 Carlos Lopez // SPDX-License-Identifier: MIT // // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated // documentation files (the "Software"), to deal in the Software without restriction, including without limitation the // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in all copies or substantial portions of the // Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE // WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // // The HDR tonemap, as a function that runtime/vk_hdr.c (vk_hdr_shader_swap) splices into the game's own tonemap // shader. nx_tonemap takes x, the three values the game feeds its fitted ACES curve (its scene light after its colour // matrix, bloom, exposure and, in the gameplay shader, local exposure), and scene, the same values without local // exposure (rgb) with the exposure gain in them (a; 1 where the splice found none). It returns the colour the shader then stores, linear Rec. 709 // relative to the HUD's white, which the present encodes to PQ (shaders/hdr_encode.comp). main only exists so the // compiler keeps the functions; vk_hdr.c drops it. build_shaders.py compiles this file without optimisation ("keep // functions" above), as inlining would leave no function to splice. // // Three tone mappers (p0.w): // - 0, the game's curve: its SDR result at the picture's white. // - 9, the observer-response mapper (scene_tonemap, psycho35): the scene light goes through a finite cone response // in LMS, anchored so that scene grey 0.18 lands where the game's curve puts it (or at 0.18 times the gain) and, // with the tone slope matched, rising through it as steeply as the game's curve does at its steepest; the response // saturates at the display's peak. Chroma is the response's residual around its mean, scaled back just enough to // fit the target gamut. It takes the scene without local exposure. Rec. 709 is the target here: the game's scene // target is r11g11b10f, which holds no negative component, so a wider fit would be clipped channel by channel. // - 3, the luminance mapper (drt): the game's SDR result is the colour grade, upgraded to the HDR range by luminance // against a neutral SDR curve of the same input, then a luminance curve towards the peak with exposure, // highlights, shadows, contrast and flare, and in OkLab the hue of the input, saturation, highlight saturation and // blowout. // Settings (vk_hdr.c vk_hdr_support, support buffer bytes 1440..1519): // p0: peak nits, game nits (white of the picture), HUD nits, tone mapper (-1: the game's own SDR picture, as when the // swapchain is not HDR10; else as above) // p1: exposure, highlights, shadows, contrast // p2: saturation, highlight saturation, blowout, flare (parsed: 1 = unchanged for the first two) // p3: hue correction, grade strength, gamma correction (0 off, 1: 2.2, 2: 2.4; applied on the present), tone slope // p4: hue clip emulation (0..1), mid grey (0: 0.18 times the gain, 1: the game's curve at 0.18), match tone slope // (0 or 1), unused layout(location = 0) in vec4 a0; layout(location = 1) in vec4 a1; layout(location = 2) in vec4 a2; layout(location = 3) in vec4 a3; layout(location = 4) in vec4 a4; layout(location = 5) in vec4 a5; layout(location = 6) in vec4 a6; layout(location = 0) out vec4 o; // Matrices are written row by row; mulm(m, v) is the row-vector product of that layout. vec3 mulm(mat3 m, vec3 v) { return v * m; } const mat3 BT709_TO_AP1 = mat3(0.6130974024, 0.3395231462, 0.0473794514, 0.0701937225, 0.9163538791, 0.0134523985, 0.0206155929, 0.1095697729, 0.8698146342); const mat3 AP1_TO_BT709 = mat3(1.7050509927, -0.6217921207, -0.0832588720, -0.1302564175, 1.1408047366, -0.0105483191, -0.0240033568, -0.1289689761, 1.1529723329); const mat3 BT709_TO_OKLABLMS = mat3(0.4122214708, 0.5363325363, 0.0514459929, 0.2119034982, 0.6806995451, 0.1073969566, 0.0883024619, 0.2817188376, 0.6299787005); const mat3 OKLABLMS_TO_OKLAB = mat3(0.2104542553, 0.7936177850, -0.0040720468, 1.9779984951, -2.4285922050, 0.4505937099, 0.0259040371, 0.7827717662, -0.8086757660); const mat3 OKLAB_TO_OKLABLMS = mat3(1.0, 0.3963377774, 0.2158037573, 1.0, -0.1055613458, -0.0638541728, 1.0, -0.0894841775, -1.2914855480); const mat3 OKLABLMS_TO_BT709 = mat3(4.0767416621, -3.3077115913, 0.2309699292, -1.2684380046, 2.6097574011, -0.3413193965, -0.0041960863, -0.7034186147, 1.7076147010); float y709(vec3 c) { return dot(c, vec3(0.2126390059, 0.7151686788, 0.0721923154)); } float divide_safe(float a, float b, float fallback) { return b == 0.0 ? fallback : a / b; } vec3 copy_sign(vec3 mag, vec3 s) { vec3 a = abs(mag); return mix(a, -a, lessThan(s, vec3(0.0))); } vec3 cbrt(vec3 x) { return copy_sign(pow(abs(x), vec3(1.0 / 3.0)), x); } vec3 oklab_from_bt709(vec3 c) { return mulm(OKLABLMS_TO_OKLAB, cbrt(mulm(BT709_TO_OKLABLMS, c))); } vec3 bt709_from_oklab(vec3 lab) { vec3 lms = mulm(OKLAB_TO_OKLABLMS, lab); return mulm(OKLABLMS_TO_BT709, lms * lms * lms); } vec3 clamp_ap1(vec3 c) { return mulm(AP1_TO_BT709, max(mulm(BT709_TO_AP1, c), vec3(0.0))); } // The hue (OkLab a, b direction) of correct with the chrominance of incorrect. vec3 hue_oklab(vec3 incorrect, vec3 correct) { vec3 il = oklab_from_bt709(incorrect), cl = oklab_from_bt709(correct); float pre = length(il.yz); vec2 ab = cl.yz; ab *= divide_safe(pre, length(ab), 1.0); il.yz = ab; return clamp_ap1(bt709_from_oklab(il)); } float srgb_decode(float c) { return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4); } // pow_to_srgb: a value of a gamma-g picture as the sRGB value of the same code (the peak's correction). float gamma_to_srgb(float c, float g) { return srgb_decode(pow(c, 1.0 / g)); } float smoother(float t) { return t * t * t * (t * (t * 6.0 - 15.0) + 10.0); } float highlights(float x, float h, float mid) { if (h == 1.0) return x; float t = 0.0; if (x > mid) t = clamp(log2(x / mid) / log2(1.0 / mid), 0.0, 1.0); t = smoother(t); if (h > 1.0) return mix(x, mid * pow(x / mid, h), t); float b = mid * pow(x / mid, 2.0 - h); return divide_safe(x * x, mix(x, b, t), x); } float shadows(float x, float s, float mid) { if (s == 1.0) return x; float ratio = max(divide_safe(x, mid, 0.0), 0.0); float base_term = x * mid; float base_scale = divide_safe(base_term, ratio, 0.0); float shadow_floor = mid / 16.0; float t = 1.0; if (x > shadow_floor) t = clamp(log2(x / mid) / log2(shadow_floor / mid), 0.0, 1.0); t = smoother(t); if (s > 1.0) { float raised = x * (1.0 + divide_safe(base_term, pow(ratio, s), 0.0)); return x + (raised - x * (1.0 + base_scale)) * t; } float lowered = x * (1.0 - divide_safe(base_term, pow(ratio, 2.0 - s), 0.0)); return x + (lowered - x * (1.0 - base_scale)) * t; } // The luminance curve: n peak nits, g contrast, c_d mid grey in nits, t_1 flare; 100 nits reference, scene grey 0.18. float curve(float x, float n, float g, float c_d, float t_1) { const float n_r = 100.0, c = 0.18, w_g = 0.0, r_hit_min = 128.0, r_hit_max = 256.0; float m_0 = n / n_r; float m_1 = 0.5 * (m_0 + sqrt(m_0 * (m_0 + 4.0 * t_1))); float r_hit = r_hit_min + (r_hit_max - r_hit_min) * (log(m_0) / log(10000.0 / 100.0)); float u = pow((r_hit / m_1) / ((r_hit / m_1) + 1.0), g); float m = m_1 / u; float w_i = log(n / 100.0) / log(2.0); float c_t = (c_d / n_r) * (1.0 + w_i * w_g); float g_ip = 0.5 * (c_t + sqrt(c_t * (c_t + 4.0 * t_1))); float g_ipp2 = -m_1 * pow(g_ip / m, 1.0 / g) / (pow(g_ip / m, 1.0 / g) - 1.0); float w_2 = c / g_ipp2; float s_2 = w_2 * m_1; float u_2 = pow((r_hit / m_1) / ((r_hit / m_1) + w_2), g); float m_2 = m_1 / u_2; float ts = pow(max(0.0, x) / (x + s_2), g) * m_2; return max(0.0, (ts * ts) / (ts + t_1)); } struct Drt { float nits_peak, exposure, highlights, shadows, contrast, saturation, dechroma, flare, hue, blowout; float mid_gray_nits; bool clamp_zero; // clamp to Rec. 709 (no negative channel) before the peak }; // The tone mapper by luminance, then hue, saturation and blowout in OkLab; clamped to the peak in Rec. 709. vec3 drt(vec3 bt709, Drt d) { const float mid = 0.18; float peak = d.nits_peak / 100.0; float y_original = y709(bt709); float y = y_original * d.exposure; y = highlights(y, d.highlights, mid); y = shadows(y, d.shadows, mid); float y_new = clamp(curve(y, d.nits_peak, d.contrast, d.mid_gray_nits, d.flare), 0.0, peak); vec3 color = bt709 * (y_original > 0.0 ? y_new / y_original : 0.0); if (d.dechroma != 0.0 || d.saturation != 1.0 || d.hue != 0.0 || d.blowout != 0.0) { vec3 lab = oklab_from_bt709(color); if (d.hue != 0.0) { vec3 old_lab = oklab_from_bt709(bt709); float pre = length(lab.yz); lab.yz = mix(lab.yz, old_lab.yz, d.hue); lab.yz *= divide_safe(pre, length(lab.yz), 1.0); } if (d.dechroma != 0.0) lab.yz *= mix(1.0, 0.0, clamp(pow(y_original / 100.0, 1.0 - d.dechroma), 0.0, 1.0)); if (d.blowout != 0.0) { float percent_max = clamp(y_original * 100.0 / 10000.0, 0.0, 1.0); float change = pow(1.0 - percent_max, 100.0 * abs(d.blowout)); if (d.blowout < 0.0) change = 2.0 - change; lab.yz *= change; } lab.yz *= d.saturation; color = bt709_from_oklab(lab); } if (d.clamp_zero) color = max(color, vec3(0.0)); return min(color, vec3(peak)); } // The same curve at SDR range with nothing changed: what the SDR grade is measured against. vec3 neutral_sdr(vec3 c) { Drt d = Drt(100.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 18.0, true); return drt(c, d); } // The graded SDR colour carried to the HDR range: its luminance gains what the untonemapped colour has above the // neutral SDR curve, in the graded colour's hue. vec3 upgrade(vec3 untonemapped, vec3 neutral, vec3 graded, float strength) { float yu = y709(untonemapped), yn = y709(neutral), yg = y709(graded); float ratio; if (yu < yn) { ratio = yu / yn; } else { float y_new = yg + max(0.0, yu - yn); ratio = yg > 0.0 ? y_new / yg : 0.0; } vec3 scaled = hue_oklab(graded * ratio, graded); return mix(untonemapped, scaled, strength); } vec3 aces_fitted(vec3 x) { // the game's curve and clamp return clamp(x * (2.51 * x + 0.03) / (x * (2.43 * x + 0.59) + 0.14), 0.0, 1.0); } // ---- the observer-response mapper // Rec. 709 (D65) to the cone fundamentals LMS of the two-degree observer and back, and LMS to Rec. 2020; rows. The // products of the XYZ matrices of each, worked out in double precision. const mat3 PSY_BT709_TO_LMS = mat3(0.2896057766, 0.6972466442, 0.0763712786, 0.0901837576, 0.7073490257, 0.1122031464, 0.0155287401, 0.0536093073, 0.5097978305); const mat3 PSY_LMS_TO_BT709 = mat3(4.9676196505, -4.9223795294, 0.3391991812, -0.6196828788, 2.0517506515, -0.3587439844, -0.0861520040, -0.0658193830, 1.9889544833); const mat3 PSY_LMS_TO_BT2020 = mat3(2.9089213537, -2.4155642448, 0.1808342948, -0.2275532730, 1.5457966613, -0.2838427127, -0.0502712321, 0.0409489517, 1.7552839121); const vec3 PSY_YF_WEIGHTS = vec3(0.68990272, 0.34832189, 0.0); // luminance of the observer from L and M const vec3 PSY_D65_WHITE_LMS = vec3(1.0632236993, 0.9097359297, 0.5789358779); // PSY_BT709_TO_LMS of white // Exact mean on equal-component vectors. float psy_mean(vec3 v) { return v.x + ((v.y - v.x) + (v.z - v.x)) / 3.0; } // A residual in white-normalised LMS as the displacement it is in the target's RGB (0: Rec. 709, else Rec. 2020). vec3 psy_target_residual(vec3 normalized_lms, int target) { vec3 physical_lms = normalized_lms * PSY_D65_WHITE_LMS; return target == 0 ? mulm(PSY_LMS_TO_BT709, physical_lms) : mulm(PSY_LMS_TO_BT2020, physical_lms); } // The finite response u of one cone in the log domain: log_u, log_tail = log(1 - u^h) and log_deficit = log(1 - u), // kept as logarithms so that neither end underflows. void psy_response_logs(float log_q, float k, float n, float h, out float log_u, out float log_tail, out float log_deficit) { float latent = log(k) - log(1.0 - k) + n * log_q; float correction = log(1.0 + exp(-abs(latent))); log_u = (min(latent, 0.0) - correction) / h; log_tail = -max(latent, 0.0) - correction; log_deficit = latent > 20.0 ? log_tail - log(h) : log(abs(log_u) < 0.01 ? -log_u * (1.0 + log_u * (0.5 + log_u * (1.0 / 6.0 + log_u / 24.0))) : 1.0 - exp(log_u)); } struct PsyReference { vec3 source_ratio; // the input against its adaptation anchor, largest component 1 vec3 log_source_ratio; vec3 anchor_power; vec3 input_exponent; float response_compression; float peak; }; struct PsySample { float mean; // the response's mean over the cones, in peak units times the peak float headroom; // what is left up to the peak, from the deficits vec3 residual; // the chroma: the response around its mean, its direction half way to the source's }; // The response of the three cones at exposure_stops above the reference's own drive. PsySample psy_reference_at(PsyReference reference, float exposure_stops) { vec3 response, deficit; for (int i = 0; i < 3; ++i) { if (reference.source_ratio[i] == 0.0) { response[i] = 0.0; deficit[i] = 1.0; } else { float log_u, log_tail, log_deficit; psy_response_logs(reference.log_source_ratio[i] + exposure_stops * log(2.0), reference.anchor_power[i], reference.input_exponent[i], reference.response_compression, log_u, log_tail, log_deficit); response[i] = exp(log_u); deficit[i] = exp(log_deficit); } } float response_mean = psy_mean(response); vec3 response_residual = response_mean > 0.5 ? psy_mean(deficit) - deficit : response - response_mean; // normalise before squaring: the length can underflow where the vector itself does not float residual_scale = max(abs(response_residual.x), max(abs(response_residual.y), abs(response_residual.z))); vec3 scaled_residual = residual_scale > 0.0 ? response_residual / residual_scale : vec3(0.0); float scaled_radius = length(scaled_residual); float radius = residual_scale * scaled_radius; vec3 direction = scaled_radius > 0.0 ? scaled_residual / scaled_radius : vec3(0.0); vec3 source = reference.source_ratio - psy_mean(reference.source_ratio); float source_radius = length(source); if (source_radius > 0.0 && radius > 0.0) { vec3 midpoint_direction = source / source_radius + direction; float midpoint_length = length(midpoint_direction); if (midpoint_length > 0.0) direction = midpoint_direction / midpoint_length; } PsySample s; s.mean = reference.peak * response_mean; s.headroom = reference.peak * psy_mean(deficit); s.residual = reference.peak * radius * direction; return s; } // Extended linear Rec. 709 in, relative to reference white; the same out, inside the target gamut and below peak. // anchor_in is the scene grey the eye is adapted to, anchor_out where it lands; cone is the response's exponent. vec3 psycho35(vec3 bt709, float peak, float highlights, float shadows, float contrast, float purity_scale, float cone, float anchor_in_gray, float anchor_out_gray, int target) { vec3 input_lms = mulm(PSY_BT709_TO_LMS, bt709); vec3 anchor_in = mulm(PSY_BT709_TO_LMS, vec3(anchor_in_gray)); vec3 anchor_out = anchor_out_gray == anchor_in_gray ? anchor_in : mulm(PSY_BT709_TO_LMS, vec3(anchor_out_gray)); if (highlights != 1.0 || shadows != 1.0) { float input_yf = dot(PSY_YF_WEIGHTS, input_lms); float anchor_yf = dot(PSY_YF_WEIGHTS, anchor_in); float graded_y = input_yf; if (highlights != 1.0) { float ratio = graded_y / anchor_yf; float blend = graded_y > anchor_yf ? clamp(log2(ratio) / log2(1.0 / anchor_yf), 0.0, 1.0) : 0.0; blend = smoother(blend); float shaped = pow(ratio, abs(highlights - 1.0)); graded_y = highlights > 1.0 ? graded_y * mix(1.0, shaped, blend) : graded_y / mix(1.0, shaped, blend); } if (shadows != 1.0) { float ratio = graded_y / anchor_yf; float blend = graded_y > anchor_yf * exp2(-4.0) ? clamp(log2(ratio) / -4.0, 0.0, 1.0) : 1.0; blend = smoother(blend); float target_y = shadows > 1.0 ? graded_y * (1.0 - anchor_yf * anchor_yf) + anchor_yf * anchor_yf * anchor_yf * pow(ratio, 2.0 - shadows) : graded_y * (1.0 + anchor_yf * anchor_yf) - anchor_yf * anchor_yf * anchor_yf * pow(ratio, shadows); graded_y = mix(graded_y, target_y, blend); } if (input_yf != 0.0) input_lms *= graded_y / input_yf; } // purity (saturation) around the neutral of the same luminance, relative to the adaptation vec3 source_ratio = input_lms / anchor_in; if (purity_scale != contrast) { float neutral_ratio = dot(PSY_YF_WEIGHTS, input_lms) / dot(PSY_YF_WEIGHTS, anchor_in); vec3 purity_direction = source_ratio - neutral_ratio; float purity_amount = purity_scale / contrast; // more purity must not turn a valid cone input negative: the common amount is bounded, not single cones if (all(greaterThanEqual(source_ratio, vec3(0.0))) && neutral_ratio > 0.0 && purity_amount > 1.0) { for (int c = 0; c < 3; ++c) if (purity_direction[c] < 0.0) purity_amount = min(purity_amount, neutral_ratio / -purity_direction[c]); source_ratio = max(neutral_ratio + purity_amount * purity_direction, 0.0); } else { source_ratio = neutral_ratio + purity_amount * purity_direction; } } PsyReference reference; float response_power = contrast * cone; reference.response_compression = 1.0; reference.peak = peak; reference.anchor_power = pow(anchor_out / (PSY_D65_WHITE_LMS * reference.peak), vec3(reference.response_compression)); reference.input_exponent = response_power * reference.response_compression / (1.0 - reference.anchor_power); if (all(equal(source_ratio, vec3(0.0)))) return vec3(0.0); // the exposure factored out: source_ratio = drive * reference.source_ratio float drive = max(abs(source_ratio.x), max(abs(source_ratio.y), abs(source_ratio.z))); reference.source_ratio = source_ratio / drive; reference.log_source_ratio = log(vec3(reference.source_ratio.x != 0.0 ? reference.source_ratio.x : 1.0, reference.source_ratio.y != 0.0 ? reference.source_ratio.y : 1.0, reference.source_ratio.z != 0.0 ? reference.source_ratio.z : 1.0)); PsySample actual = psy_reference_at(reference, log2(drive)); if (all(equal(actual.residual, vec3(0.0)))) return vec3(actual.mean); // neutral: nothing to fit // the exact fit: the chroma scaled until the nearest face of the target's cube (0 or the peak) is touched vec3 target_displacement = psy_target_residual(actual.residual, target); float scale = 1.0; for (int channel = 0; channel < 3; ++channel) { if (target_displacement[channel] > 0.0) scale = min(scale, actual.headroom / target_displacement[channel]); else if (target_displacement[channel] < 0.0) scale = min(scale, actual.mean / -target_displacement[channel]); } return actual.mean + psy_target_residual(actual.residual * scale, 0); } // The bend the game's clamp gives a bright colour (a clipped channel stops, the others catch up, the hue turns towards // yellow, cyan or white), given to the unclamped colour: the curve's result, stretched back over the colour's own // range of magnitudes, at the colour's luminance. vec3 hue_clip(vec3 untonemapped, float amount) { vec3 magnitude = abs(untonemapped); vec3 reference = aces_fitted(magnitude); float low = min(reference.x, min(reference.y, reference.z)); float range = max(reference.x, max(reference.y, reference.z)) - low; bool neutral = range == 0.0; float mag_low = min(magnitude.x, min(magnitude.y, magnitude.z)); float mag_high = max(magnitude.x, max(magnitude.y, magnitude.z)); vec3 transferred = mix(vec3(mag_low), vec3(mag_high), (reference - low) / (neutral ? 1.0 : range)); transferred = copy_sign(transferred, untonemapped); if (neutral) transferred = untonemapped; vec3 bent = mix(untonemapped, transferred, amount); float original_y = y709(untonemapped), bent_y = y709(bent); if (original_y > 0.0 && bent_y > 0.0) untonemapped = bent * (original_y / bent_y); return untonemapped; } // The scene (before the exposure gain) through the observer-response mapper, in picture whites. vec3 scene_tonemap(vec3 untonemapped, float gain, vec4 p0, vec4 p1, vec4 p2, vec4 p3, vec4 p4) { if (p1.x == 0.0) return vec3(0.0); // zero exposure is black; the mapper needs a positive anchor float peak_nits = max(p0.x, p0.y); float reference_exposure = p4.y == 1.0 ? aces_fitted(vec3(0.18)).x / 0.18 : 1.0; if (p4.x > 0.0) untonemapped = hue_clip(untonemapped, p4.x); // the log-log slope x V'(x) / V(x) of the game's curve where V''(x) = 0, at x = 0.120305925 float cone = p4.z != 0.0 ? 1.3355037565264822 : 1.0; float anchor_in = 0.18; float anchor_out = anchor_in * gain * reference_exposure * p1.x; return psycho35(untonemapped, peak_nits / p0.y, p1.y, p1.z, p1.w, p2.x, cone * p3.w, anchor_in, anchor_out, 0); } vec3 nx_tonemap(vec3 x, vec4 scene, vec4 p0, vec4 p1, vec4 p2, vec4 p3, vec4 p4) { vec3 vanilla = aces_fitted(x); if (p0.w < 0.0) return vanilla; vec3 color = vanilla; if (p0.w == 9.0) { // the mapper takes the light before the gain; without a gain there is no light color = scene.a > 0.0 ? scene_tonemap(scene.rgb / scene.a, scene.a, p0, p1, p2, p3, p4) : vec3(0.0); } else if (p0.w > 0.0) { vec3 graded = p3.y == 0.0 ? x : upgrade(x, neutral_sdr(x), vanilla, p3.y); float peak = p0.x / p0.y; // the display's peak in picture whites; corrected for the present's gamma if (p3.z != 0.0) peak = gamma_to_srgb(peak, p3.z == 1.0 ? 2.2 : 2.4); Drt d = Drt(peak * 100.0, p1.x, p1.y, p1.z, p1.w, p2.x, p2.z, 0.10 * pow(p2.w, 10.0), p3.x, -(p2.y - 1.0), 18.0, false); color = drt(graded, d); } color *= p0.y / p0.z; // the picture's white against the HUD's return mix(color, vec3(0.0), isnan(color)); } void main() { o = vec4(nx_tonemap(a0.xyz, a1, a2, a3, a4, a5, a6), 1.0); }