@photivra/engine 2.13.0 → 2.14.0

package/dist/gpu/wgsl-kernels.js

@@ -13,11 +13,11 @@
  * largest per-sample linear bound of a luminance tone curve (a maximum, not a sum: non-negative float32
  * bit patterns order like their values). `luminanceDomain` counts samples outside the float32 domain.
  */
-export const SDR_COUNTER = Object.freeze({ negative: 0, above: 1, changed: 2, low: 3, high: 4, outOfGamut: 5, uncertain: 6, gamutUncertain: 7,
+export const SDR_COUNTER = /* @__PURE__ */ Object.freeze({ negative: 0, above: 1, changed: 2, low: 3, high: 4, outOfGamut: 5, uncertain: 6, gamutUncertain: 7,
     saturatedPixels: 8, whiteBalanceClipped: 9, reconstructedPixels: 10, linearBoundBits: 11, luminanceDomain: 12 });
 export const SDR_COUNTER_SLOTS = 16;
 /** Tone modes of the luminance kernels (`Params.tone_mode`); 0 is a per-channel curve. */
-export const SDR_TONE_MODE = Object.freeze({ perChannel: 0, extendedReinhard: 1, nakaRushton: 2 });
+export const SDR_TONE_MODE = /* @__PURE__ */ Object.freeze({ perChannel: 0, extendedReinhard: 1, nakaRushton: 2 });
 export const LINEAR_WORKGROUP_SIZE = 256;
 /** RAW_HIGHLIGHT_RECONSTRUCTION_START as a WGSL literal (rounded once to float32 by the compiler). */
 const RAW_HIGHLIGHT_START_WGSL = "0.8";
@@ -31,43 +31,43 @@ const SDR_FUNCTIONS = /* wgsl */ `
 var<workgroup> local_counters: array<atomic<u32>, ${SDR_COUNTER_SLOTS}>;
 fn count(slot: u32) { atomicAdd(&local_counters[slot], 1u); }
 fn encode_srgb(x: f32) -> f32 {
-  if (x == 1.0) { return 1.0; }
-  if (x <= 0.0031308) { return x * 12.92; }
-  return 1.055 * pow(x, 1.0 / 2.4) - 0.055;
+if (x == 1.0) { return 1.0; }
+if (x <= 0.0031308) { return x * 12.92; }
+return 1.055 * pow(x, 1.0 / 2.4) - 0.055;
 }
 fn render_sample(e: f32, source_nonzero: bool, band0: f32, band1: f32, reinhard: bool, reject: bool, maximum: f32) -> u32 {
-  // Gamut decisions (mapped < 0, mapped > 1) depend only on the sign band and, for identity tone, the band at 1.
-  var gamut_uncertain = (e == 0.0 && source_nonzero) || (!reinhard && abs(e - 1.0) <= band1);
-  if (band0 > 0.0 && abs(e) <= band0) { gamut_uncertain = true; }
-  var uncertain = gamut_uncertain || abs(e - 1.0) <= band1;
-  if (reinhard && e > 0.0 && e < 9.5367431640625e-7) { uncertain = true; }
+
+var gamut_uncertain = (e == 0.0 && source_nonzero) || (!reinhard && abs(e - 1.0) <= band1);
+if (band0 > 0.0 && abs(e) <= band0) { gamut_uncertain = true; }
+var uncertain = gamut_uncertain || abs(e - 1.0) <= band1;
+if (reinhard && e > 0.0 && e < 9.5367431640625e-7) { uncertain = true; }
   if (uncertain) { count(${SDR_COUNTER.uncertain}u); }
   if (gamut_uncertain) { count(${SDR_COUNTER.gamutUncertain}u); }
   if (e < 0.0) { count(${SDR_COUNTER.negative}u); }
   if (e > 1.0) { count(${SDR_COUNTER.above}u); }
-  var mapped = e;
-  if (reinhard && e > 0.0) { mapped = e / (1.0 + e); }
+var mapped = e;
+if (reinhard && e > 0.0) { mapped = e / (1.0 + e); }
   if (mapped != e) { count(${SDR_COUNTER.changed}u); }
-  var linear = mapped;
-  if (mapped < 0.0 || mapped > 1.0) {
+var linear = mapped;
+if (mapped < 0.0 || mapped > 1.0) {
     if (reject) { count(${SDR_COUNTER.outOfGamut}u); }
     else if (mapped < 0.0) { count(${SDR_COUNTER.low}u); linear = 0.0; }
     else { count(${SDR_COUNTER.high}u); linear = 1.0; }
-  }
-  let code = floor(encode_srgb(linear) * maximum + 0.5);
-  return u32(clamp(code, 0.0, maximum));
+}
+let code = floor(encode_srgb(linear) * maximum + 0.5);
+return u32(clamp(code, 0.0, maximum));
 }
 fn clear_counters(local_index: u32) {
   if (local_index < ${SDR_COUNTER_SLOTS}u) { atomicStore(&local_counters[local_index], 0u); }
-  workgroupBarrier();
+workgroupBarrier();
 }
 fn flush_counters(local_index: u32) {
-  workgroupBarrier();
+workgroupBarrier();
   if (local_index < ${SDR_COUNTER_SLOTS}u) {
-    let value = atomicLoad(&local_counters[local_index]);
+let value = atomicLoad(&local_counters[local_index]);
     if (local_index == ${SDR_COUNTER.linearBoundBits}u) { atomicMax(&counters[local_index], value); }
-    else if (value > 0u) { atomicAdd(&counters[local_index], value); }
-  }
+else if (value > 0u) { atomicAdd(&counters[local_index], value); }
+}
 }
 `;
 /**
@@ -84,88 +84,88 @@ const LUMINANCE_FUNCTIONS = /* wgsl */ `
 const LU: f32 = 5.9604644775390625e-8;
 const ULP1: f32 = 1.1920928955078125e-7;
 fn count_max(slot: u32, value: f32) { atomicMax(&local_counters[slot], bitcast<u32>(max(value, 0.0))); }
-// (h, eta, abs_h): |h_gpu - h(l)| <= eta*h(l) + abs_h for the exact h at this float32 l > 0.
+
 fn tone_h(l: f32) -> vec3<f32> {
   if (params.tone_mode == ${SDR_TONE_MODE.extendedReinhard}u) {
-    return vec3<f32>((1.0 + l * params.tone.x) / (1.0 + l), 14.0 * LU, 0.0);
-  }
-  let lg = log2(params.tone.x / l);
-  let n = params.tone.y;
-  let z = n * lg;
-  // log2: 2^-21 absolute or 3 ULP; the sigma/l division and sigma's rounding; the product's rounding.
-  let dz = n * (4.76837158203125e-7 + 3.0 * ULP1 * abs(lg) + 9.0 * LU) + 2.0 * LU * abs(z);
-  // exp2: 3 + 2|z| ULP; plus slack for the float64 reference's pow.
-  let rho = 0.7 * dz * (1.0 + dz) + (3.0 + 2.0 * abs(z)) * ULP1 + 9.094947e-13 * (1.0 + abs(z));
-  let eta = 2.0 * rho + 16.0 * LU;
-  if (z >= 0.0) {
-    let p = exp2(-z);
-    var abs_h = 0.0;
-    // Below 2^-120 the power may have flushed to zero: bound h absolutely instead.
-    if (p < 7.52316384526264e-37) { abs_h = params.tone.z * 3.009265538105056e-36 / l; }
-    return vec3<f32>(params.tone.z * p / (l * (1.0 + p)), eta, abs_h);
-  }
-  let p = exp2(z);
-  return vec3<f32>(params.tone.z / (l * (1.0 + p)), eta, 0.0);
+return vec3<f32>((1.0 + l * params.tone.x) / (1.0 + l), 14.0 * LU, 0.0);
+}
+let lg = log2(params.tone.x / l);
+let n = params.tone.y;
+let z = n * lg;
+
+let dz = n * (4.76837158203125e-7 + 3.0 * ULP1 * abs(lg) + 9.0 * LU) + 2.0 * LU * abs(z);
+
+let rho = 0.7 * dz * (1.0 + dz) + (3.0 + 2.0 * abs(z)) * ULP1 + 9.094947e-13 * (1.0 + abs(z));
+let eta = 2.0 * rho + 16.0 * LU;
+if (z >= 0.0) {
+let p = exp2(-z);
+var abs_h = 0.0;
+
+if (p < 7.52316384526264e-37) { abs_h = params.tone.z * 3.009265538105056e-36 / l; }
+return vec3<f32>(params.tone.z * p / (l * (1.0 + p)), eta, abs_h);
+}
+let p = exp2(z);
+return vec3<f32>(params.tone.z / (l * (1.0 + p)), eta, 0.0);
 }
 struct Toned { m: vec3<f32>, delta: vec3<f32>, changed_uncertain: bool };
 fn luminance_tone(e: vec3<f32>, eps: vec3<f32>) -> Toned {
-  var t: Toned;
-  let ae = abs(e);
-  let ea = ae + eps;
-  let s = (params.lum.x * ae.x + params.lum.y * ae.y) + params.lum.z * ae.z;
-  let l = (params.lum.x * e.x + params.lum.y * e.y) + params.lum.z * e.z;
-  let lambda = (((params.lum.x * eps.x + params.lum.y * eps.y) + params.lum.z * eps.z) + 6.0 * LU * s) * 1.001;
-  if (l < -2.0 * lambda || (l == 0.0 && lambda == 0.0)) {
-    // L < 0 for the reference too: both keep the exposed values.
-    t.m = e; t.delta = eps; t.changed_uncertain = false;
-    return t;
-  }
-  if (l > 2.0 * lambda) {
-    let r = tone_h(l);
-    let q = lambda / l;
-    let f = exp2(params.lum.w * log2((1.0 + q) / (1.0 - q))) / (1.0 - q) * 1.01;
-    let fq = params.lum.w * f * q;
-    let hh = r.x * (1.0 + 2.0 * r.y) + r.z;
-    t.m = e * r.x;
-    t.delta = (eps * hh * (1.0 + fq) + ea * (hh * (r.y + fq) + r.z) + 2.0 * LU * abs(t.m)) * 1.001;
-    t.changed_uncertain = abs(r.x - 1.0) <= 2.0 * (r.y + fq) * max(1.0, r.x) + r.z + 4.0 * LU;
-    return t;
-  }
-  // |L| is inside its classification band: either branch may run, so bound both.
-  var hsup = max(1.0, params.tone.x);
+var t: Toned;
+let ae = abs(e);
+let ea = ae + eps;
+let s = (params.lum.x * ae.x + params.lum.y * ae.y) + params.lum.z * ae.z;
+let l = (params.lum.x * e.x + params.lum.y * e.y) + params.lum.z * e.z;
+let lambda = (((params.lum.x * eps.x + params.lum.y * eps.y) + params.lum.z * eps.z) + 6.0 * LU * s) * 1.001;
+if (l < -2.0 * lambda || (l == 0.0 && lambda == 0.0)) {
+
+t.m = e; t.delta = eps; t.changed_uncertain = false;
+return t;
+}
+if (l > 2.0 * lambda) {
+let r = tone_h(l);
+let q = lambda / l;
+let f = exp2(params.lum.w * log2((1.0 + q) / (1.0 - q))) / (1.0 - q) * 1.01;
+let fq = params.lum.w * f * q;
+let hh = r.x * (1.0 + 2.0 * r.y) + r.z;
+t.m = e * r.x;
+t.delta = (eps * hh * (1.0 + fq) + ea * (hh * (r.y + fq) + r.z) + 2.0 * LU * abs(t.m)) * 1.001;
+t.changed_uncertain = abs(r.x - 1.0) <= 2.0 * (r.y + fq) * max(1.0, r.x) + r.z + 4.0 * LU;
+return t;
+}
+
+var hsup = max(1.0, params.tone.x);
   if (params.tone_mode == ${SDR_TONE_MODE.nakaRushton}u) {
-    hsup = params.tone.z * exp2((params.tone.y - 1.0) * log2(3.0 * lambda)) / params.tone.w * 1.01;
-  }
-  var m = e;
-  if (l > 0.0) { m = e * tone_h(l).x; }
-  t.m = m;
-  t.delta = (2.0 * ea * (1.0 + hsup * (1.0 + 1e-3))) * 1.001;
-  t.changed_uncertain = true;
-  return t;
-}
-// Classification, gamut handling and encoding of one luminance-toned sample (e exposed, m toned).
+hsup = params.tone.z * exp2((params.tone.y - 1.0) * log2(3.0 * lambda)) / params.tone.w * 1.01;
+}
+var m = e;
+if (l > 0.0) { m = e * tone_h(l).x; }
+t.m = m;
+t.delta = (2.0 * ea * (1.0 + hsup * (1.0 + 1e-3))) * 1.001;
+t.changed_uncertain = true;
+return t;
+}
+
 fn render_toned(e: f32, source_nonzero: bool, band0: f32, band1: f32, m: f32, delta: f32, changed_uncertain: bool, reject: bool, maximum: f32) -> u32 {
-  var uncertain = (e == 0.0 && source_nonzero) || abs(e - 1.0) <= band1 || (band0 > 0.0 && abs(e) <= band0) || (changed_uncertain && e != 0.0);
-  // The reference value lies in [m - delta, m + delta]: uncertain only if that interval straddles a decision.
-  let gamut_uncertain = (m - delta < 0.0 && m + delta >= 0.0) || (m + delta > 1.0 && m - delta <= 1.0);
+var uncertain = (e == 0.0 && source_nonzero) || abs(e - 1.0) <= band1 || (band0 > 0.0 && abs(e) <= band0) || (changed_uncertain && e != 0.0);
+
+let gamut_uncertain = (m - delta < 0.0 && m + delta >= 0.0) || (m + delta > 1.0 && m - delta <= 1.0);
   if (gamut_uncertain) { uncertain = true; count(${SDR_COUNTER.gamutUncertain}u); }
   if (uncertain) { count(${SDR_COUNTER.uncertain}u); }
   if (e < 0.0) { count(${SDR_COUNTER.negative}u); }
   if (e > 1.0) { count(${SDR_COUNTER.above}u); }
   if (m != e) { count(${SDR_COUNTER.changed}u); }
   if (!(abs(m) + delta <= 1.2676506002282294e30)) { count(${SDR_COUNTER.luminanceDomain}u); }
-  var linear = m;
-  var bound = min(delta, 1.0);
-  if (m < 0.0 || m > 1.0) {
+var linear = m;
+var bound = min(delta, 1.0);
+if (m < 0.0 || m > 1.0) {
     if (reject) { count(${SDR_COUNTER.outOfGamut}u); }
     else if (m < 0.0) { count(${SDR_COUNTER.low}u); linear = 0.0; }
     else { count(${SDR_COUNTER.high}u); linear = 1.0; }
-  }
-  // Clipping is 1-Lipschitz; when both values clip to the same end the difference is zero.
-  if (!reject && (m - delta >= 1.0 || m + delta <= 0.0)) { bound = 0.0; }
+}
+
+if (!reject && (m - delta >= 1.0 || m + delta <= 0.0)) { bound = 0.0; }
   count_max(${SDR_COUNTER.linearBoundBits}u, bound);
-  let code = floor(encode_srgb(linear) * maximum + 0.5);
-  return u32(clamp(code, 0.0, maximum));
+let code = floor(encode_srgb(linear) * maximum + 0.5);
+return u32(clamp(code, 0.0, maximum));
 }
 `;
 /** Pointwise SDR over a packed float32 band; one invocation per sample. */
@@ -178,20 +178,20 @@ struct Params { count: u32, reinhard: u32, reject: u32, pad0: u32, scale: f32, m
 ${SDR_FUNCTIONS}
 @compute @workgroup_size(${LINEAR_WORKGROUP_SIZE})
 fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) local_index: u32,
-        @builtin(num_workgroups) groups: vec3<u32>) {
-  clear_counters(local_index);
+@builtin(num_workgroups) groups: vec3<u32>) {
+clear_counters(local_index);
   let i = gid.x + gid.y * groups.x * ${LINEAR_WORKGROUP_SIZE}u;
-  if (i < params.count) {
-    let s = source[i];
-    codes[i] = render_sample(s * params.scale, s != 0.0, 0.0, params.band1, params.reinhard != 0u, params.reject != 0u, params.maximum);
-  }
-  flush_counters(local_index);
+if (i < params.count) {
+let s = source[i];
+codes[i] = render_sample(s * params.scale, s != 0.0, 0.0, params.band1, params.reinhard != 0u, params.reject != 0u, params.maximum);
+}
+flush_counters(local_index);
 }
 `;
 /** Pointwise SDR with a luminance tone curve over a packed float32 band; one invocation per pixel. */
 export const SDR_LUMINANCE_WGSL = /* wgsl */ `
 struct Params { pixels: u32, reject: u32, tone_mode: u32, pad0: u32, scale: f32, maximum: f32, band1: f32, pad1: f32,
-  tone: vec4<f32>, lum: vec4<f32> };
+tone: vec4<f32>, lum: vec4<f32> };
 @group(0) @binding(0) var<uniform> params: Params;
 @group(0) @binding(1) var<storage, read> source: array<f32>;
 @group(0) @binding(2) var<storage, read_write> codes: array<u32>;
