@photivra/engine 2.13.0 → 2.14.1

package/dist/gpu/wgsl-display-view-speed-kernel.js.map

@@ -1 +1 @@
-{"version":3,"file":"wgsl-display-view-speed-kernel.js","sourceRoot":"","sources":["../../src/gpu/wgsl-display-view-speed-kernel.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,CAAC;AAC9C,6GAA6G;AAC7G,MAAM,CAAC,MAAM,wCAAwC,GAAG,CAAC,CAAC;AAC1D,MAAM,CAAC,MAAM,4BAA4B,GAAG,wCAAwC,GAAG,CAAC,CAAC;AACzF,iGAAiG;AACjG,MAAM,CAAC,MAAM,gCAAgC,GAAG,EAAE,CAAC;AACnD,yIAAyI;AACzI,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAC7C,8DAA8D;AAC9D,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,CAAC;AAC/C,+CAA+C;AAC/C,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC;IAC5C,yEAAyE;IACzE,OAAO,EAAE,CAAC;IACV,4FAA4F;IAC5F,IAAI,EAAE,EAAE;IACR,2DAA2D;IAC3D,SAAS,EAAE,GAAG;IACd,0DAA0D;IAC1D,aAAa,EAAE,GAAG;IAClB,IAAI,EAAE,GAAG;CACV,CAAC,CAAC;AACH,yEAAyE;AACzE,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,CAAC;AAC3C,qIAAqI;AACrI,MAAM,SAAS,GAAG,uBAAuB,CAAC;AAC1C;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,CAAC;AAC7C,MAAM,CAAC,MAAM,4BAA4B,GAAG,KAAK,CAAC;AAClD,8GAA8G;AAC9G,MAAM,CAAC,MAAM,4BAA4B,GAAG,GAAG,CAAC;AAChD,MAAM,CAAC,MAAM,gCAAgC,GAAG,GAAG,CAAC;AAEpD,MAAM,OAAO,GAAG,CAAC,KAAa,EAAU,EAAE;IACxC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACxC,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC;AACjD,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,UAAU,CAAC;iBACxC,SAAS;;;2BAGC,OAAO,CAAC,wBAAwB,CAAC;+BAC7B,OAAO,CAAC,4BAA4B,CAAC;sBAC9C,4BAA4B;sBAC5B,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA2GjB,gBAAgB,CAAC,aAAa;;iCAE9B,gBAAgB,CAAC,aAAa,GAAG,EAAE;;;;;;;;;;;;;;;;;;;;;;iBAsBnD,gBAAgB,CAAC,OAAO;;;;;;;;2BAQd,2BAA2B;;uCAEf,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiE7C,gBAAgB,CAAC,IAAI;;;;;;;;;;kCAUR,gBAAgB,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DA8DF,gBAAgB,CAAC,SAAS;;;;;;;;;gBASpE,0BAA0B;;;;;;;CAOzC,CAAC;AAEF,iGAAiG;AACjG,MAAM,UAAU,4BAA4B,CAAC,kBAA0B;IACrE,OAAO,8BAA8B,GAAG,IAAI,GAAG,kBAAkB,GAAG,IAAI,CAAC;AAC3E,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * WGSL kernel of the display view's Speed path on the GPU (#478): one invocation per display pixel of the exact\n * area mean (docs/DISPLAY_VIEW.md, \"Exact area mean\") without diffraction, with the bilinear demosaic and chart\n * materials. It evaluates `renderDisplayView`'s per-sample loop (facade/display-view.ts) for every real pixel of the\n * display pixel's footprint, in the reference's operation order where the order matters, in float32:\n *\n * 1. the real pixels the footprint covers and their overlap weights a_j = w_j / A (the host computes the 1-D overlaps\n *    divided by the scale in float64; the kernel multiplies the two axes);\n * 2. for every native site the real pixels' demosaic reads (the footprint plus one site of reach), the expected\n *    electrons: the scene material at the pixel aperture's query offsets (the material module, `material_at`), the\n *    material's channel signal from a table the host computed in float64 (Σ_λ A_c(λ)·L(λ)), summed over the offsets\n *    in the reference's order, plus the dark electrons;\n * 3. the readout moments of each site (mean k·e, variance k²·e + c₀, third cumulant k³·e) and the clip at the white\n *    level (the clipped-normal moments, in a cancellation-free standardized form);\n * 4. per real pixel the bilinear kernels, white balance and highlight clip, the colour matrix, the tone curve\n *    (identity, or positive Reinhard by the reference's 4 × 16-point Gauss–Legendre rule) and the clip to [0, 1] with\n *    the first-order skewness term;\n * 5. the display pixel's expected value Σ_j a_j·E[L_j], the linear (Stein) covariance Σ_c B_c·σ_c²·a_c·a_cᵀ with the\n *    closed-form B_c of the footprint, and the independent residual Σ_j a_j²·r_j.\n *\n * It outputs, per display pixel, the three means, the three variances (linear plus residual), the three covariances\n * and two running error terms: the absolute error bound of the mean and of the variance that the clip steps\n * contribute (a fixed formula evaluated from the pixel's own float32 values; docs/WEBGPU.md, \"Display view (Speed)\").\n * The host adds the output quantization term, draws the noise, encodes and rounds (`display-view-speed-gpu.ts`), so\n * the noise draw is the CPU's bit for bit.\n *\n * Precision: float32 with an a-priori bound per step from the WGSL accuracy table (+ − × within one float32 rounding in\n * either direction, E = 2^-23; division 2.5 ULP, sqrt 4.5 ULP, exp 3 + 2|x| ULP; no trigonometric built-in is used). Every quotient that is a constant of\n * the request (the overlaps over the scale, the axis sums over the squared scale, 1/Σw² of the demosaic kernels) is\n * computed on the host in float64 and uploaded. Data-dependent quotients (z = (t − m)/s, the Abramowitz–Stegun t,\n * the skewness) carry the 2.5 ULP bound.\n */\n\nexport const DISPLAY_VIEW_WORKGROUP_SIZE = 64;\n/** Largest footprint per axis (real pixels): the site window is (n + 2)² ≤ 64 entries of private storage. */\nexport const DISPLAY_VIEW_GPU_MAXIMUM_PIXELS_PER_AXIS = 6;\nexport const DISPLAY_VIEW_GPU_WINDOW_SIDE = DISPLAY_VIEW_GPU_MAXIMUM_PIXELS_PER_AXIS + 2;\n/** Largest number of query offsets (pixel-aperture nodes × filter spots) the aux table holds. */\nexport const DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS = 16;\n/** Floats per display pixel in the output buffer: m0 m1 m2, v00 v11 v22 (linear + residual), c01 c02 c12, mean bound, variance bound. */\nexport const DISPLAY_VIEW_OUTPUT_FLOATS = 11;\n/** Floats per column or row record of the geometry buffer. */\nexport const DISPLAY_VIEW_GEOMETRY_STRIDE = 20;\n/** Layout of the aux table (float32 words). */\nexport const DISPLAY_VIEW_AUX = Object.freeze({\n  /** Per offset o: ou (0.5 + ox − W/2), ov (0.5 + oy − H/2), weight, 0. */\n  offsets: 0,\n  /** Per phase p, channel c, tap t: dx, dy, weight, 0 (4 taps; unused taps have weight 0). */\n  taps: 64,\n  /** Per phase p, channel c: 1 / Σ_t w_t² (host float64). */\n  inverseW2: 256,\n  /** 16 Gauss–Legendre nodes then 16 weights on [−1, 1]. */\n  gaussLegendre: 272,\n  size: 304\n});\n/** Uniform parameter words (see `Params` below): 40 words, 160 bytes. */\nexport const DISPLAY_VIEW_PARAM_WORDS = 40;\n/** The `E` of the bounds: one WGSL rounding of + − × in either direction, 2^-23 (W3C WGSL \"Floating Point Accuracy\"; #471, #487). */\nconst E_LITERAL = \"1.1920928955078125e-7\";\n/**\n * Clip-step constants of the running bound, in units of E (docs/WEBGPU.md, \"Display view (Speed)\", derivation): the\n * absolute error of the clipped-normal mean in units of the standard deviation (`CLIP_MEAN_U`) and of its variance in\n * units of the variance (`CLIP_VARIANCE_U`), for one clip side. The host doubles every bound (MARGIN).\n */\nexport const DISPLAY_VIEW_CLIP_MEAN_U = 1400;\nexport const DISPLAY_VIEW_CLIP_VARIANCE_U = 36000;\n/** The additional relative error of the Reinhard quadrature, in units of E, for the mean and the variance. */\nexport const DISPLAY_VIEW_REINHARD_MEAN_U = 256;\nexport const DISPLAY_VIEW_REINHARD_VARIANCE_U = 512;\n\nconst literal = (value: number): string => {\n  const text = String(Math.fround(value));\n  return /[.e]/u.test(text) ? text : `${text}.0`;\n};\n\n/**\n * The kernel's own WGSL, without the material module. `assembleDisplayViewSpeedWgsl` appends a module that defines\n * `fn material_at(p: vec2<f32>) -> u32` and `var<private> material_uncertain: bool` (set to true when the point's\n * classification is within its bound of a material boundary; the kernel then flags the display pixel for host\n * recomputation). The module may declare bindings in @group(1) and use the constants E and SLACK declared here.\n */\nexport const DISPLAY_VIEW_SPEED_KERNEL_WGSL = /* wgsl */ `\nconst E: f32 = ${E_LITERAL};\nconst SLACK: f32 = 1e-14;\nconst CLIP_REACH: f32 = 8.5;\nconst CLIP_MEAN_U: f32 = ${literal(DISPLAY_VIEW_CLIP_MEAN_U)};\nconst CLIP_VARIANCE_U: f32 = ${literal(DISPLAY_VIEW_CLIP_VARIANCE_U)};\nconst WINDOW: u32 = ${DISPLAY_VIEW_GPU_WINDOW_SIDE}u;\nconst STRIDE: u32 = ${DISPLAY_VIEW_GEOMETRY_STRIDE}u;\nstruct Params {\n  count: u32, row0: u32, region_w: u32, region_x: u32,\n  region_y: u32, margin: u32, native_w: u32, native_h: u32,\n  columns: u32, tone: u32, offsets: u32, pad0: u32,\n  k0: f32, k1: f32, k2: f32, reach2: f32,\n  dark0: f32, dark1: f32, dark2: f32, clip_level: f32,\n  c0_0: f32, c0_1: f32, c0_2: f32, pad1: f32,\n  g0: f32, g1: f32, g2: f32, pad2: f32,\n  m00: f32, m01: f32, m02: f32, m10: f32,\n  m11: f32, m12: f32, m20: f32, m21: f32,\n  m22: f32, scale_u: f32, scale_v: f32, pad3: f32,\n};\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> aux: array<f32>;\n@group(0) @binding(2) var<storage, read> geometry: array<f32>;\n@group(0) @binding(3) var<storage, read> site_table: array<f32>;\n@group(0) @binding(4) var<storage, read_write> out: array<f32>;\n@group(0) @binding(5) var<storage, read_write> flags: array<u32>;\n\nvar<private> site_mean: array<f32, 64>;\nvar<private> site_var: array<f32, 64>;\nvar<private> site_third: array<f32, 64>;\nvar<private> site_bound: array<f32, 64>;\n\nfn k_of(c: u32) -> f32 { if (c == 0u) { return params.k0; } if (c == 1u) { return params.k1; } return params.k2; }\nfn dark_of(c: u32) -> f32 { if (c == 0u) { return params.dark0; } if (c == 1u) { return params.dark1; } return params.dark2; }\nfn c0_of(c: u32) -> f32 { if (c == 0u) { return params.c0_0; } if (c == 1u) { return params.c0_1; } return params.c0_2; }\nfn g_of(c: u32) -> f32 { if (c == 0u) { return params.g0; } if (c == 1u) { return params.g1; } return params.g2; }\nfn m_of(r: u32, c: u32) -> f32 {\n  let i = r * 3u + c;\n  switch (i) {\n    case 0u: { return params.m00; } case 1u: { return params.m01; } case 2u: { return params.m02; }\n    case 3u: { return params.m10; } case 4u: { return params.m11; } case 5u: { return params.m12; }\n    case 6u: { return params.m20; } case 7u: { return params.m21; } default: { return params.m22; }\n  }\n}\n// Standard normal density, as the reference forms it: 0.3989422804014327·exp(−0.5·z·z).\nfn phi(z: f32) -> f32 { return 0.3989422804014327 * exp(-0.5 * z * z); }\n// Abramowitz & Stegun 26.2.17: returns (Φ(z), 1 − Φ(z)), each formed from the tail q directly where it is small.\nfn pq(z: f32) -> vec2<f32> {\n  let x = abs(z);\n  let t = 1.0 / (1.0 + 0.2316419 * x);\n  let q = phi(x) * t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));\n  if (z >= 0.0) { return vec2<f32>(1.0 - q, q); }\n  return vec2<f32>(q, 1.0 - q);\n}\n// Moments of min(Y, top) for Y ~ N(m, v): (mean, variance, slope P). The variance is v·(P − zφ + z²Q − δ²) with\n// δ = φ − zQ: algebraically E[min²] − E[min]² without the m² cancellation.\nfn upper_clip(m: f32, v: f32, top: f32) -> vec3<f32> {\n  if (!(v > 0.0)) { return vec3<f32>(min(m, top), 0.0, select(0.0, 1.0, m < top)); }\n  let s = sqrt(v);\n  let z = (top - m) / s;\n  if (z > CLIP_REACH) { return vec3<f32>(m, v, 1.0); }\n  if (z < -CLIP_REACH) { return vec3<f32>(top, 0.0, 0.0); }\n  let p = pq(z);\n  let d = phi(z);\n  let delta = d - z * p.y;\n  let mean = m - s * delta;\n  let ratio = p.x - z * d + z * z * p.y - delta * delta;\n  return vec3<f32>(mean, v * max(0.0, ratio), p.x);\n}\n// Moments of clip(Y, 0, 1) for Y with mean m, variance v and standardized skewness γ (|γ| ≤ 1): (mean, variance, inside).\n// With Z standard normal, W = m + s·g(Z), g = clip(Z, a, b): E[g] = aΦa + φa − φb + bQb, E[g²] = a²Φa + (Φb − Φa) −\n// (bφb − aφa) + b²Qb; the mean adds the reference's Edgeworth term (s·γ/6)·(aφa − bφb).\nfn unit_clip(m: f32, v: f32, skewness: f32) -> vec3<f32> {\n  if (!(v > 0.0)) { return vec3<f32>(clamp(m, 0.0, 1.0), 0.0, select(0.0, 1.0, m > 0.0 && m < 1.0)); }\n  let s = sqrt(v);\n  let a = -m / s;\n  let b = (1.0 - m) / s;\n  if (a < -CLIP_REACH && b > CLIP_REACH) { return vec3<f32>(m, v, 1.0); }\n  var pa = 0.0; var da = 0.0;\n  if (!(a < -CLIP_REACH)) { pa = pq(a).x; da = phi(a); }\n  var pb = 1.0; var qb = 0.0; var db = 0.0;\n  if (!(b > CLIP_REACH)) { let p = pq(b); pb = p.x; qb = p.y; db = phi(b); }\n  let inside = pb - pa;\n  let gamma = clamp(skewness, -1.0, 1.0);\n  let aa = a * da;\n  let bb = b * db;\n  let eg = a * pa + (da - db) + b * qb;\n  let eg2 = a * a * pa + inside - (bb - aa) + b * b * qb;\n  let normal_mean = m + s * eg;\n  var mean = normal_mean;\n  var skew_shift = 0.0;\n  if (gamma != 0.0) { skew_shift = s * gamma / 6.0 * (aa - bb); mean = normal_mean + skew_shift; }\n  // The reference forms E[Y²] − (E[Y] + shift)², so the shift also enters its variance: −shift·(2·E[Y] + shift).\n  return vec3<f32>(mean, max(0.0, v * (eg2 - eg * eg) - skew_shift * (2.0 * normal_mean + skew_shift)), inside);\n}\n// Positive Reinhard per channel then the clip to [0, 1]: h(x) = x/(1 + x) for x > 0, else 0. Composite 16-point\n// Gauss–Legendre over [max(0, m − 8.5s), m + 8.5s] in 4 panels, as the reference; the variance is formed about h(m).\nfn reinhard_moments(m: f32, v: f32) -> vec3<f32> {\n  if (!(v > 0.0)) {\n    if (m > 0.0) { return vec3<f32>(m / (1.0 + m), 0.0, 1.0 / ((1.0 + m) * (1.0 + m))); }\n    return vec3<f32>(0.0, 0.0, 0.0);\n  }\n  let s = sqrt(v);\n  // The reference's panels [max(0, m − 8.5s), m + 8.5s] in standardized units z = (x − m)/s, so the node's z is formed\n  // without the cancellation x − m: zlo = max(−m/s, −8.5), weight = zhalf·w_k·φ(z_k) (= half·w_k·φ((x − m)/s)/s), x = m + s·z.\n  let zlo = max(-m / s, -CLIP_REACH);\n  if (!(CLIP_REACH > zlo)) { return vec3<f32>(0.0, 0.0, 0.0); }\n  let hm = select(0.0, m / (1.0 + m), m > 0.0);\n  var e1 = 0.0; var e2 = 0.0; var ed = 0.0;\n  let zwidth = (CLIP_REACH - zlo) / 4.0;\n  for (var p = 0u; p < 4u; p = p + 1u) {\n    let zc = zlo + (f32(p) + 0.5) * zwidth;\n    let zhalf = zwidth / 2.0;\n    for (var k = 0u; k < 16u; k = k + 1u) {\n      let z = zc + zhalf * aux[${DISPLAY_VIEW_AUX.gaussLegendre}u + k];\n      let x = m + s * z;\n      let weight = zhalf * aux[${DISPLAY_VIEW_AUX.gaussLegendre + 16}u + k] * phi(z);\n      let h = x / (1.0 + x);\n      e1 = e1 + weight * h;\n      e2 = e2 + weight * (h - hm) * (h - hm);\n      ed = ed + weight / ((1.0 + x) * (1.0 + x));\n    }\n  }\n  let shifted = e1 - hm;\n  return vec3<f32>(e1, max(0.0, e2 - shifted * shifted), ed);\n}\nfn reflect_x(x: i32) -> i32 { if (x < 0) { return -x; } if (x >= i32(params.native_w)) { return 2 * i32(params.native_w) - 2 - x; } return x; }\nfn reflect_y(y: i32) -> i32 { if (y < 0) { return -y; } if (y >= i32(params.native_h)) { return 2 * i32(params.native_h) - 2 - y; } return y; }\nfn channel_of(x: i32, y: i32) -> u32 {\n  if ((y & 1) == 0) { return select(1u, 0u, (x & 1) == 0); }\n  return select(2u, 1u, (x & 1) == 0);\n}\n// The expected photo electrons of native site (x, y): Σ_o w_o·table[m_o, c] in offset order (directSite).\nfn site_electrons(x: i32, y: i32, c: u32) -> f32 {\n  var sum = 0.0;\n  let fx = f32(x);\n  let fy = f32(y);\n  for (var o = 0u; o < params.offsets; o = o + 1u) {\n    let base = ${DISPLAY_VIEW_AUX.offsets}u + 4u * o;\n    let u = (fx + aux[base]) * params.scale_u;\n    let v = (fy + aux[base + 1u]) * params.scale_v;\n    let m = material_at(vec2<f32>(u, v));\n    sum = sum + aux[base + 2u] * site_table[m * 3u + c];\n  }\n  return sum;\n}\n@compute @workgroup_size(${DISPLAY_VIEW_WORKGROUP_SIZE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) groups: vec3<u32>) {\n  let i = gid.x + gid.y * groups.x * ${DISPLAY_VIEW_WORKGROUP_SIZE}u;\n  if (i >= params.count) { return; }\n  material_uncertain = false;\n  let rx = i % params.region_w;\n  let ry = params.row0 + i / params.region_w;\n  let col = rx * STRIDE;\n  let row = (params.columns + ry) * STRIDE;\n  let col_first = bitcast<i32>(geometry[col]);\n  let nx = bitcast<u32>(geometry[col + 1u]);\n  let row_first = bitcast<i32>(geometry[row]);\n  let ny = bitcast<u32>(geometry[row + 1u]);\n  let margin = i32(params.margin);\n  // 2. and 3.: the sites of the footprint plus one site of reach, once each.\n  let x0 = col_first + margin - 1;\n  let y0 = row_first + margin - 1;\n  let window_w = nx + 2u;\n  for (var sj = 0u; sj < ny + 2u; sj = sj + 1u) {\n    let sy = reflect_y(y0 + i32(sj));\n    for (var si = 0u; si < window_w; si = si + 1u) {\n      let sx = reflect_x(x0 + i32(si));\n      let c = channel_of(sx, sy);\n      let e = site_electrons(sx, sy, c) + dark_of(c);\n      let kc = k_of(c);\n      let mean = kc * e;\n      let variance = kc * kc * e + c0_of(c);\n      let gap = 1.0 - mean;\n      let slot = sj * window_w + si;\n      site_third[slot] = kc * kc * kc * e;\n      if (gap > 0.0 && gap * gap > params.reach2 * variance) {\n        site_mean[slot] = mean; site_var[slot] = variance; site_bound[slot] = 0.0;\n      } else {\n        let clipped = upper_clip(mean, variance, 1.0);\n        site_mean[slot] = clipped.x; site_var[slot] = clipped.y; site_bound[slot] = sqrt(variance);\n      }\n    }\n  }\n  // B_c of the footprint from the host's axis sums (each over its scale squared): red, green, blue.\n  let xb_even = geometry[col + 8u]; let xb_odd = geometry[col + 9u];\n  let xpp_even = geometry[col + 10u]; let xpp_odd = geometry[col + 11u];\n  let xqq_even = geometry[col + 12u]; let xqq_odd = geometry[col + 13u];\n  let xpq_even = geometry[col + 14u]; let xpq_odd = geometry[col + 15u];\n  let yb_even = geometry[row + 8u]; let yb_odd = geometry[row + 9u];\n  let ypp_even = geometry[row + 10u]; let ypp_odd = geometry[row + 11u];\n  let yqq_even = geometry[row + 12u]; let yqq_odd = geometry[row + 13u];\n  let ypq_even = geometry[row + 14u]; let ypq_odd = geometry[row + 15u];\n  let b0 = xb_even * yb_even;\n  let b1 = (xpp_odd * ypp_even + xqq_odd * ypp_even + xpp_odd * yqq_even + 2.0 * xpq_odd * ypp_even + 2.0 * xpp_odd * ypq_even + 2.0 * xpq_odd * ypq_even) +\n    (xpp_even * ypp_odd + xqq_even * ypp_odd + xpp_even * yqq_odd + 2.0 * xpq_even * ypp_odd + 2.0 * xpp_even * ypq_odd + 2.0 * xpq_even * ypq_odd);\n  let b2 = xb_odd * yb_odd;\n  let reinhard = params.tone == 1u;\n  var s0 = 0.0; var s1 = 0.0; var s2 = 0.0;\n  var c00 = 0.0; var c01 = 0.0; var c02 = 0.0; var c11 = 0.0; var c12 = 0.0; var c22 = 0.0;\n  var r0 = 0.0; var r1 = 0.0; var r2 = 0.0;\n  var bound_mean = 0.0; var bound_var = 0.0;\n  // 4. and 5.: every real pixel of the footprint with its overlap weight.\n  for (var j = 0u; j < ny; j = j + 1u) {\n    let ay = geometry[row + 2u + j];\n    for (var ii = 0u; ii < nx; ii = ii + 1u) {\n      let aj = geometry[col + 2u + ii] * ay;\n      let x = col_first + i32(ii) + margin;\n      let y = row_first + i32(j) + margin;\n      let phase = u32(y & 1) * 2u + u32(x & 1);\n      var cm: array<f32, 3>; var cvv: array<f32, 3>; var cth: array<f32, 3>; var csv: array<f32, 3>; var cb: array<f32, 3>;\n      for (var c = 0u; c < 3u; c = c + 1u) {\n        var mean = 0.0; var variance = 0.0; var third = 0.0; var bnd = 0.0;\n        let taps = ${DISPLAY_VIEW_AUX.taps}u + (phase * 3u + c) * 16u;\n        for (var t = 0u; t < 4u; t = t + 1u) {\n          let w = aux[taps + 4u * t + 2u];\n          let slot = u32((i32(j) + 1 + i32(aux[taps + 4u * t + 1u])) * i32(window_w) + i32(ii) + 1 + i32(aux[taps + 4u * t]));\n          mean = mean + w * site_mean[slot];\n          variance = variance + w * w * site_var[slot];\n          third = third + w * w * w * site_third[slot];\n          bnd = max(bnd, select(0.0, site_bound[slot], w != 0.0));\n        }\n        cm[c] = mean; cvv[c] = variance; cth[c] = third; cb[c] = bnd;\n        csv[c] = variance * aux[${DISPLAY_VIEW_AUX.inverseW2}u + phase * 3u + c];\n      }\n      // White balance and the highlight clip at the smallest gain: bm, bv, bs (slope), with the clip's bound terms.\n      var bm: array<f32, 3>; var bv: array<f32, 3>; var bs: array<f32, 3>; var bbm: array<f32, 3>; var bbv: array<f32, 3>;\n      for (var c = 0u; c < 3u; c = c + 1u) {\n        let gc = g_of(c);\n        let um = gc * cm[c];\n        let uv = gc * gc * cvv[c];\n        let gap = params.clip_level - um;\n        bbm[c] = gc * CLIP_MEAN_U * cb[c];\n        bbv[c] = gc * gc * CLIP_VARIANCE_U * cb[c] * cb[c];\n        if (gap > 0.0 && gap * gap > params.reach2 * uv) { bm[c] = um; bv[c] = uv; bs[c] = gc; }\n        else {\n          let clipped = upper_clip(um, uv, params.clip_level);\n          bm[c] = clipped.x; bv[c] = clipped.y; bs[c] = gc * clipped.z;\n          bbm[c] = bbm[c] + CLIP_MEAN_U * sqrt(uv);\n          bbv[c] = bbv[c] + CLIP_VARIANCE_U * uv;\n        }\n      }\n      // Colour matrix, then the rendering of each component (tone curve, clip to [0, 1]).\n      var hm: array<f32, 3>; var hv: array<f32, 3>; var hs: array<f32, 3>; var hbm: array<f32, 3>; var hbv: array<f32, 3>;\n      for (var comp = 0u; comp < 3u; comp = comp + 1u) {\n        let r0m = m_of(comp, 0u); let r1m = m_of(comp, 1u); let r2m = m_of(comp, 2u);\n        let mean = r0m * bm[0] + r1m * bm[1] + r2m * bm[2];\n        let variance = r0m * r0m * bv[0] + r1m * r1m * bv[1] + r2m * r2m * bv[2];\n        var bm_c = abs(r0m) * bbm[0] + abs(r1m) * bbm[1] + abs(r2m) * bbm[2];\n        var bv_c = r0m * r0m * bbv[0] + r1m * r1m * bbv[1] + r2m * r2m * bbv[2];\n        if (!reinhard && mean > 0.0 && mean < 1.0 && mean * mean > params.reach2 * variance && (1.0 - mean) * (1.0 - mean) > params.reach2 * variance) {\n          hm[comp] = mean; hv[comp] = variance; hs[comp] = 1.0;\n        } else if (reinhard) {\n          let moments = reinhard_moments(mean, variance);\n          hm[comp] = moments.x; hv[comp] = moments.y; hs[comp] = moments.z;\n          bm_c = bm_c + 2.0 * CLIP_MEAN_U * sqrt(variance);\n          bv_c = bv_c + 2.0 * CLIP_VARIANCE_U * variance;\n        } else {\n          // κ₃ of the component: Σ_c (M_comp,c·Γ_c)³·Σ_t w_t³·κ₃(site) (the sites of one channel share the coefficient).\n          let k0 = r0m * bs[0]; let k1 = r1m * bs[1]; let k2 = r2m * bs[2];\n          let third = k0 * k0 * k0 * cth[0] + k1 * k1 * k1 * cth[1] + k2 * k2 * k2 * cth[2];\n          let skew = select(0.0, third / (variance * sqrt(variance)), variance > 0.0);\n          let moments = unit_clip(mean, variance, skew);\n          hm[comp] = moments.x; hv[comp] = moments.y; hs[comp] = moments.z;\n          bm_c = bm_c + 2.0 * CLIP_MEAN_U * sqrt(variance);\n          bv_c = bv_c + 2.0 * CLIP_VARIANCE_U * variance;\n        }\n        hbm[comp] = bm_c; hbv[comp] = bv_c;\n      }\n      s0 = s0 + aj * hm[0]; s1 = s1 + aj * hm[1]; s2 = s2 + aj * hm[2];\n      // Linear (Stein) part with B_c·σ_c², and the pixel's own linear variance for the residual.\n      var l0 = 0.0; var l1 = 0.0; var l2 = 0.0;\n      var lb0 = 0.0; var lb1 = 0.0; var lb2 = 0.0;\n      for (var c = 0u; c < 3u; c = c + 1u) {\n        let a0 = hs[0] * m_of(0u, c) * bs[c];\n        let a1 = hs[1] * m_of(1u, c) * bs[c];\n        let a2 = hs[2] * m_of(2u, c) * bs[c];\n        var bc = b0; if (c == 1u) { bc = b1; } if (c == 2u) { bc = b2; }\n        let wgt = aj * bc * csv[c];\n        c00 = c00 + wgt * a0 * a0; c01 = c01 + wgt * a0 * a1; c02 = c02 + wgt * a0 * a2;\n        c11 = c11 + wgt * a1 * a1; c12 = c12 + wgt * a1 * a2; c22 = c22 + wgt * a2 * a2;\n        l0 = l0 + a0 * a0 * cvv[c]; l1 = l1 + a1 * a1 * cvv[c]; l2 = l2 + a2 * a2 * cvv[c];\n        // The clip bound of each channel's variance enters the covariance through a_j·B_c·(Δσ_c²/Σw²)·a_i·a_j and the\n        // residual's linear prediction through a²·Δσ_c².\n        lb0 = lb0 + (a0 * a0) * bbv[c]; lb1 = lb1 + (a1 * a1) * bbv[c]; lb2 = lb2 + (a2 * a2) * bbv[c];\n        bound_var = bound_var + aj * bc * (bbv[c] * aux[${DISPLAY_VIEW_AUX.inverseW2}u + phase * 3u + c]) * max(a0 * a0, max(a1 * a1, a2 * a2));\n      }\n      r0 = r0 + aj * aj * max(0.0, hv[0] - l0);\n      r1 = r1 + aj * aj * max(0.0, hv[1] - l1);\n      r2 = r2 + aj * aj * max(0.0, hv[2] - l2);\n      bound_mean = bound_mean + aj * max(hbm[0], max(hbm[1], hbm[2]));\n      bound_var = bound_var + aj * aj * (max(hbv[0], max(hbv[1], hbv[2])) + max(lb0, max(lb1, lb2)));\n    }\n  }\n  let o = i * ${DISPLAY_VIEW_OUTPUT_FLOATS}u;\n  out[o] = s0; out[o + 1u] = s1; out[o + 2u] = s2;\n  out[o + 3u] = c00 + r0; out[o + 4u] = c11 + r1; out[o + 5u] = c22 + r2;\n  out[o + 6u] = c01; out[o + 7u] = c02; out[o + 8u] = c12;\n  out[o + 9u] = bound_mean * E; out[o + 10u] = bound_var * E;\n  flags[i] = select(0u, 1u, material_uncertain);\n}\n`;\n\n/** The full shader: the kernel plus a material module (see `DISPLAY_VIEW_SPEED_KERNEL_WGSL`). */\nexport function assembleDisplayViewSpeedWgsl(materialModuleWgsl: string): string {\n  return DISPLAY_VIEW_SPEED_KERNEL_WGSL + \"\\n\" + materialModuleWgsl + \"\\n\";\n}\n"]}
+{"version":3,"file":"wgsl-display-view-speed-kernel.js","sourceRoot":"","sources":["../../src/gpu/wgsl-display-view-speed-kernel.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,CAAC;AAC9C,6GAA6G;AAC7G,MAAM,CAAC,MAAM,wCAAwC,GAAG,CAAC,CAAC;AAC1D,MAAM,CAAC,MAAM,4BAA4B,GAAG,wCAAwC,GAAG,CAAC,CAAC;AACzF,iGAAiG;AACjG,MAAM,CAAC,MAAM,gCAAgC,GAAG,EAAE,CAAC;AACnD,yIAAyI;AACzI,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAC7C,8DAA8D;AAC9D,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,CAAC;AAC/C,+CAA+C;AAC/C,MAAM,CAAC,MAAM,gBAAgB,GAAG,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC;IAC5D,yEAAyE;IACzE,OAAO,EAAE,CAAC;IACV,4FAA4F;IAC5F,IAAI,EAAE,EAAE;IACR,2DAA2D;IAC3D,SAAS,EAAE,GAAG;IACd,0DAA0D;IAC1D,aAAa,EAAE,GAAG;IAClB,IAAI,EAAE,GAAG;CACV,CAAC,CAAC;AACH,yEAAyE;AACzE,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,CAAC;AAC3C,qIAAqI;AACrI,MAAM,SAAS,GAAG,uBAAuB,CAAC;AAC1C;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,CAAC;AAC7C,MAAM,CAAC,MAAM,4BAA4B,GAAG,KAAK,CAAC;AAClD,8GAA8G;AAC9G,MAAM,CAAC,MAAM,4BAA4B,GAAG,GAAG,CAAC;AAChD,MAAM,CAAC,MAAM,gCAAgC,GAAG,GAAG,CAAC;AAEpD,MAAM,OAAO,GAAG,CAAC,KAAa,EAAU,EAAE;IACxC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACxC,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC;AACjD,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,UAAU,CAAC;iBACxC,SAAS;;;2BAGC,OAAO,CAAC,wBAAwB,CAAC;+BAC7B,OAAO,CAAC,4BAA4B,CAAC;sBAC9C,4BAA4B;sBAC5B,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA2GjB,gBAAgB,CAAC,aAAa;;iCAE9B,gBAAgB,CAAC,aAAa,GAAG,EAAE;;;;;;;;;;;;;;;;;;;;;;iBAsBnD,gBAAgB,CAAC,OAAO;;;;;;;;2BAQd,2BAA2B;;uCAEf,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiE7C,gBAAgB,CAAC,IAAI;;;;;;;;;;kCAUR,gBAAgB,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DA8DF,gBAAgB,CAAC,SAAS;;;;;;;;;gBASpE,0BAA0B;;;;;;;CAOzC,CAAC;AAEF,iGAAiG;AACjG,MAAM,UAAU,4BAA4B,CAAC,kBAA0B;IACrE,OAAO,8BAA8B,GAAG,IAAI,GAAG,kBAAkB,GAAG,IAAI,CAAC;AAC3E,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * WGSL kernel of the display view's Speed path on the GPU (#478): one invocation per display pixel of the exact\n * area mean (docs/DISPLAY_VIEW.md, \"Exact area mean\") without diffraction, with the bilinear demosaic and chart\n * materials. It evaluates `renderDisplayView`'s per-sample loop (facade/display-view.ts) for every real pixel of the\n * display pixel's footprint, in the reference's operation order where the order matters, in float32:\n *\n * 1. the real pixels the footprint covers and their overlap weights a_j = w_j / A (the host computes the 1-D overlaps\n *    divided by the scale in float64; the kernel multiplies the two axes);\n * 2. for every native site the real pixels' demosaic reads (the footprint plus one site of reach), the expected\n *    electrons: the scene material at the pixel aperture's query offsets (the material module, `material_at`), the\n *    material's channel signal from a table the host computed in float64 (Σ_λ A_c(λ)·L(λ)), summed over the offsets\n *    in the reference's order, plus the dark electrons;\n * 3. the readout moments of each site (mean k·e, variance k²·e + c₀, third cumulant k³·e) and the clip at the white\n *    level (the clipped-normal moments, in a cancellation-free standardized form);\n * 4. per real pixel the bilinear kernels, white balance and highlight clip, the colour matrix, the tone curve\n *    (identity, or positive Reinhard by the reference's 4 × 16-point Gauss–Legendre rule) and the clip to [0, 1] with\n *    the first-order skewness term;\n * 5. the display pixel's expected value Σ_j a_j·E[L_j], the linear (Stein) covariance Σ_c B_c·σ_c²·a_c·a_cᵀ with the\n *    closed-form B_c of the footprint, and the independent residual Σ_j a_j²·r_j.\n *\n * It outputs, per display pixel, the three means, the three variances (linear plus residual), the three covariances\n * and two running error terms: the absolute error bound of the mean and of the variance that the clip steps\n * contribute (a fixed formula evaluated from the pixel's own float32 values; docs/WEBGPU.md, \"Display view (Speed)\").\n * The host adds the output quantization term, draws the noise, encodes and rounds (`display-view-speed-gpu.ts`), so\n * the noise draw is the CPU's bit for bit.\n *\n * Precision: float32 with an a-priori bound per step from the WGSL accuracy table (+ − × within one float32 rounding in\n * either direction, E = 2^-23; division 2.5 ULP, sqrt 4.5 ULP, exp 3 + 2|x| ULP; no trigonometric built-in is used). Every quotient that is a constant of\n * the request (the overlaps over the scale, the axis sums over the squared scale, 1/Σw² of the demosaic kernels) is\n * computed on the host in float64 and uploaded. Data-dependent quotients (z = (t − m)/s, the Abramowitz–Stegun t,\n * the skewness) carry the 2.5 ULP bound.\n */\n\nexport const DISPLAY_VIEW_WORKGROUP_SIZE = 64;\n/** Largest footprint per axis (real pixels): the site window is (n + 2)² ≤ 64 entries of private storage. */\nexport const DISPLAY_VIEW_GPU_MAXIMUM_PIXELS_PER_AXIS = 6;\nexport const DISPLAY_VIEW_GPU_WINDOW_SIDE = DISPLAY_VIEW_GPU_MAXIMUM_PIXELS_PER_AXIS + 2;\n/** Largest number of query offsets (pixel-aperture nodes × filter spots) the aux table holds. */\nexport const DISPLAY_VIEW_GPU_MAXIMUM_OFFSETS = 16;\n/** Floats per display pixel in the output buffer: m0 m1 m2, v00 v11 v22 (linear + residual), c01 c02 c12, mean bound, variance bound. */\nexport const DISPLAY_VIEW_OUTPUT_FLOATS = 11;\n/** Floats per column or row record of the geometry buffer. */\nexport const DISPLAY_VIEW_GEOMETRY_STRIDE = 20;\n/** Layout of the aux table (float32 words). */\nexport const DISPLAY_VIEW_AUX = /* @__PURE__ */ Object.freeze({\n  /** Per offset o: ou (0.5 + ox − W/2), ov (0.5 + oy − H/2), weight, 0. */\n  offsets: 0,\n  /** Per phase p, channel c, tap t: dx, dy, weight, 0 (4 taps; unused taps have weight 0). */\n  taps: 64,\n  /** Per phase p, channel c: 1 / Σ_t w_t² (host float64). */\n  inverseW2: 256,\n  /** 16 Gauss–Legendre nodes then 16 weights on [−1, 1]. */\n  gaussLegendre: 272,\n  size: 304\n});\n/** Uniform parameter words (see `Params` below): 40 words, 160 bytes. */\nexport const DISPLAY_VIEW_PARAM_WORDS = 40;\n/** The `E` of the bounds: one WGSL rounding of + − × in either direction, 2^-23 (W3C WGSL \"Floating Point Accuracy\"; #471, #487). */\nconst E_LITERAL = \"1.1920928955078125e-7\";\n/**\n * Clip-step constants of the running bound, in units of E (docs/WEBGPU.md, \"Display view (Speed)\", derivation): the\n * absolute error of the clipped-normal mean in units of the standard deviation (`CLIP_MEAN_U`) and of its variance in\n * units of the variance (`CLIP_VARIANCE_U`), for one clip side. The host doubles every bound (MARGIN).\n */\nexport const DISPLAY_VIEW_CLIP_MEAN_U = 1400;\nexport const DISPLAY_VIEW_CLIP_VARIANCE_U = 36000;\n/** The additional relative error of the Reinhard quadrature, in units of E, for the mean and the variance. */\nexport const DISPLAY_VIEW_REINHARD_MEAN_U = 256;\nexport const DISPLAY_VIEW_REINHARD_VARIANCE_U = 512;\n\nconst literal = (value: number): string => {\n  const text = String(Math.fround(value));\n  return /[.e]/u.test(text) ? text : `${text}.0`;\n};\n\n/**\n * The kernel's own WGSL, without the material module. `assembleDisplayViewSpeedWgsl` appends a module that defines\n * `fn material_at(p: vec2<f32>) -> u32` and `var<private> material_uncertain: bool` (set to true when the point's\n * classification is within its bound of a material boundary; the kernel then flags the display pixel for host\n * recomputation). The module may declare bindings in @group(1) and use the constants E and SLACK declared here.\n */\nexport const DISPLAY_VIEW_SPEED_KERNEL_WGSL = /* wgsl */ `\nconst E: f32 = ${E_LITERAL};\nconst SLACK: f32 = 1e-14;\nconst CLIP_REACH: f32 = 8.5;\nconst CLIP_MEAN_U: f32 = ${literal(DISPLAY_VIEW_CLIP_MEAN_U)};\nconst CLIP_VARIANCE_U: f32 = ${literal(DISPLAY_VIEW_CLIP_VARIANCE_U)};\nconst WINDOW: u32 = ${DISPLAY_VIEW_GPU_WINDOW_SIDE}u;\nconst STRIDE: u32 = ${DISPLAY_VIEW_GEOMETRY_STRIDE}u;\nstruct Params {\n  count: u32, row0: u32, region_w: u32, region_x: u32,\n  region_y: u32, margin: u32, native_w: u32, native_h: u32,\n  columns: u32, tone: u32, offsets: u32, pad0: u32,\n  k0: f32, k1: f32, k2: f32, reach2: f32,\n  dark0: f32, dark1: f32, dark2: f32, clip_level: f32,\n  c0_0: f32, c0_1: f32, c0_2: f32, pad1: f32,\n  g0: f32, g1: f32, g2: f32, pad2: f32,\n  m00: f32, m01: f32, m02: f32, m10: f32,\n  m11: f32, m12: f32, m20: f32, m21: f32,\n  m22: f32, scale_u: f32, scale_v: f32, pad3: f32,\n};\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> aux: array<f32>;\n@group(0) @binding(2) var<storage, read> geometry: array<f32>;\n@group(0) @binding(3) var<storage, read> site_table: array<f32>;\n@group(0) @binding(4) var<storage, read_write> out: array<f32>;\n@group(0) @binding(5) var<storage, read_write> flags: array<u32>;\n\nvar<private> site_mean: array<f32, 64>;\nvar<private> site_var: array<f32, 64>;\nvar<private> site_third: array<f32, 64>;\nvar<private> site_bound: array<f32, 64>;\n\nfn k_of(c: u32) -> f32 { if (c == 0u) { return params.k0; } if (c == 1u) { return params.k1; } return params.k2; }\nfn dark_of(c: u32) -> f32 { if (c == 0u) { return params.dark0; } if (c == 1u) { return params.dark1; } return params.dark2; }\nfn c0_of(c: u32) -> f32 { if (c == 0u) { return params.c0_0; } if (c == 1u) { return params.c0_1; } return params.c0_2; }\nfn g_of(c: u32) -> f32 { if (c == 0u) { return params.g0; } if (c == 1u) { return params.g1; } return params.g2; }\nfn m_of(r: u32, c: u32) -> f32 {\n  let i = r * 3u + c;\n  switch (i) {\n    case 0u: { return params.m00; } case 1u: { return params.m01; } case 2u: { return params.m02; }\n    case 3u: { return params.m10; } case 4u: { return params.m11; } case 5u: { return params.m12; }\n    case 6u: { return params.m20; } case 7u: { return params.m21; } default: { return params.m22; }\n  }\n}\n// Standard normal density, as the reference forms it: 0.3989422804014327·exp(−0.5·z·z).\nfn phi(z: f32) -> f32 { return 0.3989422804014327 * exp(-0.5 * z * z); }\n// Abramowitz & Stegun 26.2.17: returns (Φ(z), 1 − Φ(z)), each formed from the tail q directly where it is small.\nfn pq(z: f32) -> vec2<f32> {\n  let x = abs(z);\n  let t = 1.0 / (1.0 + 0.2316419 * x);\n  let q = phi(x) * t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));\n  if (z >= 0.0) { return vec2<f32>(1.0 - q, q); }\n  return vec2<f32>(q, 1.0 - q);\n}\n// Moments of min(Y, top) for Y ~ N(m, v): (mean, variance, slope P). The variance is v·(P − zφ + z²Q − δ²) with\n// δ = φ − zQ: algebraically E[min²] − E[min]² without the m² cancellation.\nfn upper_clip(m: f32, v: f32, top: f32) -> vec3<f32> {\n  if (!(v > 0.0)) { return vec3<f32>(min(m, top), 0.0, select(0.0, 1.0, m < top)); }\n  let s = sqrt(v);\n  let z = (top - m) / s;\n  if (z > CLIP_REACH) { return vec3<f32>(m, v, 1.0); }\n  if (z < -CLIP_REACH) { return vec3<f32>(top, 0.0, 0.0); }\n  let p = pq(z);\n  let d = phi(z);\n  let delta = d - z * p.y;\n  let mean = m - s * delta;\n  let ratio = p.x - z * d + z * z * p.y - delta * delta;\n  return vec3<f32>(mean, v * max(0.0, ratio), p.x);\n}\n// Moments of clip(Y, 0, 1) for Y with mean m, variance v and standardized skewness γ (|γ| ≤ 1): (mean, variance, inside).\n// With Z standard normal, W = m + s·g(Z), g = clip(Z, a, b): E[g] = aΦa + φa − φb + bQb, E[g²] = a²Φa + (Φb − Φa) −\n// (bφb − aφa) + b²Qb; the mean adds the reference's Edgeworth term (s·γ/6)·(aφa − bφb).\nfn unit_clip(m: f32, v: f32, skewness: f32) -> vec3<f32> {\n  if (!(v > 0.0)) { return vec3<f32>(clamp(m, 0.0, 1.0), 0.0, select(0.0, 1.0, m > 0.0 && m < 1.0)); }\n  let s = sqrt(v);\n  let a = -m / s;\n  let b = (1.0 - m) / s;\n  if (a < -CLIP_REACH && b > CLIP_REACH) { return vec3<f32>(m, v, 1.0); }\n  var pa = 0.0; var da = 0.0;\n  if (!(a < -CLIP_REACH)) { pa = pq(a).x; da = phi(a); }\n  var pb = 1.0; var qb = 0.0; var db = 0.0;\n  if (!(b > CLIP_REACH)) { let p = pq(b); pb = p.x; qb = p.y; db = phi(b); }\n  let inside = pb - pa;\n  let gamma = clamp(skewness, -1.0, 1.0);\n  let aa = a * da;\n  let bb = b * db;\n  let eg = a * pa + (da - db) + b * qb;\n  let eg2 = a * a * pa + inside - (bb - aa) + b * b * qb;\n  let normal_mean = m + s * eg;\n  var mean = normal_mean;\n  var skew_shift = 0.0;\n  if (gamma != 0.0) { skew_shift = s * gamma / 6.0 * (aa - bb); mean = normal_mean + skew_shift; }\n  // The reference forms E[Y²] − (E[Y] + shift)², so the shift also enters its variance: −shift·(2·E[Y] + shift).\n  return vec3<f32>(mean, max(0.0, v * (eg2 - eg * eg) - skew_shift * (2.0 * normal_mean + skew_shift)), inside);\n}\n// Positive Reinhard per channel then the clip to [0, 1]: h(x) = x/(1 + x) for x > 0, else 0. Composite 16-point\n// Gauss–Legendre over [max(0, m − 8.5s), m + 8.5s] in 4 panels, as the reference; the variance is formed about h(m).\nfn reinhard_moments(m: f32, v: f32) -> vec3<f32> {\n  if (!(v > 0.0)) {\n    if (m > 0.0) { return vec3<f32>(m / (1.0 + m), 0.0, 1.0 / ((1.0 + m) * (1.0 + m))); }\n    return vec3<f32>(0.0, 0.0, 0.0);\n  }\n  let s = sqrt(v);\n  // The reference's panels [max(0, m − 8.5s), m + 8.5s] in standardized units z = (x − m)/s, so the node's z is formed\n  // without the cancellation x − m: zlo = max(−m/s, −8.5), weight = zhalf·w_k·φ(z_k) (= half·w_k·φ((x − m)/s)/s), x = m + s·z.\n  let zlo = max(-m / s, -CLIP_REACH);\n  if (!(CLIP_REACH > zlo)) { return vec3<f32>(0.0, 0.0, 0.0); }\n  let hm = select(0.0, m / (1.0 + m), m > 0.0);\n  var e1 = 0.0; var e2 = 0.0; var ed = 0.0;\n  let zwidth = (CLIP_REACH - zlo) / 4.0;\n  for (var p = 0u; p < 4u; p = p + 1u) {\n    let zc = zlo + (f32(p) + 0.5) * zwidth;\n    let zhalf = zwidth / 2.0;\n    for (var k = 0u; k < 16u; k = k + 1u) {\n      let z = zc + zhalf * aux[${DISPLAY_VIEW_AUX.gaussLegendre}u + k];\n      let x = m + s * z;\n      let weight = zhalf * aux[${DISPLAY_VIEW_AUX.gaussLegendre + 16}u + k] * phi(z);\n      let h = x / (1.0 + x);\n      e1 = e1 + weight * h;\n      e2 = e2 + weight * (h - hm) * (h - hm);\n      ed = ed + weight / ((1.0 + x) * (1.0 + x));\n    }\n  }\n  let shifted = e1 - hm;\n  return vec3<f32>(e1, max(0.0, e2 - shifted * shifted), ed);\n}\nfn reflect_x(x: i32) -> i32 { if (x < 0) { return -x; } if (x >= i32(params.native_w)) { return 2 * i32(params.native_w) - 2 - x; } return x; }\nfn reflect_y(y: i32) -> i32 { if (y < 0) { return -y; } if (y >= i32(params.native_h)) { return 2 * i32(params.native_h) - 2 - y; } return y; }\nfn channel_of(x: i32, y: i32) -> u32 {\n  if ((y & 1) == 0) { return select(1u, 0u, (x & 1) == 0); }\n  return select(2u, 1u, (x & 1) == 0);\n}\n// The expected photo electrons of native site (x, y): Σ_o w_o·table[m_o, c] in offset order (directSite).\nfn site_electrons(x: i32, y: i32, c: u32) -> f32 {\n  var sum = 0.0;\n  let fx = f32(x);\n  let fy = f32(y);\n  for (var o = 0u; o < params.offsets; o = o + 1u) {\n    let base = ${DISPLAY_VIEW_AUX.offsets}u + 4u * o;\n    let u = (fx + aux[base]) * params.scale_u;\n    let v = (fy + aux[base + 1u]) * params.scale_v;\n    let m = material_at(vec2<f32>(u, v));\n    sum = sum + aux[base + 2u] * site_table[m * 3u + c];\n  }\n  return sum;\n}\n@compute @workgroup_size(${DISPLAY_VIEW_WORKGROUP_SIZE})\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) groups: vec3<u32>) {\n  let i = gid.x + gid.y * groups.x * ${DISPLAY_VIEW_WORKGROUP_SIZE}u;\n  if (i >= params.count) { return; }\n  material_uncertain = false;\n  let rx = i % params.region_w;\n  let ry = params.row0 + i / params.region_w;\n  let col = rx * STRIDE;\n  let row = (params.columns + ry) * STRIDE;\n  let col_first = bitcast<i32>(geometry[col]);\n  let nx = bitcast<u32>(geometry[col + 1u]);\n  let row_first = bitcast<i32>(geometry[row]);\n  let ny = bitcast<u32>(geometry[row + 1u]);\n  let margin = i32(params.margin);\n  // 2. and 3.: the sites of the footprint plus one site of reach, once each.\n  let x0 = col_first + margin - 1;\n  let y0 = row_first + margin - 1;\n  let window_w = nx + 2u;\n  for (var sj = 0u; sj < ny + 2u; sj = sj + 1u) {\n    let sy = reflect_y(y0 + i32(sj));\n    for (var si = 0u; si < window_w; si = si + 1u) {\n      let sx = reflect_x(x0 + i32(si));\n      let c = channel_of(sx, sy);\n      let e = site_electrons(sx, sy, c) + dark_of(c);\n      let kc = k_of(c);\n      let mean = kc * e;\n      let variance = kc * kc * e + c0_of(c);\n      let gap = 1.0 - mean;\n      let slot = sj * window_w + si;\n      site_third[slot] = kc * kc * kc * e;\n      if (gap > 0.0 && gap * gap > params.reach2 * variance) {\n        site_mean[slot] = mean; site_var[slot] = variance; site_bound[slot] = 0.0;\n      } else {\n        let clipped = upper_clip(mean, variance, 1.0);\n        site_mean[slot] = clipped.x; site_var[slot] = clipped.y; site_bound[slot] = sqrt(variance);\n      }\n    }\n  }\n  // B_c of the footprint from the host's axis sums (each over its scale squared): red, green, blue.\n  let xb_even = geometry[col + 8u]; let xb_odd = geometry[col + 9u];\n  let xpp_even = geometry[col + 10u]; let xpp_odd = geometry[col + 11u];\n  let xqq_even = geometry[col + 12u]; let xqq_odd = geometry[col + 13u];\n  let xpq_even = geometry[col + 14u]; let xpq_odd = geometry[col + 15u];\n  let yb_even = geometry[row + 8u]; let yb_odd = geometry[row + 9u];\n  let ypp_even = geometry[row + 10u]; let ypp_odd = geometry[row + 11u];\n  let yqq_even = geometry[row + 12u]; let yqq_odd = geometry[row + 13u];\n  let ypq_even = geometry[row + 14u]; let ypq_odd = geometry[row + 15u];\n  let b0 = xb_even * yb_even;\n  let b1 = (xpp_odd * ypp_even + xqq_odd * ypp_even + xpp_odd * yqq_even + 2.0 * xpq_odd * ypp_even + 2.0 * xpp_odd * ypq_even + 2.0 * xpq_odd * ypq_even) +\n    (xpp_even * ypp_odd + xqq_even * ypp_odd + xpp_even * yqq_odd + 2.0 * xpq_even * ypp_odd + 2.0 * xpp_even * ypq_odd + 2.0 * xpq_even * ypq_odd);\n  let b2 = xb_odd * yb_odd;\n  let reinhard = params.tone == 1u;\n  var s0 = 0.0; var s1 = 0.0; var s2 = 0.0;\n  var c00 = 0.0; var c01 = 0.0; var c02 = 0.0; var c11 = 0.0; var c12 = 0.0; var c22 = 0.0;\n  var r0 = 0.0; var r1 = 0.0; var r2 = 0.0;\n  var bound_mean = 0.0; var bound_var = 0.0;\n  // 4. and 5.: every real pixel of the footprint with its overlap weight.\n  for (var j = 0u; j < ny; j = j + 1u) {\n    let ay = geometry[row + 2u + j];\n    for (var ii = 0u; ii < nx; ii = ii + 1u) {\n      let aj = geometry[col + 2u + ii] * ay;\n      let x = col_first + i32(ii) + margin;\n      let y = row_first + i32(j) + margin;\n      let phase = u32(y & 1) * 2u + u32(x & 1);\n      var cm: array<f32, 3>; var cvv: array<f32, 3>; var cth: array<f32, 3>; var csv: array<f32, 3>; var cb: array<f32, 3>;\n      for (var c = 0u; c < 3u; c = c + 1u) {\n        var mean = 0.0; var variance = 0.0; var third = 0.0; var bnd = 0.0;\n        let taps = ${DISPLAY_VIEW_AUX.taps}u + (phase * 3u + c) * 16u;\n        for (var t = 0u; t < 4u; t = t + 1u) {\n          let w = aux[taps + 4u * t + 2u];\n          let slot = u32((i32(j) + 1 + i32(aux[taps + 4u * t + 1u])) * i32(window_w) + i32(ii) + 1 + i32(aux[taps + 4u * t]));\n          mean = mean + w * site_mean[slot];\n          variance = variance + w * w * site_var[slot];\n          third = third + w * w * w * site_third[slot];\n          bnd = max(bnd, select(0.0, site_bound[slot], w != 0.0));\n        }\n        cm[c] = mean; cvv[c] = variance; cth[c] = third; cb[c] = bnd;\n        csv[c] = variance * aux[${DISPLAY_VIEW_AUX.inverseW2}u + phase * 3u + c];\n      }\n      // White balance and the highlight clip at the smallest gain: bm, bv, bs (slope), with the clip's bound terms.\n      var bm: array<f32, 3>; var bv: array<f32, 3>; var bs: array<f32, 3>; var bbm: array<f32, 3>; var bbv: array<f32, 3>;\n      for (var c = 0u; c < 3u; c = c + 1u) {\n        let gc = g_of(c);\n        let um = gc * cm[c];\n        let uv = gc * gc * cvv[c];\n        let gap = params.clip_level - um;\n        bbm[c] = gc * CLIP_MEAN_U * cb[c];\n        bbv[c] = gc * gc * CLIP_VARIANCE_U * cb[c] * cb[c];\n        if (gap > 0.0 && gap * gap > params.reach2 * uv) { bm[c] = um; bv[c] = uv; bs[c] = gc; }\n        else {\n          let clipped = upper_clip(um, uv, params.clip_level);\n          bm[c] = clipped.x; bv[c] = clipped.y; bs[c] = gc * clipped.z;\n          bbm[c] = bbm[c] + CLIP_MEAN_U * sqrt(uv);\n          bbv[c] = bbv[c] + CLIP_VARIANCE_U * uv;\n        }\n      }\n      // Colour matrix, then the rendering of each component (tone curve, clip to [0, 1]).\n      var hm: array<f32, 3>; var hv: array<f32, 3>; var hs: array<f32, 3>; var hbm: array<f32, 3>; var hbv: array<f32, 3>;\n      for (var comp = 0u; comp < 3u; comp = comp + 1u) {\n        let r0m = m_of(comp, 0u); let r1m = m_of(comp, 1u); let r2m = m_of(comp, 2u);\n        let mean = r0m * bm[0] + r1m * bm[1] + r2m * bm[2];\n        let variance = r0m * r0m * bv[0] + r1m * r1m * bv[1] + r2m * r2m * bv[2];\n        var bm_c = abs(r0m) * bbm[0] + abs(r1m) * bbm[1] + abs(r2m) * bbm[2];\n        var bv_c = r0m * r0m * bbv[0] + r1m * r1m * bbv[1] + r2m * r2m * bbv[2];\n        if (!reinhard && mean > 0.0 && mean < 1.0 && mean * mean > params.reach2 * variance && (1.0 - mean) * (1.0 - mean) > params.reach2 * variance) {\n          hm[comp] = mean; hv[comp] = variance; hs[comp] = 1.0;\n        } else if (reinhard) {\n          let moments = reinhard_moments(mean, variance);\n          hm[comp] = moments.x; hv[comp] = moments.y; hs[comp] = moments.z;\n          bm_c = bm_c + 2.0 * CLIP_MEAN_U * sqrt(variance);\n          bv_c = bv_c + 2.0 * CLIP_VARIANCE_U * variance;\n        } else {\n          // κ₃ of the component: Σ_c (M_comp,c·Γ_c)³·Σ_t w_t³·κ₃(site) (the sites of one channel share the coefficient).\n          let k0 = r0m * bs[0]; let k1 = r1m * bs[1]; let k2 = r2m * bs[2];\n          let third = k0 * k0 * k0 * cth[0] + k1 * k1 * k1 * cth[1] + k2 * k2 * k2 * cth[2];\n          let skew = select(0.0, third / (variance * sqrt(variance)), variance > 0.0);\n          let moments = unit_clip(mean, variance, skew);\n          hm[comp] = moments.x; hv[comp] = moments.y; hs[comp] = moments.z;\n          bm_c = bm_c + 2.0 * CLIP_MEAN_U * sqrt(variance);\n          bv_c = bv_c + 2.0 * CLIP_VARIANCE_U * variance;\n        }\n        hbm[comp] = bm_c; hbv[comp] = bv_c;\n      }\n      s0 = s0 + aj * hm[0]; s1 = s1 + aj * hm[1]; s2 = s2 + aj * hm[2];\n      // Linear (Stein) part with B_c·σ_c², and the pixel's own linear variance for the residual.\n      var l0 = 0.0; var l1 = 0.0; var l2 = 0.0;\n      var lb0 = 0.0; var lb1 = 0.0; var lb2 = 0.0;\n      for (var c = 0u; c < 3u; c = c + 1u) {\n        let a0 = hs[0] * m_of(0u, c) * bs[c];\n        let a1 = hs[1] * m_of(1u, c) * bs[c];\n        let a2 = hs[2] * m_of(2u, c) * bs[c];\n        var bc = b0; if (c == 1u) { bc = b1; } if (c == 2u) { bc = b2; }\n        let wgt = aj * bc * csv[c];\n        c00 = c00 + wgt * a0 * a0; c01 = c01 + wgt * a0 * a1; c02 = c02 + wgt * a0 * a2;\n        c11 = c11 + wgt * a1 * a1; c12 = c12 + wgt * a1 * a2; c22 = c22 + wgt * a2 * a2;\n        l0 = l0 + a0 * a0 * cvv[c]; l1 = l1 + a1 * a1 * cvv[c]; l2 = l2 + a2 * a2 * cvv[c];\n        // The clip bound of each channel's variance enters the covariance through a_j·B_c·(Δσ_c²/Σw²)·a_i·a_j and the\n        // residual's linear prediction through a²·Δσ_c².\n        lb0 = lb0 + (a0 * a0) * bbv[c]; lb1 = lb1 + (a1 * a1) * bbv[c]; lb2 = lb2 + (a2 * a2) * bbv[c];\n        bound_var = bound_var + aj * bc * (bbv[c] * aux[${DISPLAY_VIEW_AUX.inverseW2}u + phase * 3u + c]) * max(a0 * a0, max(a1 * a1, a2 * a2));\n      }\n      r0 = r0 + aj * aj * max(0.0, hv[0] - l0);\n      r1 = r1 + aj * aj * max(0.0, hv[1] - l1);\n      r2 = r2 + aj * aj * max(0.0, hv[2] - l2);\n      bound_mean = bound_mean + aj * max(hbm[0], max(hbm[1], hbm[2]));\n      bound_var = bound_var + aj * aj * (max(hbv[0], max(hbv[1], hbv[2])) + max(lb0, max(lb1, lb2)));\n    }\n  }\n  let o = i * ${DISPLAY_VIEW_OUTPUT_FLOATS}u;\n  out[o] = s0; out[o + 1u] = s1; out[o + 2u] = s2;\n  out[o + 3u] = c00 + r0; out[o + 4u] = c11 + r1; out[o + 5u] = c22 + r2;\n  out[o + 6u] = c01; out[o + 7u] = c02; out[o + 8u] = c12;\n  out[o + 9u] = bound_mean * E; out[o + 10u] = bound_var * E;\n  flags[i] = select(0u, 1u, material_uncertain);\n}\n`;\n\n/** The full shader: the kernel plus a material module (see `DISPLAY_VIEW_SPEED_KERNEL_WGSL`). */\nexport function assembleDisplayViewSpeedWgsl(materialModuleWgsl: string): string {\n  return DISPLAY_VIEW_SPEED_KERNEL_WGSL + \"\\n\" + materialModuleWgsl + \"\\n\";\n}\n"]}