@@ -200,24 +200,24 @@ ${SDR_FUNCTIONS}
 ${LUMINANCE_FUNCTIONS}
 @compute @workgroup_size(${LINEAR_WORKGROUP_SIZE})
 fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) local_index: u32,
-        @builtin(num_workgroups) groups: vec3<u32>) {
-  clear_counters(local_index);
+@builtin(num_workgroups) groups: vec3<u32>) {
+clear_counters(local_index);
   let i = gid.x + gid.y * groups.x * ${LINEAR_WORKGROUP_SIZE}u;
-  if (i < params.pixels) {
-    let s = vec3<f32>(source[i * 3u], source[i * 3u + 1u], source[i * 3u + 2u]);
-    let e = s * params.scale;
-    // Source, scale and product roundings (plus the reference's own), and an absolute term where a non-zero source may underflow.
-    var eps = 4.0 * LU * abs(e);
-    for (var j = 0u; j < 3u; j++) {
-      if (s[j] != 0.0 && abs(e[j]) < 7.888609052210118e-31) { eps[j] = eps[j] + 2.350988701644575e-38 * max(1.0, params.scale); }
-    }
-    let t = luminance_tone(e, eps);
-    let reject = params.reject != 0u;
-    for (var j = 0u; j < 3u; j++) {
-      codes[i * 3u + j] = render_toned(e[j], s[j] != 0.0, 0.0, params.band1, t.m[j], t.delta[j], t.changed_uncertain, reject, params.maximum);
-    }
-  }
-  flush_counters(local_index);
+if (i < params.pixels) {
+let s = vec3<f32>(source[i * 3u], source[i * 3u + 1u], source[i * 3u + 2u]);
+let e = s * params.scale;
+
+var eps = 4.0 * LU * abs(e);
+for (var j = 0u; j < 3u; j++) {
+if (s[j] != 0.0 && abs(e[j]) < 7.888609052210118e-31) { eps[j] = eps[j] + 2.350988701644575e-38 * max(1.0, params.scale); }
+}
+let t = luminance_tone(e, eps);
+let reject = params.reject != 0u;
+for (var j = 0u; j < 3u; j++) {
+codes[i * 3u + j] = render_toned(e[j], s[j] != 0.0, 0.0, params.band1, t.m[j], t.delta[j], t.changed_uncertain, reject, params.maximum);
+}
+}
+flush_counters(local_index);
 }
 `;
 /**
@@ -230,17 +230,17 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation
  */
 export const RAW_DEVELOPMENT_WGSL = /* wgsl */ `
 struct Params {
-  width: u32, count: u32, row0: u32, reinhard: u32,
-  reject: u32, repeat_w: u32, repeat_h: u32, region_w: u32,
-  origin_x: i32, origin_y: i32, axx: i32, axy: i32,
-  ayx: i32, ayy: i32, region_x: i32, region_y: i32,
-  scale: f32, maximum: f32, band0: f32, band1: f32,
-  clip_level: f32, reconstruct: u32, band_u: f32, band_s: f32,
-  gains: vec4<f32>,
-  m0: vec4<f32>, m1: vec4<f32>, m2: vec4<f32>,
-  x0: vec4<f32>, x1: vec4<f32>, x2: vec4<f32>,
-  tone_mode: u32, pad0: u32, pad1: u32, pad2: u32,
-  tone: vec4<f32>, lum: vec4<f32>,
+width: u32, count: u32, row0: u32, reinhard: u32,
+reject: u32, repeat_w: u32, repeat_h: u32, region_w: u32,
+origin_x: i32, origin_y: i32, axx: i32, axy: i32,
+ayx: i32, ayy: i32, region_x: i32, region_y: i32,
+scale: f32, maximum: f32, band0: f32, band1: f32,
+clip_level: f32, reconstruct: u32, band_u: f32, band_s: f32,
+gains: vec4<f32>,
+m0: vec4<f32>, m1: vec4<f32>, m2: vec4<f32>,
+x0: vec4<f32>, x1: vec4<f32>, x2: vec4<f32>,
+tone_mode: u32, pad0: u32, pad1: u32, pad2: u32,
+tone: vec4<f32>, lum: vec4<f32>,
 };
 struct Tap { ox: i32, oy: i32, w: f32, pad: f32 };
 @group(0) @binding(0) var<uniform> params: Params;
@@ -253,86 +253,86 @@ ${SDR_FUNCTIONS}
 ${LUMINANCE_FUNCTIONS}
 var<private> saturated: bool;
 fn channel(phase: u32, c: u32, nx: i32, ny: i32) -> f32 {
-  let range = phases[phase * 3u + c];
-  var value = 0.0;
-  for (var k = 0u; k < range.y; k++) {
-    let t = taps[range.x + k];
-    let sx = nx + t.ox - params.region_x;
-    let sy = ny + t.oy - params.region_y;
-    let site = normalized[u32(sy) * params.region_w + u32(sx)];
-    if (site == 1.0) { saturated = true; }
-    value = value + site * t.w;
-  }
-  return value;
+let range = phases[phase * 3u + c];
+var value = 0.0;
+for (var k = 0u; k < range.y; k++) {
+let t = taps[range.x + k];
+let sx = nx + t.ox - params.region_x;
+let sy = ny + t.oy - params.region_y;
+let site = normalized[u32(sy) * params.region_w + u32(sx)];
+if (site == 1.0) { saturated = true; }
+value = value + site * t.w;
+}
+return value;
 }
 fn row3(m: vec4<f32>, v: vec3<f32>) -> f32 { return ((0.0 + m.x * v.x) + m.y * v.y) + m.z * v.z; }
 fn max3(v: vec3<f32>) -> f32 {
-  if (v.x > v.y) { if (v.x > v.z) { return v.x; } return v.z; }
-  if (v.y > v.z) { return v.y; }
-  return v.z;
+if (v.x > v.y) { if (v.x > v.z) { return v.x; } return v.z; }
+if (v.y > v.z) { return v.y; }
+return v.z;
 }
 @compute @workgroup_size(${LINEAR_WORKGROUP_SIZE})
 fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) local_index: u32,
-        @builtin(num_workgroups) groups: vec3<u32>) {
-  clear_counters(local_index);
+@builtin(num_workgroups) groups: vec3<u32>) {
+clear_counters(local_index);
   let i = gid.x + gid.y * groups.x * ${LINEAR_WORKGROUP_SIZE}u;
-  if (i < params.count) {
-    let col = i32(i % params.width);
-    let row = i32(params.row0 + i / params.width);
-    let nx = params.origin_x + params.axx * col + params.axy * row;
-    let ny = params.origin_y + params.ayx * col + params.ayy * row;
-    let phase = (u32(ny) % params.repeat_h) * params.repeat_w + u32(nx) % params.repeat_w;
-    saturated = false;
-    let c = vec3<f32>(channel(phase, 0u, nx, ny), channel(phase, 1u, nx, ny), channel(phase, 2u, nx, ny));
+if (i < params.count) {
+let col = i32(i % params.width);
+let row = i32(params.row0 + i / params.width);
+let nx = params.origin_x + params.axx * col + params.axy * row;
+let ny = params.origin_y + params.ayx * col + params.ayy * row;
+let phase = (u32(ny) % params.repeat_h) * params.repeat_w + u32(nx) % params.repeat_w;
+saturated = false;
+let c = vec3<f32>(channel(phase, 0u, nx, ny), channel(phase, 1u, nx, ny), channel(phase, 2u, nx, ny));
     if (saturated) { count(${SDR_COUNTER.saturatedPixels}u); }
-    let u = vec3<f32>(c.x * params.gains.x, c.y * params.gains.y, c.z * params.gains.z);
-    let clip = params.clip_level;
-    let k = vec3<f32>(select(u.x, clip, u.x > clip), select(u.y, clip, u.y > clip), select(u.z, clip, u.z > clip));
-    var b = k;
-    if (params.reconstruct == 0u) {
-      for (var j = 0u; j < 3u; j++) {
+let u = vec3<f32>(c.x * params.gains.x, c.y * params.gains.y, c.z * params.gains.z);
+let clip = params.clip_level;
+let k = vec3<f32>(select(u.x, clip, u.x > clip), select(u.y, clip, u.y > clip), select(u.z, clip, u.z > clip));
+var b = k;
+if (params.reconstruct == 0u) {
+for (var j = 0u; j < 3u; j++) {
         if (u[j] > clip) { count(${SDR_COUNTER.whiteBalanceClipped}u); }
         if (abs(u[j] - clip) <= params.band_u) { count(${SDR_COUNTER.uncertain}u); }
-      }
-    } else {
-      let s = max3(c);
+}
+} else {
+let s = max3(c);
       if (abs(s - ${RAW_HIGHLIGHT_START_WGSL}) <= params.band_s) { count(${SDR_COUNTER.uncertain}u); }
       if (s > ${RAW_HIGHLIGHT_START_WGSL}) {
-        var t = 1.0;
+var t = 1.0;
         if (s < 1.0) { t = (s - ${RAW_HIGHLIGHT_START_WGSL}) / (1.0 - ${RAW_HIGHLIGHT_START_WGSL}); }
-        let n = max3(k);
-        b = (1.0 - t) * u + t * vec3<f32>(n, n, n);
+let n = max3(k);
+b = (1.0 - t) * u + t * vec3<f32>(n, n, n);
         count(${SDR_COUNTER.reconstructedPixels}u);
-      } else {
-        b = u;
-      }
-    }
-    let xyz = vec3<f32>(row3(params.m0, b), row3(params.m1, b), row3(params.m2, b));
-    let rgb = vec3<f32>(row3(params.x0, xyz), row3(params.x1, xyz), row3(params.x2, xyz));
-    let reinhard = params.reinhard != 0u;
-    let reject = params.reject != 0u;
+} else {
+b = u;
+}
+}
+let xyz = vec3<f32>(row3(params.m0, b), row3(params.m1, b), row3(params.m2, b));
+let rgb = vec3<f32>(row3(params.x0, xyz), row3(params.x1, xyz), row3(params.x2, xyz));
+let reinhard = params.reinhard != 0u;
+let reject = params.reject != 0u;
     if (params.tone_mode == ${SDR_TONE_MODE.perChannel}u) {
-      for (var j = 0u; j < 3u; j++) {
-        codes[i * 3u + j] = render_sample(rgb[j] * params.scale, false, params.band0, params.band1, reinhard, reject, params.maximum);
-      }
-    } else {
-      // band0 bounds each exposed value against the reference (the development chain's a-priori bound).
-      let e = rgb * params.scale;
-      let t = luminance_tone(e, vec3<f32>(params.band0, params.band0, params.band0));
-      for (var j = 0u; j < 3u; j++) {
-        codes[i * 3u + j] = render_toned(e[j], false, params.band0, params.band1, t.m[j], t.delta[j], t.changed_uncertain, reject, params.maximum);
-      }
-    }
-  }
-  flush_counters(local_index);
+for (var j = 0u; j < 3u; j++) {
+codes[i * 3u + j] = render_sample(rgb[j] * params.scale, false, params.band0, params.band1, reinhard, reject, params.maximum);
+}
+} else {
+
+let e = rgb * params.scale;
+let t = luminance_tone(e, vec3<f32>(params.band0, params.band0, params.band0));
+for (var j = 0u; j < 3u; j++) {
+codes[i * 3u + j] = render_toned(e[j], false, params.band0, params.band1, t.m[j], t.delta[j], t.changed_uncertain, reject, params.maximum);
+}
+}
+}
+flush_counters(local_index);
 }
 `;
 /** Source-indexed isoplanatic-patch convolution of one output-row band; one invocation per output site. */
 export const IRRADIANCE_CONVOLUTION_WGSL = /* wgsl */ `
 struct Params {
-  width: u32, height: u32, radius: u32, size: u32,
-  patch_w: u32, patch_h: u32, cols: u32, rows: u32,
-  out_row0: u32, out_rows: u32, in_row0: u32, taps: u32,
+width: u32, height: u32, radius: u32, size: u32,
+patch_w: u32, patch_h: u32, cols: u32, rows: u32,
+out_row0: u32, out_rows: u32, in_row0: u32, taps: u32,
 };
 @group(0) @binding(0) var<uniform> params: Params;
 @group(0) @binding(1) var<storage, read> source: array<f32>;
@@ -340,26 +340,26 @@ struct Params {
 @group(0) @binding(3) var<storage, read_write> result: array<f32>;
 @compute @workgroup_size(${CONVOLUTION_WORKGROUP_EDGE}, ${CONVOLUTION_WORKGROUP_EDGE})
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-  let x = gid.x;
-  let local_y = gid.y;
-  if (x >= params.width || local_y >= params.out_rows) { return; }
-  let y = i32(params.out_row0 + local_y);
-  let r = i32(params.radius);
-  var sum = 0.0;
-  for (var v = -r; v <= r; v++) {
-    let sy = y - v;
-    if (sy < 0 || sy >= i32(params.height)) { continue; }
-    let patch_row = min(u32(sy) / params.patch_h, params.rows - 1u) * params.cols;
-    let kernel_row = (v + r) * i32(params.size) + r;
-    let source_row = (u32(sy) - params.in_row0) * params.width;
-    for (var u = -r; u <= r; u++) {
-      let sx = i32(x) - u;
-      if (sx < 0 || sx >= i32(params.width)) { continue; }
-      let patch_index = patch_row + min(u32(sx) / params.patch_w, params.cols - 1u);
-      sum = sum + source[source_row + u32(sx)] * kernels[patch_index * params.taps + u32(kernel_row + u)];
-    }
-  }
-  result[local_y * params.width + x] = sum;
+let x = gid.x;
+let local_y = gid.y;
+if (x >= params.width || local_y >= params.out_rows) { return; }
+let y = i32(params.out_row0 + local_y);
+let r = i32(params.radius);
+var sum = 0.0;
+for (var v = -r; v <= r; v++) {
+let sy = y - v;
+if (sy < 0 || sy >= i32(params.height)) { continue; }
+let patch_row = min(u32(sy) / params.patch_h, params.rows - 1u) * params.cols;
+let kernel_row = (v + r) * i32(params.size) + r;
+let source_row = (u32(sy) - params.in_row0) * params.width;
+for (var u = -r; u <= r; u++) {
+let sx = i32(x) - u;
+if (sx < 0 || sx >= i32(params.width)) { continue; }
+let patch_index = patch_row + min(u32(sx) / params.patch_w, params.cols - 1u);
+sum = sum + source[source_row + u32(sx)] * kernels[patch_index * params.taps + u32(kernel_row + u)];
+}
+}
+result[local_y * params.width + x] = sum;
 }
 `;
 //# sourceMappingURL=wgsl-kernels.js.map

package/dist/gpu/wgsl-kernels.js.map

@@ -1 +1 @@
-{"version":3,"file":"wgsl-kernels.js","sourceRoot":"","sources":["../../src/gpu/wgsl-kernels.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The project's own WGSL (WebGPU shader language) compute kernels for the `webgpu-f32` image-kernel\n * backend. Each kernel evaluates the same equations, in the same order, as its float64 CPU reference:\n * - SDR: `calculateSdrRendering` / native capture SDR (exposure → tone → gamut → sRGB → nearest-ties-up);\n * - RAW development: `createNativeRawDevelopmentTask` (CFA kernel sums → WB gains → camera→XYZ →\n *   XYZ→linear sRGB → SDR);\n * - irradiance convolution: `convolveIrradianceRows` (source-indexed isoplanatic-patch gather).\n * The host packers in image-kernel-accelerator.ts use matching uniform layouts.\n */\n\n/**\n * Counter slots shared by the SDR-producing kernels. `linearBoundBits` holds the float32 bits of the\n * largest per-sample linear bound of a luminance tone curve (a maximum, not a sum: non-negative float32\n * bit patterns order like their values). `luminanceDomain` counts samples outside the float32 domain.\n */\nexport const SDR_COUNTER = Object.freeze({ negative: 0, above: 1, changed: 2, low: 3, high: 4, outOfGamut: 5, uncertain: 6, gamutUncertain: 7,\n  saturatedPixels: 8, whiteBalanceClipped: 9, reconstructedPixels: 10, linearBoundBits: 11, luminanceDomain: 12 });\nexport const SDR_COUNTER_SLOTS = 16;\n/** Tone modes of the luminance kernels (`Params.tone_mode`); 0 is a per-channel curve. */\nexport const SDR_TONE_MODE = Object.freeze({ perChannel: 0, extendedReinhard: 1, nakaRushton: 2 });\nexport const LINEAR_WORKGROUP_SIZE = 256;\n/** RAW_HIGHLIGHT_RECONSTRUCTION_START as a WGSL literal (rounded once to float32 by the compiler). */\nconst RAW_HIGHLIGHT_START_WGSL = \"0.8\";\nexport const CONVOLUTION_WORKGROUP_EDGE = 16;\n\n/**\n * Shared SDR sample renderer. `band0`/`band1` are absolute classification bands around 0 and 1 inside\n * which the float32 decision may differ from float64; such samples increment the uncertainty counter.\n * A zero result from a non-zero source (underflow) and tiny positive Reinhard inputs are also uncertain.\n */\nconst SDR_FUNCTIONS = /* wgsl */ `\nvar<workgroup> local_counters: array<atomic<u32>, ${SDR_COUNTER_SLOTS}>;\nfn count(slot: u32) { atomicAdd(&local_counters[slot], 1u); }\nfn encode_srgb(x: f32) -> f32 {\n  if (x == 1.0) { return 1.0; }\n  if (x <= 0.0031308) { return x * 12.92; }\n  return 1.055 * pow(x, 1.0 / 2.4) - 0.055;\n}\nfn render_sample(e: f32, source_nonzero: bool, band0: f32, band1: f32, reinhard: bool, reject: bool, maximum: f32) -> u32 {\n  // Gamut decisions (mapped < 0, mapped > 1) depend only on the sign band and, for identity tone, the band at 1.\n  var gamut_uncertain = (e == 0.0 && source_nonzero) || (!reinhard && abs(e - 1.0) <= band1);\n  if (band0 > 0.0 && abs(e) <= band0) { gamut_uncertain = true; }\n  var uncertain = gamut_uncertain || abs(e - 1.0) <= band1;\n  if (reinhard && e > 0.0 && e < 9.5367431640625e-7) { uncertain = true; }\n  if (uncertain) { count(${SDR_COUNTER.uncertain}u); }\n  if (gamut_uncertain) { count(${SDR_COUNTER.gamutUncertain}u); }\n  if (e < 0.0) { count(${SDR_COUNTER.negative}u); }\n  if (e > 1.0) { count(${SDR_COUNTER.above}u); }\n  var mapped = e;\n  if (reinhard && e > 0.0) { mapped = e / (1.0 + e); }\n  if (mapped != e) { count(${SDR_COUNTER.changed}u); }\n  var linear = mapped;\n  if (mapped < 0.0 || mapped > 1.0) {\n    if (reject) { count(${SDR_COUNTER.outOfGamut}u); }\n    else if (mapped < 0.0) { count(${SDR_COUNTER.low}u); linear = 0.0; }\n    else { count(${SDR_COUNTER.high}u); linear = 1.0; }\n  }\n  let code = floor(encode_srgb(linear) * maximum + 0.5);\n  return u32(clamp(code, 0.0, maximum));\n}\nfn clear_counters(local_index: u32) {\n  if (local_index < ${SDR_COUNTER_SLOTS}u) { atomicStore(&local_counters[local_index], 0u); }\n  workgroupBarrier();\n}\nfn flush_counters(local_index: u32) {\n  workgroupBarrier();\n  if (local_index < ${SDR_COUNTER_SLOTS}u) {\n    let value = atomicLoad(&local_counters[local_index]);\n    if (local_index == ${SDR_COUNTER.linearBoundBits}u) { atomicMax(&counters[local_index], value); }\n    else if (value > 0u) { atomicAdd(&counters[local_index], value); }\n  }\n}\n`;\n\n/**\n * Luminance tone curves (`prepareSdrPixelTone`): every component of a pixel is scaled by h(L) = f(L)/L,\n * L = kr·r + kg·g + kb·b, when L > 0. The kernel evaluates h directly (algebraically equal to f(L)/L):\n * - extended Reinhard: h = (1 + L/Lw²)/(1 + L);\n * - Naka–Rushton: h = (1/g(Lw))/(L·(1 + (σ/L)ⁿ)), with P = (σ/L)ⁿ = exp2(n·log2(σ/L)) and, for P ≥ 1,\n *   the equal form (1/g(Lw))·P⁻¹/(L·(1 + P⁻¹)) so nothing overflows.\n * Per sample it also evaluates an a-priori bound on |m_gpu − m_reference| from the inputs' bounds ε\n * (see docs/WEBGPU.md, \"Luminance tone curves\"). The bound itself is evaluated in float32 and inflated.\n * Uniform fields used: tone_mode, tone = (Reinhard: 1/Lw²; Naka–Rushton: σ, n, 1/g(Lw), σⁿ), lum = (kr, kg, kb, T).\n */\nconst LUMINANCE_FUNCTIONS = /* wgsl */ `\nconst LU: f32 = 5.9604644775390625e-8;\nconst ULP1: f32 = 1.1920928955078125e-7;\nfn count_max(slot: u32, value: f32) { atomicMax(&local_counters[slot], bitcast<u32>(max(value, 0.0))); }\n// (h, eta, abs_h): |h_gpu - h(l)| <= eta*h(l) + abs_h for the exact h at this float32 l > 0.\nfn tone_h(l: f32) -> vec3<f32> {\n  if (params.tone_mode == ${SDR_TONE_MODE.extendedReinhard}u) {\n    return vec3<f32>((1.0 + l * params.tone.x) / (1.0 + l), 14.0 * LU, 0.0);\n  }\n  let lg = log2(params.tone.x / l);\n  let n = params.tone.y;\n  let z = n * lg;\n  // log2: 2^-21 absolute or 3 ULP; the sigma/l division and sigma's rounding; the product's rounding.\n  let dz = n * (4.76837158203125e-7 + 3.0 * ULP1 * abs(lg) + 9.0 * LU) + 2.0 * LU * abs(z);\n  // exp2: 3 + 2|z| ULP; plus slack for the float64 reference's pow.\n  let rho = 0.7 * dz * (1.0 + dz) + (3.0 + 2.0 * abs(z)) * ULP1 + 9.094947e-13 * (1.0 + abs(z));\n  let eta = 2.0 * rho + 16.0 * LU;\n  if (z >= 0.0) {\n    let p = exp2(-z);\n    var abs_h = 0.0;\n    // Below 2^-120 the power may have flushed to zero: bound h absolutely instead.\n    if (p < 7.52316384526264e-37) { abs_h = params.tone.z * 3.009265538105056e-36 / l; }\n    return vec3<f32>(params.tone.z * p / (l * (1.0 + p)), eta, abs_h);\n  }\n  let p = exp2(z);\n  return vec3<f32>(params.tone.z / (l * (1.0 + p)), eta, 0.0);\n}\nstruct Toned { m: vec3<f32>, delta: vec3<f32>, changed_uncertain: bool };\nfn luminance_tone(e: vec3<f32>, eps: vec3<f32>) -> Toned {\n  var t: Toned;\n  let ae = abs(e);\n  let ea = ae + eps;\n  let s = (params.lum.x * ae.x + params.lum.y * ae.y) + params.lum.z * ae.z;\n  let l = (params.lum.x * e.x + params.lum.y * e.y) + params.lum.z * e.z;\n  let lambda = (((params.lum.x * eps.x + params.lum.y * eps.y) + params.lum.z * eps.z) + 6.0 * LU * s) * 1.001;\n  if (l < -2.0 * lambda || (l == 0.0 && lambda == 0.0)) {\n    // L < 0 for the reference too: both keep the exposed values.\n    t.m = e; t.delta = eps; t.changed_uncertain = false;\n    return t;\n  }\n  if (l > 2.0 * lambda) {\n    let r = tone_h(l);\n    let q = lambda / l;\n    let f = exp2(params.lum.w * log2((1.0 + q) / (1.0 - q))) / (1.0 - q) * 1.01;\n    let fq = params.lum.w * f * q;\n    let hh = r.x * (1.0 + 2.0 * r.y) + r.z;\n    t.m = e * r.x;\n    t.delta = (eps * hh * (1.0 + fq) + ea * (hh * (r.y + fq) + r.z) + 2.0 * LU * abs(t.m)) * 1.001;\n    t.changed_uncertain = abs(r.x - 1.0) <= 2.0 * (r.y + fq) * max(1.0, r.x) + r.z + 4.0 * LU;\n    return t;\n  }\n  // |L| is inside its classification band: either branch may run, so bound both.\n  var hsup = max(1.0, params.tone.x);\n  if (params.tone_mode == ${SDR_TONE_MODE.nakaRushton}u) {\n    hsup = params.tone.z * exp2((params.tone.y - 1.0) * log2(3.0 * lambda)) / params.tone.w * 1.01;\n  }\n  var m = e;\n  if (l > 0.0) { m = e * tone_h(l).x; }\n  t.m = m;\n  t.delta = (2.0 * ea * (1.0 + hsup * (1.0 + 1e-3))) * 1.001;\n  t.changed_uncertain = true;\n  return t;\n}\n// Classification, gamut handling and encoding of one luminance-toned sample (e exposed, m toned).\nfn render_toned(e: f32, source_nonzero: bool, band0: f32, band1: f32, m: f32, delta: f32, changed_uncertain: bool, reject: bool, maximum: f32) -> u32 {\n  var uncertain = (e == 0.0 && source_nonzero) || abs(e - 1.0) <= band1 || (band0 > 0.0 && abs(e) <= band0) || (changed_uncertain && e != 0.0);\n  // The reference value lies in [m - delta, m + delta]: uncertain only if that interval straddles a decision.\n  let gamut_uncertain = (m - delta < 0.0 && m + delta >= 0.0) || (m + delta > 1.0 && m - delta <= 1.0);\n  if (gamut_uncertain) { uncertain = true; count(${SDR_COUNTER.gamutUncertain}u); }\n  if (uncertain) { count(${SDR_COUNTER.uncertain}u); }\n  if (e < 0.0) { count(${SDR_COUNTER.negative}u); }\n  if (e > 1.0) { count(${SDR_COUNTER.above}u); }\n  if (m != e) { count(${SDR_COUNTER.changed}u); }\n  if (!(abs(m) + delta <= 1.2676506002282294e30)) { count(${SDR_COUNTER.luminanceDomain}u); }\n  var linear = m;\n  var bound = min(delta, 1.0);\n  if (m < 0.0 || m > 1.0) {\n    if (reject) { count(${SDR_COUNTER.outOfGamut}u); }\n    else if (m < 0.0) { count(${SDR_COUNTER.low}u); linear = 0.0; }\n    else { count(${SDR_COUNTER.high}u); linear = 1.0; }\n  }\n  // Clipping is 1-Lipschitz; when both values clip to the same end the difference is zero.\n  if (!reject && (m - delta >= 1.0 || m + delta <= 0.0)) { bound = 0.0; }\n  count_max(${SDR_COUNTER.linearBoundBits}u, bound);\n  let code = floor(encode_srgb(linear) * maximum + 0.5);\n  return u32(clamp(code, 0.0, maximum));\n}\n`;\n\n/** Pointwise SDR over a packed float32 band; one invocation per sample. */\nexport const SDR_WGSL = /* wgsl */ `\nstruct Params { count: u32, reinhard: u32, reject: u32, pad0: u32, scale: f32, maximum: f32, band1: f32, pad1: f32 };\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> source: array<f32>;\n@group(0) @binding(2) var<storage, read_write> codes: array<u32>;\n@group(0) @binding(3) var<storage, read_write> counters: array<atomic<u32>, ${SDR_COUNTER_SLOTS}>;\n${SDR_FUNCTIONS}\n@compute @workgroup_size(${LINEAR_WORKGROUP_SIZE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) local_index: u32,\n        @builtin(num_workgroups) groups: vec3<u32>) {\n  clear_counters(local_index);\n  let i = gid.x + gid.y * groups.x * ${LINEAR_WORKGROUP_SIZE}u;\n  if (i < params.count) {\n    let s = source[i];\n    codes[i] = render_sample(s * params.scale, s != 0.0, 0.0, params.band1, params.reinhard != 0u, params.reject != 0u, params.maximum);\n  }\n  flush_counters(local_index);\n}\n`;\n\n/** Pointwise SDR with a luminance tone curve over a packed float32 band; one invocation per pixel. */\nexport const SDR_LUMINANCE_WGSL = /* wgsl */ `\nstruct Params { pixels: u32, reject: u32, tone_mode: u32, pad0: u32, scale: f32, maximum: f32, band1: f32, pad1: f32,\n  tone: vec4<f32>, lum: vec4<f32> };\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> source: array<f32>;\n@group(0) @binding(2) var<storage, read_write> codes: array<u32>;\n@group(0) @binding(3) var<storage, read_write> counters: array<atomic<u32>, ${SDR_COUNTER_SLOTS}>;\n${SDR_FUNCTIONS}\n${LUMINANCE_FUNCTIONS}\n@compute @workgroup_size(${LINEAR_WORKGROUP_SIZE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) local_index: u32,\n        @builtin(num_workgroups) groups: vec3<u32>) {\n  clear_counters(local_index);\n  let i = gid.x + gid.y * groups.x * ${LINEAR_WORKGROUP_SIZE}u;\n  if (i < params.pixels) {\n    let s = vec3<f32>(source[i * 3u], source[i * 3u + 1u], source[i * 3u + 2u]);\n    let e = s * params.scale;\n    // Source, scale and product roundings (plus the reference's own), and an absolute term where a non-zero source may underflow.\n    var eps = 4.0 * LU * abs(e);\n    for (var j = 0u; j < 3u; j++) {\n      if (s[j] != 0.0 && abs(e[j]) < 7.888609052210118e-31) { eps[j] = eps[j] + 2.350988701644575e-38 * max(1.0, params.scale); }\n    }\n    let t = luminance_tone(e, eps);\n    let reject = params.reject != 0u;\n    for (var j = 0u; j < 3u; j++) {\n      codes[i * 3u + j] = render_toned(e[j], s[j] != 0.0, 0.0, params.band1, t.m[j], t.delta[j], t.changed_uncertain, reject, params.maximum);\n    }\n  }\n  flush_counters(local_index);\n}\n`;\n\n/**\n * Packed native RAW development of one band of output rows; one invocation per output pixel.\n * `normalized` holds the host's float64 site values, rounded once to float32. A saturated site\n * (flagged, or at or above its phase white level) is exactly 1. Any other site is\n * (code − black)/(white − black) ≤ 1 − 1/65535. So a saturated contributing site is recognised exactly.\n * Highlight handling matches `prepareSensorColorDevelopment` (clip at the smallest applied gain, or the\n * declared neutral blend).\n */\nexport const RAW_DEVELOPMENT_WGSL = /* wgsl */ `\nstruct Params {\n  width: u32, count: u32, row0: u32, reinhard: u32,\n  reject: u32, repeat_w: u32, repeat_h: u32, region_w: u32,\n  origin_x: i32, origin_y: i32, axx: i32, axy: i32,\n  ayx: i32, ayy: i32, region_x: i32, region_y: i32,\n  scale: f32, maximum: f32, band0: f32, band1: f32,\n  clip_level: f32, reconstruct: u32, band_u: f32, band_s: f32,\n  gains: vec4<f32>,\n  m0: vec4<f32>, m1: vec4<f32>, m2: vec4<f32>,\n  x0: vec4<f32>, x1: vec4<f32>, x2: vec4<f32>,\n  tone_mode: u32, pad0: u32, pad1: u32, pad2: u32,\n  tone: vec4<f32>, lum: vec4<f32>,\n};\nstruct Tap { ox: i32, oy: i32, w: f32, pad: f32 };\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> normalized: array<f32>;\n@group(0) @binding(2) var<storage, read> taps: array<Tap>;\n@group(0) @binding(3) var<storage, read> phases: array<vec2<u32>>;\n@group(0) @binding(4) var<storage, read_write> codes: array<u32>;\n@group(0) @binding(5) var<storage, read_write> counters: array<atomic<u32>, ${SDR_COUNTER_SLOTS}>;\n${SDR_FUNCTIONS}\n${LUMINANCE_FUNCTIONS}\nvar<private> saturated: bool;\nfn channel(phase: u32, c: u32, nx: i32, ny: i32) -> f32 {\n  let range = phases[phase * 3u + c];\n  var value = 0.0;\n  for (var k = 0u; k < range.y; k++) {\n    let t = taps[range.x + k];\n    let sx = nx + t.ox - params.region_x;\n    let sy = ny + t.oy - params.region_y;\n    let site = normalized[u32(sy) * params.region_w + u32(sx)];\n    if (site == 1.0) { saturated = true; }\n    value = value + site * t.w;\n  }\n  return value;\n}\nfn row3(m: vec4<f32>, v: vec3<f32>) -> f32 { return ((0.0 + m.x * v.x) + m.y * v.y) + m.z * v.z; }\nfn max3(v: vec3<f32>) -> f32 {\n  if (v.x > v.y) { if (v.x > v.z) { return v.x; } return v.z; }\n  if (v.y > v.z) { return v.y; }\n  return v.z;\n}\n@compute @workgroup_size(${LINEAR_WORKGROUP_SIZE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) local_index: u32,\n        @builtin(num_workgroups) groups: vec3<u32>) {\n  clear_counters(local_index);\n  let i = gid.x + gid.y * groups.x * ${LINEAR_WORKGROUP_SIZE}u;\n  if (i < params.count) {\n    let col = i32(i % params.width);\n    let row = i32(params.row0 + i / params.width);\n    let nx = params.origin_x + params.axx * col + params.axy * row;\n    let ny = params.origin_y + params.ayx * col + params.ayy * row;\n    let phase = (u32(ny) % params.repeat_h) * params.repeat_w + u32(nx) % params.repeat_w;\n    saturated = false;\n    let c = vec3<f32>(channel(phase, 0u, nx, ny), channel(phase, 1u, nx, ny), channel(phase, 2u, nx, ny));\n    if (saturated) { count(${SDR_COUNTER.saturatedPixels}u); }\n    let u = vec3<f32>(c.x * params.gains.x, c.y * params.gains.y, c.z * params.gains.z);\n    let clip = params.clip_level;\n    let k = vec3<f32>(select(u.x, clip, u.x > clip), select(u.y, clip, u.y > clip), select(u.z, clip, u.z > clip));\n    var b = k;\n    if (params.reconstruct == 0u) {\n      for (var j = 0u; j < 3u; j++) {\n        if (u[j] > clip) { count(${SDR_COUNTER.whiteBalanceClipped}u); }\n        if (abs(u[j] - clip) <= params.band_u) { count(${SDR_COUNTER.uncertain}u); }\n      }\n    } else {\n      let s = max3(c);\n      if (abs(s - ${RAW_HIGHLIGHT_START_WGSL}) <= params.band_s) { count(${SDR_COUNTER.uncertain}u); }\n      if (s > ${RAW_HIGHLIGHT_START_WGSL}) {\n        var t = 1.0;\n        if (s < 1.0) { t = (s - ${RAW_HIGHLIGHT_START_WGSL}) / (1.0 - ${RAW_HIGHLIGHT_START_WGSL}); }\n        let n = max3(k);\n        b = (1.0 - t) * u + t * vec3<f32>(n, n, n);\n        count(${SDR_COUNTER.reconstructedPixels}u);\n      } else {\n        b = u;\n      }\n    }\n    let xyz = vec3<f32>(row3(params.m0, b), row3(params.m1, b), row3(params.m2, b));\n    let rgb = vec3<f32>(row3(params.x0, xyz), row3(params.x1, xyz), row3(params.x2, xyz));\n    let reinhard = params.reinhard != 0u;\n    let reject = params.reject != 0u;\n    if (params.tone_mode == ${SDR_TONE_MODE.perChannel}u) {\n      for (var j = 0u; j < 3u; j++) {\n        codes[i * 3u + j] = render_sample(rgb[j] * params.scale, false, params.band0, params.band1, reinhard, reject, params.maximum);\n      }\n    } else {\n      // band0 bounds each exposed value against the reference (the development chain's a-priori bound).\n      let e = rgb * params.scale;\n      let t = luminance_tone(e, vec3<f32>(params.band0, params.band0, params.band0));\n      for (var j = 0u; j < 3u; j++) {\n        codes[i * 3u + j] = render_toned(e[j], false, params.band0, params.band1, t.m[j], t.delta[j], t.changed_uncertain, reject, params.maximum);\n      }\n    }\n  }\n  flush_counters(local_index);\n}\n`;\n\n/** Source-indexed isoplanatic-patch convolution of one output-row band; one invocation per output site. */\nexport const IRRADIANCE_CONVOLUTION_WGSL = /* wgsl */ `\nstruct Params {\n  width: u32, height: u32, radius: u32, size: u32,\n  patch_w: u32, patch_h: u32, cols: u32, rows: u32,\n  out_row0: u32, out_rows: u32, in_row0: u32, taps: u32,\n};\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> source: array<f32>;\n@group(0) @binding(2) var<storage, read> kernels: array<f32>;\n@group(0) @binding(3) var<storage, read_write> result: array<f32>;\n@compute @workgroup_size(${CONVOLUTION_WORKGROUP_EDGE}, ${CONVOLUTION_WORKGROUP_EDGE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let x = gid.x;\n  let local_y = gid.y;\n  if (x >= params.width || local_y >= params.out_rows) { return; }\n  let y = i32(params.out_row0 + local_y);\n  let r = i32(params.radius);\n  var sum = 0.0;\n  for (var v = -r; v <= r; v++) {\n    let sy = y - v;\n    if (sy < 0 || sy >= i32(params.height)) { continue; }\n    let patch_row = min(u32(sy) / params.patch_h, params.rows - 1u) * params.cols;\n    let kernel_row = (v + r) * i32(params.size) + r;\n    let source_row = (u32(sy) - params.in_row0) * params.width;\n    for (var u = -r; u <= r; u++) {\n      let sx = i32(x) - u;\n      if (sx < 0 || sx >= i32(params.width)) { continue; }\n      let patch_index = patch_row + min(u32(sx) / params.patch_w, params.cols - 1u);\n      sum = sum + source[source_row + u32(sx)] * kernels[patch_index * params.taps + u32(kernel_row + u)];\n    }\n  }\n  result[local_y * params.width + x] = sum;\n}\n`;\n"]}
+{"version":3,"file":"wgsl-kernels.js","sourceRoot":"","sources":["../../src/gpu/wgsl-kernels.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;;;;;GAQG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC;IAC3J,eAAe,EAAE,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,mBAAmB,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,CAAC;AACnH,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC;AACpC,0FAA0F;AAC1F,MAAM,CAAC,MAAM,aAAa,GAAG,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;AACnH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AACzC,sGAAsG;AACtG,MAAM,wBAAwB,GAAG,KAAK,CAAC;AACvC,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAE7C;;;;GAIG;AACH,MAAM,aAAa,GAAG,UAAU,CAAC;oDACmB,iBAAiB;;;;;;;;;;;;;2BAa1C,WAAW,CAAC,SAAS;iCACf,WAAW,CAAC,cAAc;yBAClC,WAAW,CAAC,QAAQ;yBACpB,WAAW,CAAC,KAAK;;;6BAGb,WAAW,CAAC,OAAO;;;0BAGtB,WAAW,CAAC,UAAU;qCACX,WAAW,CAAC,GAAG;mBACjC,WAAW,CAAC,IAAI;;;;;;sBAMb,iBAAiB;;;;;sBAKjB,iBAAiB;;yBAEd,WAAW,CAAC,eAAe;;;;CAInD,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;4BAMX,aAAa,CAAC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA+C9B,aAAa,CAAC,WAAW;;;;;;;;;;;;;;;mDAeF,WAAW,CAAC,cAAc;2BAClD,WAAW,CAAC,SAAS;yBACvB,WAAW,CAAC,QAAQ;yBACpB,WAAW,CAAC,KAAK;wBAClB,WAAW,CAAC,OAAO;4DACiB,WAAW,CAAC,eAAe;;;;0BAI7D,WAAW,CAAC,UAAU;gCAChB,WAAW,CAAC,GAAG;mBAC5B,WAAW,CAAC,IAAI;;;;cAIrB,WAAW,CAAC,eAAe;;;;CAIxC,CAAC;AAEF,2EAA2E;AAC3E,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;8EAK2C,iBAAiB;EAC7F,aAAa;2BACY,qBAAqB;;;;uCAIT,qBAAqB;;;;;;;CAO3D,CAAC;AAEF,sGAAsG;AACtG,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;8EAMiC,iBAAiB;EAC7F,aAAa;EACb,mBAAmB;2BACM,qBAAqB;;;;uCAIT,qBAAqB;;;;;;;;;;;;;;;;;CAiB3D,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;8EAoB+B,iBAAiB;EAC7F,aAAa;EACb,mBAAmB;;;;;;;;;;;;;;;;;;;;;2BAqBM,qBAAqB;;;;uCAIT,qBAAqB;;;;;;;;;6BAS/B,WAAW,CAAC,eAAe;;;;;;;mCAOrB,WAAW,CAAC,mBAAmB;yDACT,WAAW,CAAC,SAAS;;;;oBAI1D,wBAAwB,+BAA+B,WAAW,CAAC,SAAS;gBAChF,wBAAwB;;kCAEN,wBAAwB,cAAc,wBAAwB;;;gBAGhF,WAAW,CAAC,mBAAmB;;;;;;;;;8BASjB,aAAa,CAAC,UAAU;;;;;;;;;;;;;;;CAerD,CAAC;AAEF,2GAA2G;AAC3G,MAAM,CAAC,MAAM,2BAA2B,GAAG,UAAU,CAAC;;;;;;;;;;2BAU3B,0BAA0B,KAAK,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;CAuBnF,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The project's own WGSL (WebGPU shader language) compute kernels for the `webgpu-f32` image-kernel\n * backend. Each kernel evaluates the same equations, in the same order, as its float64 CPU reference:\n * - SDR: `calculateSdrRendering` / native capture SDR (exposure → tone → gamut → sRGB → nearest-ties-up);\n * - RAW development: `createNativeRawDevelopmentTask` (CFA kernel sums → WB gains → camera→XYZ →\n *   XYZ→linear sRGB → SDR);\n * - irradiance convolution: `convolveIrradianceRows` (source-indexed isoplanatic-patch gather).\n * The host packers in image-kernel-accelerator.ts use matching uniform layouts.\n */\n\n/**\n * Counter slots shared by the SDR-producing kernels. `linearBoundBits` holds the float32 bits of the\n * largest per-sample linear bound of a luminance tone curve (a maximum, not a sum: non-negative float32\n * bit patterns order like their values). `luminanceDomain` counts samples outside the float32 domain.\n */\nexport const SDR_COUNTER = /* @__PURE__ */ Object.freeze({ negative: 0, above: 1, changed: 2, low: 3, high: 4, outOfGamut: 5, uncertain: 6, gamutUncertain: 7,\n  saturatedPixels: 8, whiteBalanceClipped: 9, reconstructedPixels: 10, linearBoundBits: 11, luminanceDomain: 12 });\nexport const SDR_COUNTER_SLOTS = 16;\n/** Tone modes of the luminance kernels (`Params.tone_mode`); 0 is a per-channel curve. */\nexport const SDR_TONE_MODE = /* @__PURE__ */ Object.freeze({ perChannel: 0, extendedReinhard: 1, nakaRushton: 2 });\nexport const LINEAR_WORKGROUP_SIZE = 256;\n/** RAW_HIGHLIGHT_RECONSTRUCTION_START as a WGSL literal (rounded once to float32 by the compiler). */\nconst RAW_HIGHLIGHT_START_WGSL = \"0.8\";\nexport const CONVOLUTION_WORKGROUP_EDGE = 16;\n\n/**\n * Shared SDR sample renderer. `band0`/`band1` are absolute classification bands around 0 and 1 inside\n * which the float32 decision may differ from float64; such samples increment the uncertainty counter.\n * A zero result from a non-zero source (underflow) and tiny positive Reinhard inputs are also uncertain.\n */\nconst SDR_FUNCTIONS = /* wgsl */ `\nvar<workgroup> local_counters: array<atomic<u32>, ${SDR_COUNTER_SLOTS}>;\nfn count(slot: u32) { atomicAdd(&local_counters[slot], 1u); }\nfn encode_srgb(x: f32) -> f32 {\n  if (x == 1.0) { return 1.0; }\n  if (x <= 0.0031308) { return x * 12.92; }\n  return 1.055 * pow(x, 1.0 / 2.4) - 0.055;\n}\nfn render_sample(e: f32, source_nonzero: bool, band0: f32, band1: f32, reinhard: bool, reject: bool, maximum: f32) -> u32 {\n  // Gamut decisions (mapped < 0, mapped > 1) depend only on the sign band and, for identity tone, the band at 1.\n  var gamut_uncertain = (e == 0.0 && source_nonzero) || (!reinhard && abs(e - 1.0) <= band1);\n  if (band0 > 0.0 && abs(e) <= band0) { gamut_uncertain = true; }\n  var uncertain = gamut_uncertain || abs(e - 1.0) <= band1;\n  if (reinhard && e > 0.0 && e < 9.5367431640625e-7) { uncertain = true; }\n  if (uncertain) { count(${SDR_COUNTER.uncertain}u); }\n  if (gamut_uncertain) { count(${SDR_COUNTER.gamutUncertain}u); }\n  if (e < 0.0) { count(${SDR_COUNTER.negative}u); }\n  if (e > 1.0) { count(${SDR_COUNTER.above}u); }\n  var mapped = e;\n  if (reinhard && e > 0.0) { mapped = e / (1.0 + e); }\n  if (mapped != e) { count(${SDR_COUNTER.changed}u); }\n  var linear = mapped;\n  if (mapped < 0.0 || mapped > 1.0) {\n    if (reject) { count(${SDR_COUNTER.outOfGamut}u); }\n    else if (mapped < 0.0) { count(${SDR_COUNTER.low}u); linear = 0.0; }\n    else { count(${SDR_COUNTER.high}u); linear = 1.0; }\n  }\n  let code = floor(encode_srgb(linear) * maximum + 0.5);\n  return u32(clamp(code, 0.0, maximum));\n}\nfn clear_counters(local_index: u32) {\n  if (local_index < ${SDR_COUNTER_SLOTS}u) { atomicStore(&local_counters[local_index], 0u); }\n  workgroupBarrier();\n}\nfn flush_counters(local_index: u32) {\n  workgroupBarrier();\n  if (local_index < ${SDR_COUNTER_SLOTS}u) {\n    let value = atomicLoad(&local_counters[local_index]);\n    if (local_index == ${SDR_COUNTER.linearBoundBits}u) { atomicMax(&counters[local_index], value); }\n    else if (value > 0u) { atomicAdd(&counters[local_index], value); }\n  }\n}\n`;\n\n/**\n * Luminance tone curves (`prepareSdrPixelTone`): every component of a pixel is scaled by h(L) = f(L)/L,\n * L = kr·r + kg·g + kb·b, when L > 0. The kernel evaluates h directly (algebraically equal to f(L)/L):\n * - extended Reinhard: h = (1 + L/Lw²)/(1 + L);\n * - Naka–Rushton: h = (1/g(Lw))/(L·(1 + (σ/L)ⁿ)), with P = (σ/L)ⁿ = exp2(n·log2(σ/L)) and, for P ≥ 1,\n *   the equal form (1/g(Lw))·P⁻¹/(L·(1 + P⁻¹)) so nothing overflows.\n * Per sample it also evaluates an a-priori bound on |m_gpu − m_reference| from the inputs' bounds ε\n * (see docs/WEBGPU.md, \"Luminance tone curves\"). The bound itself is evaluated in float32 and inflated.\n * Uniform fields used: tone_mode, tone = (Reinhard: 1/Lw²; Naka–Rushton: σ, n, 1/g(Lw), σⁿ), lum = (kr, kg, kb, T).\n */\nconst LUMINANCE_FUNCTIONS = /* wgsl */ `\nconst LU: f32 = 5.9604644775390625e-8;\nconst ULP1: f32 = 1.1920928955078125e-7;\nfn count_max(slot: u32, value: f32) { atomicMax(&local_counters[slot], bitcast<u32>(max(value, 0.0))); }\n// (h, eta, abs_h): |h_gpu - h(l)| <= eta*h(l) + abs_h for the exact h at this float32 l > 0.\nfn tone_h(l: f32) -> vec3<f32> {\n  if (params.tone_mode == ${SDR_TONE_MODE.extendedReinhard}u) {\n    return vec3<f32>((1.0 + l * params.tone.x) / (1.0 + l), 14.0 * LU, 0.0);\n  }\n  let lg = log2(params.tone.x / l);\n  let n = params.tone.y;\n  let z = n * lg;\n  // log2: 2^-21 absolute or 3 ULP; the sigma/l division and sigma's rounding; the product's rounding.\n  let dz = n * (4.76837158203125e-7 + 3.0 * ULP1 * abs(lg) + 9.0 * LU) + 2.0 * LU * abs(z);\n  // exp2: 3 + 2|z| ULP; plus slack for the float64 reference's pow.\n  let rho = 0.7 * dz * (1.0 + dz) + (3.0 + 2.0 * abs(z)) * ULP1 + 9.094947e-13 * (1.0 + abs(z));\n  let eta = 2.0 * rho + 16.0 * LU;\n  if (z >= 0.0) {\n    let p = exp2(-z);\n    var abs_h = 0.0;\n    // Below 2^-120 the power may have flushed to zero: bound h absolutely instead.\n    if (p < 7.52316384526264e-37) { abs_h = params.tone.z * 3.009265538105056e-36 / l; }\n    return vec3<f32>(params.tone.z * p / (l * (1.0 + p)), eta, abs_h);\n  }\n  let p = exp2(z);\n  return vec3<f32>(params.tone.z / (l * (1.0 + p)), eta, 0.0);\n}\nstruct Toned { m: vec3<f32>, delta: vec3<f32>, changed_uncertain: bool };\nfn luminance_tone(e: vec3<f32>, eps: vec3<f32>) -> Toned {\n  var t: Toned;\n  let ae = abs(e);\n  let ea = ae + eps;\n  let s = (params.lum.x * ae.x + params.lum.y * ae.y) + params.lum.z * ae.z;\n  let l = (params.lum.x * e.x + params.lum.y * e.y) + params.lum.z * e.z;\n  let lambda = (((params.lum.x * eps.x + params.lum.y * eps.y) + params.lum.z * eps.z) + 6.0 * LU * s) * 1.001;\n  if (l < -2.0 * lambda || (l == 0.0 && lambda == 0.0)) {\n    // L < 0 for the reference too: both keep the exposed values.\n    t.m = e; t.delta = eps; t.changed_uncertain = false;\n    return t;\n  }\n  if (l > 2.0 * lambda) {\n    let r = tone_h(l);\n    let q = lambda / l;\n    let f = exp2(params.lum.w * log2((1.0 + q) / (1.0 - q))) / (1.0 - q) * 1.01;\n    let fq = params.lum.w * f * q;\n    let hh = r.x * (1.0 + 2.0 * r.y) + r.z;\n    t.m = e * r.x;\n    t.delta = (eps * hh * (1.0 + fq) + ea * (hh * (r.y + fq) + r.z) + 2.0 * LU * abs(t.m)) * 1.001;\n    t.changed_uncertain = abs(r.x - 1.0) <= 2.0 * (r.y + fq) * max(1.0, r.x) + r.z + 4.0 * LU;\n    return t;\n  }\n  // |L| is inside its classification band: either branch may run, so bound both.\n  var hsup = max(1.0, params.tone.x);\n  if (params.tone_mode == ${SDR_TONE_MODE.nakaRushton}u) {\n    hsup = params.tone.z * exp2((params.tone.y - 1.0) * log2(3.0 * lambda)) / params.tone.w * 1.01;\n  }\n  var m = e;\n  if (l > 0.0) { m = e * tone_h(l).x; }\n  t.m = m;\n  t.delta = (2.0 * ea * (1.0 + hsup * (1.0 + 1e-3))) * 1.001;\n  t.changed_uncertain = true;\n  return t;\n}\n// Classification, gamut handling and encoding of one luminance-toned sample (e exposed, m toned).\nfn render_toned(e: f32, source_nonzero: bool, band0: f32, band1: f32, m: f32, delta: f32, changed_uncertain: bool, reject: bool, maximum: f32) -> u32 {\n  var uncertain = (e == 0.0 && source_nonzero) || abs(e - 1.0) <= band1 || (band0 > 0.0 && abs(e) <= band0) || (changed_uncertain && e != 0.0);\n  // The reference value lies in [m - delta, m + delta]: uncertain only if that interval straddles a decision.\n  let gamut_uncertain = (m - delta < 0.0 && m + delta >= 0.0) || (m + delta > 1.0 && m - delta <= 1.0);\n  if (gamut_uncertain) { uncertain = true; count(${SDR_COUNTER.gamutUncertain}u); }\n  if (uncertain) { count(${SDR_COUNTER.uncertain}u); }\n  if (e < 0.0) { count(${SDR_COUNTER.negative}u); }\n  if (e > 1.0) { count(${SDR_COUNTER.above}u); }\n  if (m != e) { count(${SDR_COUNTER.changed}u); }\n  if (!(abs(m) + delta <= 1.2676506002282294e30)) { count(${SDR_COUNTER.luminanceDomain}u); }\n  var linear = m;\n  var bound = min(delta, 1.0);\n  if (m < 0.0 || m > 1.0) {\n    if (reject) { count(${SDR_COUNTER.outOfGamut}u); }\n    else if (m < 0.0) { count(${SDR_COUNTER.low}u); linear = 0.0; }\n    else { count(${SDR_COUNTER.high}u); linear = 1.0; }\n  }\n  // Clipping is 1-Lipschitz; when both values clip to the same end the difference is zero.\n  if (!reject && (m - delta >= 1.0 || m + delta <= 0.0)) { bound = 0.0; }\n  count_max(${SDR_COUNTER.linearBoundBits}u, bound);\n  let code = floor(encode_srgb(linear) * maximum + 0.5);\n  return u32(clamp(code, 0.0, maximum));\n}\n`;\n\n/** Pointwise SDR over a packed float32 band; one invocation per sample. */\nexport const SDR_WGSL = /* wgsl */ `\nstruct Params { count: u32, reinhard: u32, reject: u32, pad0: u32, scale: f32, maximum: f32, band1: f32, pad1: f32 };\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> source: array<f32>;\n@group(0) @binding(2) var<storage, read_write> codes: array<u32>;\n@group(0) @binding(3) var<storage, read_write> counters: array<atomic<u32>, ${SDR_COUNTER_SLOTS}>;\n${SDR_FUNCTIONS}\n@compute @workgroup_size(${LINEAR_WORKGROUP_SIZE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) local_index: u32,\n        @builtin(num_workgroups) groups: vec3<u32>) {\n  clear_counters(local_index);\n  let i = gid.x + gid.y * groups.x * ${LINEAR_WORKGROUP_SIZE}u;\n  if (i < params.count) {\n    let s = source[i];\n    codes[i] = render_sample(s * params.scale, s != 0.0, 0.0, params.band1, params.reinhard != 0u, params.reject != 0u, params.maximum);\n  }\n  flush_counters(local_index);\n}\n`;\n\n/** Pointwise SDR with a luminance tone curve over a packed float32 band; one invocation per pixel. */\nexport const SDR_LUMINANCE_WGSL = /* wgsl */ `\nstruct Params { pixels: u32, reject: u32, tone_mode: u32, pad0: u32, scale: f32, maximum: f32, band1: f32, pad1: f32,\n  tone: vec4<f32>, lum: vec4<f32> };\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> source: array<f32>;\n@group(0) @binding(2) var<storage, read_write> codes: array<u32>;\n@group(0) @binding(3) var<storage, read_write> counters: array<atomic<u32>, ${SDR_COUNTER_SLOTS}>;\n${SDR_FUNCTIONS}\n${LUMINANCE_FUNCTIONS}\n@compute @workgroup_size(${LINEAR_WORKGROUP_SIZE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) local_index: u32,\n        @builtin(num_workgroups) groups: vec3<u32>) {\n  clear_counters(local_index);\n  let i = gid.x + gid.y * groups.x * ${LINEAR_WORKGROUP_SIZE}u;\n  if (i < params.pixels) {\n    let s = vec3<f32>(source[i * 3u], source[i * 3u + 1u], source[i * 3u + 2u]);\n    let e = s * params.scale;\n    // Source, scale and product roundings (plus the reference's own), and an absolute term where a non-zero source may underflow.\n    var eps = 4.0 * LU * abs(e);\n    for (var j = 0u; j < 3u; j++) {\n      if (s[j] != 0.0 && abs(e[j]) < 7.888609052210118e-31) { eps[j] = eps[j] + 2.350988701644575e-38 * max(1.0, params.scale); }\n    }\n    let t = luminance_tone(e, eps);\n    let reject = params.reject != 0u;\n    for (var j = 0u; j < 3u; j++) {\n      codes[i * 3u + j] = render_toned(e[j], s[j] != 0.0, 0.0, params.band1, t.m[j], t.delta[j], t.changed_uncertain, reject, params.maximum);\n    }\n  }\n  flush_counters(local_index);\n}\n`;\n\n/**\n * Packed native RAW development of one band of output rows; one invocation per output pixel.\n * `normalized` holds the host's float64 site values, rounded once to float32. A saturated site\n * (flagged, or at or above its phase white level) is exactly 1. Any other site is\n * (code − black)/(white − black) ≤ 1 − 1/65535. So a saturated contributing site is recognised exactly.\n * Highlight handling matches `prepareSensorColorDevelopment` (clip at the smallest applied gain, or the\n * declared neutral blend).\n */\nexport const RAW_DEVELOPMENT_WGSL = /* wgsl */ `\nstruct Params {\n  width: u32, count: u32, row0: u32, reinhard: u32,\n  reject: u32, repeat_w: u32, repeat_h: u32, region_w: u32,\n  origin_x: i32, origin_y: i32, axx: i32, axy: i32,\n  ayx: i32, ayy: i32, region_x: i32, region_y: i32,\n  scale: f32, maximum: f32, band0: f32, band1: f32,\n  clip_level: f32, reconstruct: u32, band_u: f32, band_s: f32,\n  gains: vec4<f32>,\n  m0: vec4<f32>, m1: vec4<f32>, m2: vec4<f32>,\n  x0: vec4<f32>, x1: vec4<f32>, x2: vec4<f32>,\n  tone_mode: u32, pad0: u32, pad1: u32, pad2: u32,\n  tone: vec4<f32>, lum: vec4<f32>,\n};\nstruct Tap { ox: i32, oy: i32, w: f32, pad: f32 };\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> normalized: array<f32>;\n@group(0) @binding(2) var<storage, read> taps: array<Tap>;\n@group(0) @binding(3) var<storage, read> phases: array<vec2<u32>>;\n@group(0) @binding(4) var<storage, read_write> codes: array<u32>;\n@group(0) @binding(5) var<storage, read_write> counters: array<atomic<u32>, ${SDR_COUNTER_SLOTS}>;\n${SDR_FUNCTIONS}\n${LUMINANCE_FUNCTIONS}\nvar<private> saturated: bool;\nfn channel(phase: u32, c: u32, nx: i32, ny: i32) -> f32 {\n  let range = phases[phase * 3u + c];\n  var value = 0.0;\n  for (var k = 0u; k < range.y; k++) {\n    let t = taps[range.x + k];\n    let sx = nx + t.ox - params.region_x;\n    let sy = ny + t.oy - params.region_y;\n    let site = normalized[u32(sy) * params.region_w + u32(sx)];\n    if (site == 1.0) { saturated = true; }\n    value = value + site * t.w;\n  }\n  return value;\n}\nfn row3(m: vec4<f32>, v: vec3<f32>) -> f32 { return ((0.0 + m.x * v.x) + m.y * v.y) + m.z * v.z; }\nfn max3(v: vec3<f32>) -> f32 {\n  if (v.x > v.y) { if (v.x > v.z) { return v.x; } return v.z; }\n  if (v.y > v.z) { return v.y; }\n  return v.z;\n}\n@compute @workgroup_size(${LINEAR_WORKGROUP_SIZE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) local_index: u32,\n        @builtin(num_workgroups) groups: vec3<u32>) {\n  clear_counters(local_index);\n  let i = gid.x + gid.y * groups.x * ${LINEAR_WORKGROUP_SIZE}u;\n  if (i < params.count) {\n    let col = i32(i % params.width);\n    let row = i32(params.row0 + i / params.width);\n    let nx = params.origin_x + params.axx * col + params.axy * row;\n    let ny = params.origin_y + params.ayx * col + params.ayy * row;\n    let phase = (u32(ny) % params.repeat_h) * params.repeat_w + u32(nx) % params.repeat_w;\n    saturated = false;\n    let c = vec3<f32>(channel(phase, 0u, nx, ny), channel(phase, 1u, nx, ny), channel(phase, 2u, nx, ny));\n    if (saturated) { count(${SDR_COUNTER.saturatedPixels}u); }\n    let u = vec3<f32>(c.x * params.gains.x, c.y * params.gains.y, c.z * params.gains.z);\n    let clip = params.clip_level;\n    let k = vec3<f32>(select(u.x, clip, u.x > clip), select(u.y, clip, u.y > clip), select(u.z, clip, u.z > clip));\n    var b = k;\n    if (params.reconstruct == 0u) {\n      for (var j = 0u; j < 3u; j++) {\n        if (u[j] > clip) { count(${SDR_COUNTER.whiteBalanceClipped}u); }\n        if (abs(u[j] - clip) <= params.band_u) { count(${SDR_COUNTER.uncertain}u); }\n      }\n    } else {\n      let s = max3(c);\n      if (abs(s - ${RAW_HIGHLIGHT_START_WGSL}) <= params.band_s) { count(${SDR_COUNTER.uncertain}u); }\n      if (s > ${RAW_HIGHLIGHT_START_WGSL}) {\n        var t = 1.0;\n        if (s < 1.0) { t = (s - ${RAW_HIGHLIGHT_START_WGSL}) / (1.0 - ${RAW_HIGHLIGHT_START_WGSL}); }\n        let n = max3(k);\n        b = (1.0 - t) * u + t * vec3<f32>(n, n, n);\n        count(${SDR_COUNTER.reconstructedPixels}u);\n      } else {\n        b = u;\n      }\n    }\n    let xyz = vec3<f32>(row3(params.m0, b), row3(params.m1, b), row3(params.m2, b));\n    let rgb = vec3<f32>(row3(params.x0, xyz), row3(params.x1, xyz), row3(params.x2, xyz));\n    let reinhard = params.reinhard != 0u;\n    let reject = params.reject != 0u;\n    if (params.tone_mode == ${SDR_TONE_MODE.perChannel}u) {\n      for (var j = 0u; j < 3u; j++) {\n        codes[i * 3u + j] = render_sample(rgb[j] * params.scale, false, params.band0, params.band1, reinhard, reject, params.maximum);\n      }\n    } else {\n      // band0 bounds each exposed value against the reference (the development chain's a-priori bound).\n      let e = rgb * params.scale;\n      let t = luminance_tone(e, vec3<f32>(params.band0, params.band0, params.band0));\n      for (var j = 0u; j < 3u; j++) {\n        codes[i * 3u + j] = render_toned(e[j], false, params.band0, params.band1, t.m[j], t.delta[j], t.changed_uncertain, reject, params.maximum);\n      }\n    }\n  }\n  flush_counters(local_index);\n}\n`;\n\n/** Source-indexed isoplanatic-patch convolution of one output-row band; one invocation per output site. */\nexport const IRRADIANCE_CONVOLUTION_WGSL = /* wgsl */ `\nstruct Params {\n  width: u32, height: u32, radius: u32, size: u32,\n  patch_w: u32, patch_h: u32, cols: u32, rows: u32,\n  out_row0: u32, out_rows: u32, in_row0: u32, taps: u32,\n};\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> source: array<f32>;\n@group(0) @binding(2) var<storage, read> kernels: array<f32>;\n@group(0) @binding(3) var<storage, read_write> result: array<f32>;\n@compute @workgroup_size(${CONVOLUTION_WORKGROUP_EDGE}, ${CONVOLUTION_WORKGROUP_EDGE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let x = gid.x;\n  let local_y = gid.y;\n  if (x >= params.width || local_y >= params.out_rows) { return; }\n  let y = i32(params.out_row0 + local_y);\n  let r = i32(params.radius);\n  var sum = 0.0;\n  for (var v = -r; v <= r; v++) {\n    let sy = y - v;\n    if (sy < 0 || sy >= i32(params.height)) { continue; }\n    let patch_row = min(u32(sy) / params.patch_h, params.rows - 1u) * params.cols;\n    let kernel_row = (v + r) * i32(params.size) + r;\n    let source_row = (u32(sy) - params.in_row0) * params.width;\n    for (var u = -r; u <= r; u++) {\n      let sx = i32(x) - u;\n      if (sx < 0 || sx >= i32(params.width)) { continue; }\n      let patch_index = patch_row + min(u32(sx) / params.patch_w, params.cols - 1u);\n      sum = sum + source[source_row + u32(sx)] * kernels[patch_index * params.taps + u32(kernel_row + u)];\n    }\n  }\n  result[local_y * params.width + x] = sum;\n}\n`;\n"]}