@photivra/engine 2.9.0 → 2.11.1

package/dist/gpu/wgsl-chart-kernel.d.ts

@@ -5,15 +5,17 @@
  *
  * Every classification decision (half-plane, disk, sector, cell and gap boundaries) is evaluated with an
  * a-priori bound on how far the float32 decision value can be from the float64 reference value: the
- * point's float32 rounding, each float32 operation (u = 2^-24, correctly rounded + − ×), the float32
- * rounding of the constants and the reference's own float64 rounding. A point whose decision value lies
- * within four times its bound is flagged, and the host recomputes it with the reference. So every
- * unflagged point has exactly the reference's material, and its value is the reference value rounded
- * once to float32.
+ * point's float32 rounding, each float32 operation (E = 2^-23: one WGSL rounding of + − ×, in either
+ * direction, W3C WGSL "Floating Point Accuracy"), the float32 rounding of the constants and the
+ * reference's own float64 rounding. A point whose decision value lies within four times its bound is
+ * flagged, and the host recomputes it with the reference. So every unflagged point has exactly the
+ * reference's material, and its value is the reference value rounded once to float32.
  *
- * Siemens-star sectors are found from a rough `atan2` (any accuracy) and then decided exactly by the
- * signs of cross products with the sector boundary directions, so WGSL's 4096-ULP `atan2` bound does not
- * enter. See docs/WEBGPU.md, "Scene radiance on the GPU".
+ * Siemens-star sectors are decided only by the signs of cross products with the sector boundary
+ * directions (host float64 cos/sin, rounded once to float32): the sign of v chooses the half-plane, a
+ * binary search over that half-plane's boundaries finds the sector, and the two enclosing cross products
+ * carry the bound. The kernel calls no transcendental function, so neither the WGSL `atan2` bound nor the
+ * realm's float64 `Math.atan2` enters. See docs/WEBGPU.md, "Scene radiance on the GPU".
  */
 export declare const CHART_WORKGROUP_SIZE = 256;
 /** Preset codes of `Params.preset`, in `CHART_SCENE_PRESETS` order. */
@@ -27,4 +29,4 @@ export declare const CHART_PRESET_CODE: Readonly<{
     readonly "point-grid": 6;
     readonly patches: 7;
 }>;
-export declare const CHART_RADIANCE_WGSL = "\nconst U: f32 = 5.9604644775390625e-8;\nconst SAFETY: f32 = 4.0;\nconst SLACK: f32 = 1e-14;\nconst PI: f32 = 3.14159265358979;\nstruct Params {\n  count: u32, columns: u32, preset: u32, na: u32,\n  nb: u32, nc: u32, wavelength_mode: u32, pad0: u32,\n  f0: f32, f1: f32, f2: f32, f3: f32,\n  f4: f32, f5: f32, f6: f32, f7: f32,\n};\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> points: array<vec2<f32>>;\n@group(0) @binding(2) var<storage, read> table: array<f32>;\n@group(0) @binding(3) var<storage, read> aux: array<f32>;\n@group(0) @binding(4) var<storage, read> selectors: array<u32>;\n@group(0) @binding(5) var<storage, read_write> values: array<f32>;\n@group(0) @binding(6) var<storage, read_write> flags: array<u32>;\n\nvar<private> flagged: bool;\nfn check(distance: f32, bound: f32) { if (!(abs(distance) > SAFETY * bound)) { flagged = true; } }\n// Flags t when it lies within the bound of an integer n with lo <= n <= hi.\nfn check_integer(t: f32, bound: f32, lo: f32, hi: f32) {\n  let n = round(t);\n  if (SAFETY * bound >= 0.5) { flagged = true; return; }\n  if (n >= lo && n <= hi) { check(t - n, bound); }\n}\n// x = (a + b) * scale, with the bound of its distance from the float64 reference value.\nfn scaled_sum_bound(a: f32, b: f32, s: f32, scale: f32, x: f32, constant_rounding: f32) -> f32 {\n  return U * ((abs(a) + abs(b) + abs(s)) * abs(scale) + (1.0 + constant_rounding) * abs(x)) + SLACK * (abs(x) + 1.0);\n}\nfn cross_d(u: f32, v: f32, k: u32) -> f32 { return v * aux[2u * k] - u * aux[2u * k + 1u]; }\nfn cross_bound(u: f32, v: f32, k: u32, d: f32) -> f32 {\n  return U * (3.0 * abs(v * aux[2u * k]) + 3.0 * abs(u * aux[2u * k + 1u]) + abs(d)) + SLACK * (abs(u) + abs(v));\n}\nfn material(p: vec2<f32>) -> u32 {\n  let u = p.x;\n  let v = p.y;\n  switch (params.preset) {\n    case 0u: { return 0u; }\n    case 1u: {\n      // Light where u\u00B7cos t \u2212 v\u00B7sin t \u2265 0.\n      let a = u * params.f0;\n      let b = v * params.f1;\n      let d = a - b;\n      check(d, U * (3.0 * abs(a) + 3.0 * abs(b) + abs(d)) + SLACK * (abs(u) + abs(v)));\n      return select(0u, 1u, d >= 0.0);\n    }\n    case 2u: {\n      let uu = u * u;\n      let vv = v * v;\n      let q = uu + vv;\n      check(q - params.f0, U * (4.0 * q + 2.0 * params.f0) + SLACK * (q + params.f0));\n      if (q > params.f0) { return 2u; }\n      let sectors = 2u * params.na;\n      var k = u32(clamp(floor((atan2(v, u) + PI) * f32(params.na) / PI), 0.0, f32(sectors - 1u)));\n      for (var step = 0u; step < 4u; step++) {\n        if (cross_d(u, v, k) < 0.0 && k > 0u) { k = k - 1u; continue; }\n        if (cross_d(u, v, k + 1u) >= 0.0 && k + 1u < sectors) { k = k + 1u; continue; }\n        break;\n      }\n      let lo = cross_d(u, v, k);\n      let hi = cross_d(u, v, k + 1u);\n      if (lo < 0.0 || hi >= 0.0) { flagged = true; }\n      check(lo, cross_bound(u, v, k, lo));\n      check(hi, cross_bound(u, v, k + 1u, hi));\n      return select(0u, 1u, k % 2u == 0u);\n    }\n    case 3u, 4u: {\n      let s = u + 1.0;\n      let t = s * params.f0;\n      check_integer(t, scaled_sum_bound(u, 1.0, s, params.f0, t, 0.0), 1.0, f32(params.na - 1u));\n      return u32(clamp(floor(t), 0.0, f32(params.na - 1u)));\n    }\n    case 5u: {\n      let s = u + 1.0;\n      let x = s * params.f0;\n      let w = params.f1 - v;\n      let y = w * params.f0;\n      check_integer(x, scaled_sum_bound(u, 1.0, s, params.f0, x, 0.0), -3.0e38, 3.0e38);\n      check_integer(y, scaled_sum_bound(params.f1, v, w, params.f0, y, 0.0), -3.0e38, 3.0e38);\n      let i = i32(floor(x));\n      let j = i32(floor(y));\n      return select(0u, 1u, (i + j) % 2 == 0);\n    }\n    case 6u: {\n      let s = u + 1.0;\n      let x = s * params.f0;\n      let w = params.f1 - v;\n      let y = w * params.f2;\n      check_integer(x, scaled_sum_bound(u, 1.0, s, params.f0, x, 0.0), 1.0, f32(params.na - 1u));\n      check_integer(y, scaled_sum_bound(params.f1, v, w, params.f2, y, 1.0), 1.0, f32(params.nb - 1u));\n      let i = u32(clamp(floor(x), 0.0, f32(params.na - 1u)));\n      let j = u32(clamp(floor(y), 0.0, f32(params.nb - 1u)));\n      let c = j * params.na + i;\n      let dx = u - aux[2u * c];\n      let dy = v - aux[2u * c + 1u];\n      let ex = U * (abs(u) + abs(aux[2u * c]) + abs(dx));\n      let ey = U * (abs(v) + abs(aux[2u * c + 1u]) + abs(dy));\n      let d2 = dx * dx + dy * dy;\n      check(d2 - params.f3, 2.0 * (abs(dx) * ex + abs(dy) * ey) + ex * ex + ey * ey + U * (2.0 * d2 + params.f3) + SLACK * (d2 + params.f3));\n      return select(0u, 1u, d2 <= params.f3);\n    }\n    default: {\n      let s = u + 1.0;\n      let fx = s * params.f0;\n      let w = params.f1 - v;\n      let fy = w * params.f2;\n      let bx = scaled_sum_bound(u, 1.0, s, params.f0, fx, 0.0);\n      let by = scaled_sum_bound(params.f1, v, w, params.f2, fy, 1.0);\n      check_integer(fx, bx, -3.0e38, 3.0e38);\n      check_integer(fy, by, -3.0e38, 3.0e38);\n      let background = params.nc;\n      let ifx = floor(fx);\n      let ify = floor(fy);\n      if (ifx < 0.0 || ify < 0.0 || ifx >= f32(params.na) || ify >= f32(params.nb)) { return background; }\n      let index = u32(ify) * params.na + u32(ifx);\n      let x = fx - ifx;\n      let y = fy - ify;\n      check(x - params.f3, bx + U * params.f3);\n      check(x - params.f4, bx + U * params.f4);\n      check(y - params.f3, by + U * params.f3);\n      check(y - params.f4, by + U * params.f4);\n      if (index >= params.nc || x < params.f3 || x > params.f4 || y < params.f3 || y > params.f4) { return background; }\n      return index;\n    }\n  }\n}\n@compute @workgroup_size(256)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) groups: vec3<u32>) {\n  let i = gid.x + gid.y * groups.x * 256u;\n  if (i >= params.count) { return; }\n  flagged = false;\n  let m = material(points[i]);\n  if (params.wavelength_mode != 0u) {\n    values[i] = table[m * params.columns + selectors[i]];\n  } else {\n    for (var c = 0u; c < params.columns; c++) { values[i * params.columns + c] = table[m * params.columns + c]; }\n  }\n  flags[i] = select(0u, 1u, flagged);\n}\n";
+export declare const CHART_RADIANCE_WGSL = "\nconst E: f32 = 1.1920928955078125e-7;\nconst SAFETY: f32 = 4.0;\nconst SLACK: f32 = 1e-14;\nstruct Params {\n  count: u32, columns: u32, preset: u32, na: u32,\n  nb: u32, nc: u32, wavelength_mode: u32, pad0: u32,\n  f0: f32, f1: f32, f2: f32, f3: f32,\n  f4: f32, f5: f32, f6: f32, f7: f32,\n};\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> points: array<vec2<f32>>;\n@group(0) @binding(2) var<storage, read> table: array<f32>;\n@group(0) @binding(3) var<storage, read> aux: array<f32>;\n@group(0) @binding(4) var<storage, read> selectors: array<u32>;\n@group(0) @binding(5) var<storage, read_write> values: array<f32>;\n@group(0) @binding(6) var<storage, read_write> flags: array<u32>;\n\nvar<private> flagged: bool;\nfn check(distance: f32, bound: f32) { if (!(abs(distance) > SAFETY * bound)) { flagged = true; } }\n// Flags t when it lies within the bound of an integer n with lo <= n <= hi.\nfn check_integer(t: f32, bound: f32, lo: f32, hi: f32) {\n  let n = round(t);\n  if (SAFETY * bound >= 0.5) { flagged = true; return; }\n  if (n >= lo && n <= hi) { check(t - n, bound); }\n}\n// x = (a + b) * scale, with the bound of its distance from the float64 reference value.\nfn scaled_sum_bound(a: f32, b: f32, s: f32, scale: f32, x: f32, constant_rounding: f32) -> f32 {\n  return E * ((abs(a) + abs(b) + abs(s)) * abs(scale) + (1.0 + constant_rounding) * abs(x)) + SLACK * (abs(x) + 1.0);\n}\nfn cross_d(u: f32, v: f32, k: u32) -> f32 { return v * aux[2u * k] - u * aux[2u * k + 1u]; }\nfn cross_bound(u: f32, v: f32, k: u32, d: f32) -> f32 {\n  return E * (3.0 * abs(v * aux[2u * k]) + 3.0 * abs(u * aux[2u * k + 1u]) + abs(d)) + SLACK * (abs(u) + abs(v));\n}\nfn material(p: vec2<f32>) -> u32 {\n  let u = p.x;\n  let v = p.y;\n  switch (params.preset) {\n    case 0u: { return 0u; }\n    case 1u: {\n      // Light where u\u00B7cos t \u2212 v\u00B7sin t \u2265 0.\n      let a = u * params.f0;\n      let b = v * params.f1;\n      let d = a - b;\n      check(d, E * (3.0 * abs(a) + 3.0 * abs(b) + abs(d)) + SLACK * (abs(u) + abs(v)));\n      return select(0u, 1u, d >= 0.0);\n    }\n    case 2u: {\n      let uu = u * u;\n      let vv = v * v;\n      let q = uu + vv;\n      check(q - params.f0, E * (4.0 * q + 2.0 * params.f0) + SLACK * (q + params.f0));\n      if (q > params.f0) { return 2u; }\n      // Boundaries b_k = \u03C0(k/cycles \u2212 1), k = 0 \u2026 2\u00B7cycles. In the half-plane v \u2265 0 the angle lies in [0, \u03C0],\n      // between b_cycles and b_2cycles; for v < 0 in [\u2212\u03C0, 0), between b_0 and b_cycles. Within one half-plane,\n      // sign(cross(k)) = sign(\u03B8 \u2212 b_k), so a binary search on the cross-product signs finds the sector. A point\n      // within the bound of a boundary (the u-axis and the \u00B1\u03C0 cut included) is caught by the two final checks.\n      var low = select(0u, params.na, v >= 0.0);\n      var high = low + params.na;\n      loop {\n        if (high - low <= 1u) { break; }\n        let middle = (low + high) >> 1u;\n        if (cross_d(u, v, middle) >= 0.0) { low = middle; } else { high = middle; }\n      }\n      let k = low;\n      let lo = cross_d(u, v, k);\n      let hi = cross_d(u, v, k + 1u);\n      if (lo < 0.0 || hi >= 0.0) { flagged = true; }\n      check(lo, cross_bound(u, v, k, lo));\n      check(hi, cross_bound(u, v, k + 1u, hi));\n      return select(0u, 1u, k % 2u == 0u);\n    }\n    case 3u, 4u: {\n      let s = u + 1.0;\n      let t = s * params.f0;\n      check_integer(t, scaled_sum_bound(u, 1.0, s, params.f0, t, 0.0), 1.0, f32(params.na - 1u));\n      return u32(clamp(floor(t), 0.0, f32(params.na - 1u)));\n    }\n    case 5u: {\n      let s = u + 1.0;\n      let x = s * params.f0;\n      let w = params.f1 - v;\n      let y = w * params.f0;\n      check_integer(x, scaled_sum_bound(u, 1.0, s, params.f0, x, 0.0), -3.0e38, 3.0e38);\n      check_integer(y, scaled_sum_bound(params.f1, v, w, params.f0, y, 0.0), -3.0e38, 3.0e38);\n      let i = i32(floor(x));\n      let j = i32(floor(y));\n      return select(0u, 1u, (i + j) % 2 == 0);\n    }\n    case 6u: {\n      let s = u + 1.0;\n      let x = s * params.f0;\n      let w = params.f1 - v;\n      let y = w * params.f2;\n      check_integer(x, scaled_sum_bound(u, 1.0, s, params.f0, x, 0.0), 1.0, f32(params.na - 1u));\n      check_integer(y, scaled_sum_bound(params.f1, v, w, params.f2, y, 1.0), 1.0, f32(params.nb - 1u));\n      let i = u32(clamp(floor(x), 0.0, f32(params.na - 1u)));\n      let j = u32(clamp(floor(y), 0.0, f32(params.nb - 1u)));\n      let c = j * params.na + i;\n      let dx = u - aux[2u * c];\n      let dy = v - aux[2u * c + 1u];\n      let ex = E * (abs(u) + abs(aux[2u * c]) + abs(dx));\n      let ey = E * (abs(v) + abs(aux[2u * c + 1u]) + abs(dy));\n      let d2 = dx * dx + dy * dy;\n      check(d2 - params.f3, 2.0 * (abs(dx) * ex + abs(dy) * ey) + ex * ex + ey * ey + E * (2.0 * d2 + params.f3) + SLACK * (d2 + params.f3));\n      return select(0u, 1u, d2 <= params.f3);\n    }\n    default: {\n      let s = u + 1.0;\n      let fx = s * params.f0;\n      let w = params.f1 - v;\n      let fy = w * params.f2;\n      let bx = scaled_sum_bound(u, 1.0, s, params.f0, fx, 0.0);\n      let by = scaled_sum_bound(params.f1, v, w, params.f2, fy, 1.0);\n      check_integer(fx, bx, -3.0e38, 3.0e38);\n      check_integer(fy, by, -3.0e38, 3.0e38);\n      let background = params.nc;\n      let ifx = floor(fx);\n      let ify = floor(fy);\n      if (ifx < 0.0 || ify < 0.0 || ifx >= f32(params.na) || ify >= f32(params.nb)) { return background; }\n      let index = u32(ify) * params.na + u32(ifx);\n      let x = fx - ifx;\n      let y = fy - ify;\n      check(x - params.f3, bx + E * params.f3);\n      check(x - params.f4, bx + E * params.f4);\n      check(y - params.f3, by + E * params.f3);\n      check(y - params.f4, by + E * params.f4);\n      if (index >= params.nc || x < params.f3 || x > params.f4 || y < params.f3 || y > params.f4) { return background; }\n      return index;\n    }\n  }\n}\n@compute @workgroup_size(256)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) groups: vec3<u32>) {\n  let i = gid.x + gid.y * groups.x * 256u;\n  if (i >= params.count) { return; }\n  flagged = false;\n  let m = material(points[i]);\n  if (params.wavelength_mode != 0u) {\n    values[i] = table[m * params.columns + selectors[i]];\n  } else {\n    for (var c = 0u; c < params.columns; c++) { values[i * params.columns + c] = table[m * params.columns + c]; }\n  }\n  flags[i] = select(0u, 1u, flagged);\n}\n";

package/dist/gpu/wgsl-chart-kernel.js

@@ -6,25 +6,26 @@
  *
  * Every classification decision (half-plane, disk, sector, cell and gap boundaries) is evaluated with an
  * a-priori bound on how far the float32 decision value can be from the float64 reference value: the
- * point's float32 rounding, each float32 operation (u = 2^-24, correctly rounded + − ×), the float32
- * rounding of the constants and the reference's own float64 rounding. A point whose decision value lies
- * within four times its bound is flagged, and the host recomputes it with the reference. So every
- * unflagged point has exactly the reference's material, and its value is the reference value rounded
- * once to float32.
+ * point's float32 rounding, each float32 operation (E = 2^-23: one WGSL rounding of + − ×, in either
+ * direction, W3C WGSL "Floating Point Accuracy"), the float32 rounding of the constants and the
+ * reference's own float64 rounding. A point whose decision value lies within four times its bound is
+ * flagged, and the host recomputes it with the reference. So every unflagged point has exactly the
+ * reference's material, and its value is the reference value rounded once to float32.
  *
- * Siemens-star sectors are found from a rough `atan2` (any accuracy) and then decided exactly by the
- * signs of cross products with the sector boundary directions, so WGSL's 4096-ULP `atan2` bound does not
- * enter. See docs/WEBGPU.md, "Scene radiance on the GPU".
+ * Siemens-star sectors are decided only by the signs of cross products with the sector boundary
+ * directions (host float64 cos/sin, rounded once to float32): the sign of v chooses the half-plane, a
+ * binary search over that half-plane's boundaries finds the sector, and the two enclosing cross products
+ * carry the bound. The kernel calls no transcendental function, so neither the WGSL `atan2` bound nor the
+ * realm's float64 `Math.atan2` enters. See docs/WEBGPU.md, "Scene radiance on the GPU".
  */
 export const CHART_WORKGROUP_SIZE = 256;
 /** Preset codes of `Params.preset`, in `CHART_SCENE_PRESETS` order. */
 export const CHART_PRESET_CODE = Object.freeze({ uniform: 0, "slanted-edge": 1, "siemens-star": 2, "step-wedge": 3, "grey-ramp": 4, checkerboard: 5,
     "point-grid": 6, patches: 7 });
 export const CHART_RADIANCE_WGSL = /* wgsl */ `
-const U: f32 = 5.9604644775390625e-8;
+const E: f32 = 1.1920928955078125e-7;
 const SAFETY: f32 = 4.0;
 const SLACK: f32 = 1e-14;
-const PI: f32 = 3.14159265358979;
 struct Params {
   count: u32, columns: u32, preset: u32, na: u32,
   nb: u32, nc: u32, wavelength_mode: u32, pad0: u32,
@@ -49,11 +50,11 @@ fn check_integer(t: f32, bound: f32, lo: f32, hi: f32) {
 }
 // x = (a + b) * scale, with the bound of its distance from the float64 reference value.
 fn scaled_sum_bound(a: f32, b: f32, s: f32, scale: f32, x: f32, constant_rounding: f32) -> f32 {
-  return U * ((abs(a) + abs(b) + abs(s)) * abs(scale) + (1.0 + constant_rounding) * abs(x)) + SLACK * (abs(x) + 1.0);
+  return E * ((abs(a) + abs(b) + abs(s)) * abs(scale) + (1.0 + constant_rounding) * abs(x)) + SLACK * (abs(x) + 1.0);
 }
 fn cross_d(u: f32, v: f32, k: u32) -> f32 { return v * aux[2u * k] - u * aux[2u * k + 1u]; }
 fn cross_bound(u: f32, v: f32, k: u32, d: f32) -> f32 {
-  return U * (3.0 * abs(v * aux[2u * k]) + 3.0 * abs(u * aux[2u * k + 1u]) + abs(d)) + SLACK * (abs(u) + abs(v));
+  return E * (3.0 * abs(v * aux[2u * k]) + 3.0 * abs(u * aux[2u * k + 1u]) + abs(d)) + SLACK * (abs(u) + abs(v));
 }
 fn material(p: vec2<f32>) -> u32 {
   let u = p.x;
@@ -65,22 +66,27 @@ fn material(p: vec2<f32>) -> u32 {
       let a = u * params.f0;
       let b = v * params.f1;
       let d = a - b;
-      check(d, U * (3.0 * abs(a) + 3.0 * abs(b) + abs(d)) + SLACK * (abs(u) + abs(v)));
+      check(d, E * (3.0 * abs(a) + 3.0 * abs(b) + abs(d)) + SLACK * (abs(u) + abs(v)));
       return select(0u, 1u, d >= 0.0);
     }
     case 2u: {
       let uu = u * u;
       let vv = v * v;
       let q = uu + vv;
-      check(q - params.f0, U * (4.0 * q + 2.0 * params.f0) + SLACK * (q + params.f0));
+      check(q - params.f0, E * (4.0 * q + 2.0 * params.f0) + SLACK * (q + params.f0));
       if (q > params.f0) { return 2u; }
-      let sectors = 2u * params.na;
-      var k = u32(clamp(floor((atan2(v, u) + PI) * f32(params.na) / PI), 0.0, f32(sectors - 1u)));
-      for (var step = 0u; step < 4u; step++) {
-        if (cross_d(u, v, k) < 0.0 && k > 0u) { k = k - 1u; continue; }
-        if (cross_d(u, v, k + 1u) >= 0.0 && k + 1u < sectors) { k = k + 1u; continue; }
-        break;
+      // Boundaries b_k = π(k/cycles − 1), k = 0 … 2·cycles. In the half-plane v ≥ 0 the angle lies in [0, π],
+      // between b_cycles and b_2cycles; for v < 0 in [−π, 0), between b_0 and b_cycles. Within one half-plane,
+      // sign(cross(k)) = sign(θ − b_k), so a binary search on the cross-product signs finds the sector. A point
+      // within the bound of a boundary (the u-axis and the ±π cut included) is caught by the two final checks.
+      var low = select(0u, params.na, v >= 0.0);
+      var high = low + params.na;
+      loop {
+        if (high - low <= 1u) { break; }
+        let middle = (low + high) >> 1u;
+        if (cross_d(u, v, middle) >= 0.0) { low = middle; } else { high = middle; }
       }
+      let k = low;
       let lo = cross_d(u, v, k);
       let hi = cross_d(u, v, k + 1u);
       if (lo < 0.0 || hi >= 0.0) { flagged = true; }
@@ -117,10 +123,10 @@ fn material(p: vec2<f32>) -> u32 {
       let c = j * params.na + i;
       let dx = u - aux[2u * c];
       let dy = v - aux[2u * c + 1u];
-      let ex = U * (abs(u) + abs(aux[2u * c]) + abs(dx));
-      let ey = U * (abs(v) + abs(aux[2u * c + 1u]) + abs(dy));
+      let ex = E * (abs(u) + abs(aux[2u * c]) + abs(dx));
+      let ey = E * (abs(v) + abs(aux[2u * c + 1u]) + abs(dy));
       let d2 = dx * dx + dy * dy;
-      check(d2 - params.f3, 2.0 * (abs(dx) * ex + abs(dy) * ey) + ex * ex + ey * ey + U * (2.0 * d2 + params.f3) + SLACK * (d2 + params.f3));
+      check(d2 - params.f3, 2.0 * (abs(dx) * ex + abs(dy) * ey) + ex * ex + ey * ey + E * (2.0 * d2 + params.f3) + SLACK * (d2 + params.f3));
       return select(0u, 1u, d2 <= params.f3);
     }
     default: {
@@ -139,10 +145,10 @@ fn material(p: vec2<f32>) -> u32 {
       let index = u32(ify) * params.na + u32(ifx);
       let x = fx - ifx;
       let y = fy - ify;
-      check(x - params.f3, bx + U * params.f3);
-      check(x - params.f4, bx + U * params.f4);
-      check(y - params.f3, by + U * params.f3);
-      check(y - params.f4, by + U * params.f4);
+      check(x - params.f3, bx + E * params.f3);
+      check(x - params.f4, bx + E * params.f4);
+      check(y - params.f3, by + E * params.f3);
+      check(y - params.f4, by + E * params.f4);
       if (index >= params.nc || x < params.f3 || x > params.f4 || y < params.f3 || y > params.f4) { return background; }
       return index;
     }

package/dist/gpu/wgsl-chart-kernel.js.map

@@ -1 +1 @@
-{"version":3,"file":"wgsl-chart-kernel.js","sourceRoot":"","sources":["../../src/gpu/wgsl-chart-kernel.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAC;AACxC,uEAAuE;AACvE,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC;IACjJ,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAW,CAAC,CAAC;AAE1C,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAgInB,oBAAoB;;uCAER,oBAAoB;;;;;;;;;;;CAW1D,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * WGSL kernel for the `webgpu-f32` chart-radiance stage (#277), one invocation per query point. It\n * evaluates the chart's material classification (`resolveChartScene().materialAt`) in float32 and looks up\n * the material's value in a table the host computed in float64 with the reference's own operations.\n *\n * Every classification decision (half-plane, disk, sector, cell and gap boundaries) is evaluated with an\n * a-priori bound on how far the float32 decision value can be from the float64 reference value: the\n * point's float32 rounding, each float32 operation (u = 2^-24, correctly rounded + − ×), the float32\n * rounding of the constants and the reference's own float64 rounding. A point whose decision value lies\n * within four times its bound is flagged, and the host recomputes it with the reference. So every\n * unflagged point has exactly the reference's material, and its value is the reference value rounded\n * once to float32.\n *\n * Siemens-star sectors are found from a rough `atan2` (any accuracy) and then decided exactly by the\n * signs of cross products with the sector boundary directions, so WGSL's 4096-ULP `atan2` bound does not\n * enter. See docs/WEBGPU.md, \"Scene radiance on the GPU\".\n */\n\nexport const CHART_WORKGROUP_SIZE = 256;\n/** Preset codes of `Params.preset`, in `CHART_SCENE_PRESETS` order. */\nexport const CHART_PRESET_CODE = Object.freeze({ uniform: 0, \"slanted-edge\": 1, \"siemens-star\": 2, \"step-wedge\": 3, \"grey-ramp\": 4, checkerboard: 5,\n  \"point-grid\": 6, patches: 7 } as const);\n\nexport const CHART_RADIANCE_WGSL = /* wgsl */ `\nconst U: f32 = 5.9604644775390625e-8;\nconst SAFETY: f32 = 4.0;\nconst SLACK: f32 = 1e-14;\nconst PI: f32 = 3.14159265358979;\nstruct Params {\n  count: u32, columns: u32, preset: u32, na: u32,\n  nb: u32, nc: u32, wavelength_mode: u32, pad0: u32,\n  f0: f32, f1: f32, f2: f32, f3: f32,\n  f4: f32, f5: f32, f6: f32, f7: f32,\n};\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> points: array<vec2<f32>>;\n@group(0) @binding(2) var<storage, read> table: array<f32>;\n@group(0) @binding(3) var<storage, read> aux: array<f32>;\n@group(0) @binding(4) var<storage, read> selectors: array<u32>;\n@group(0) @binding(5) var<storage, read_write> values: array<f32>;\n@group(0) @binding(6) var<storage, read_write> flags: array<u32>;\n\nvar<private> flagged: bool;\nfn check(distance: f32, bound: f32) { if (!(abs(distance) > SAFETY * bound)) { flagged = true; } }\n// Flags t when it lies within the bound of an integer n with lo <= n <= hi.\nfn check_integer(t: f32, bound: f32, lo: f32, hi: f32) {\n  let n = round(t);\n  if (SAFETY * bound >= 0.5) { flagged = true; return; }\n  if (n >= lo && n <= hi) { check(t - n, bound); }\n}\n// x = (a + b) * scale, with the bound of its distance from the float64 reference value.\nfn scaled_sum_bound(a: f32, b: f32, s: f32, scale: f32, x: f32, constant_rounding: f32) -> f32 {\n  return U * ((abs(a) + abs(b) + abs(s)) * abs(scale) + (1.0 + constant_rounding) * abs(x)) + SLACK * (abs(x) + 1.0);\n}\nfn cross_d(u: f32, v: f32, k: u32) -> f32 { return v * aux[2u * k] - u * aux[2u * k + 1u]; }\nfn cross_bound(u: f32, v: f32, k: u32, d: f32) -> f32 {\n  return U * (3.0 * abs(v * aux[2u * k]) + 3.0 * abs(u * aux[2u * k + 1u]) + abs(d)) + SLACK * (abs(u) + abs(v));\n}\nfn material(p: vec2<f32>) -> u32 {\n  let u = p.x;\n  let v = p.y;\n  switch (params.preset) {\n    case 0u: { return 0u; }\n    case 1u: {\n      // Light where u·cos t − v·sin t ≥ 0.\n      let a = u * params.f0;\n      let b = v * params.f1;\n      let d = a - b;\n      check(d, U * (3.0 * abs(a) + 3.0 * abs(b) + abs(d)) + SLACK * (abs(u) + abs(v)));\n      return select(0u, 1u, d >= 0.0);\n    }\n    case 2u: {\n      let uu = u * u;\n      let vv = v * v;\n      let q = uu + vv;\n      check(q - params.f0, U * (4.0 * q + 2.0 * params.f0) + SLACK * (q + params.f0));\n      if (q > params.f0) { return 2u; }\n      let sectors = 2u * params.na;\n      var k = u32(clamp(floor((atan2(v, u) + PI) * f32(params.na) / PI), 0.0, f32(sectors - 1u)));\n      for (var step = 0u; step < 4u; step++) {\n        if (cross_d(u, v, k) < 0.0 && k > 0u) { k = k - 1u; continue; }\n        if (cross_d(u, v, k + 1u) >= 0.0 && k + 1u < sectors) { k = k + 1u; continue; }\n        break;\n      }\n      let lo = cross_d(u, v, k);\n      let hi = cross_d(u, v, k + 1u);\n      if (lo < 0.0 || hi >= 0.0) { flagged = true; }\n      check(lo, cross_bound(u, v, k, lo));\n      check(hi, cross_bound(u, v, k + 1u, hi));\n      return select(0u, 1u, k % 2u == 0u);\n    }\n    case 3u, 4u: {\n      let s = u + 1.0;\n      let t = s * params.f0;\n      check_integer(t, scaled_sum_bound(u, 1.0, s, params.f0, t, 0.0), 1.0, f32(params.na - 1u));\n      return u32(clamp(floor(t), 0.0, f32(params.na - 1u)));\n    }\n    case 5u: {\n      let s = u + 1.0;\n      let x = s * params.f0;\n      let w = params.f1 - v;\n      let y = w * params.f0;\n      check_integer(x, scaled_sum_bound(u, 1.0, s, params.f0, x, 0.0), -3.0e38, 3.0e38);\n      check_integer(y, scaled_sum_bound(params.f1, v, w, params.f0, y, 0.0), -3.0e38, 3.0e38);\n      let i = i32(floor(x));\n      let j = i32(floor(y));\n      return select(0u, 1u, (i + j) % 2 == 0);\n    }\n    case 6u: {\n      let s = u + 1.0;\n      let x = s * params.f0;\n      let w = params.f1 - v;\n      let y = w * params.f2;\n      check_integer(x, scaled_sum_bound(u, 1.0, s, params.f0, x, 0.0), 1.0, f32(params.na - 1u));\n      check_integer(y, scaled_sum_bound(params.f1, v, w, params.f2, y, 1.0), 1.0, f32(params.nb - 1u));\n      let i = u32(clamp(floor(x), 0.0, f32(params.na - 1u)));\n      let j = u32(clamp(floor(y), 0.0, f32(params.nb - 1u)));\n      let c = j * params.na + i;\n      let dx = u - aux[2u * c];\n      let dy = v - aux[2u * c + 1u];\n      let ex = U * (abs(u) + abs(aux[2u * c]) + abs(dx));\n      let ey = U * (abs(v) + abs(aux[2u * c + 1u]) + abs(dy));\n      let d2 = dx * dx + dy * dy;\n      check(d2 - params.f3, 2.0 * (abs(dx) * ex + abs(dy) * ey) + ex * ex + ey * ey + U * (2.0 * d2 + params.f3) + SLACK * (d2 + params.f3));\n      return select(0u, 1u, d2 <= params.f3);\n    }\n    default: {\n      let s = u + 1.0;\n      let fx = s * params.f0;\n      let w = params.f1 - v;\n      let fy = w * params.f2;\n      let bx = scaled_sum_bound(u, 1.0, s, params.f0, fx, 0.0);\n      let by = scaled_sum_bound(params.f1, v, w, params.f2, fy, 1.0);\n      check_integer(fx, bx, -3.0e38, 3.0e38);\n      check_integer(fy, by, -3.0e38, 3.0e38);\n      let background = params.nc;\n      let ifx = floor(fx);\n      let ify = floor(fy);\n      if (ifx < 0.0 || ify < 0.0 || ifx >= f32(params.na) || ify >= f32(params.nb)) { return background; }\n      let index = u32(ify) * params.na + u32(ifx);\n      let x = fx - ifx;\n      let y = fy - ify;\n      check(x - params.f3, bx + U * params.f3);\n      check(x - params.f4, bx + U * params.f4);\n      check(y - params.f3, by + U * params.f3);\n      check(y - params.f4, by + U * params.f4);\n      if (index >= params.nc || x < params.f3 || x > params.f4 || y < params.f3 || y > params.f4) { return background; }\n      return index;\n    }\n  }\n}\n@compute @workgroup_size(${CHART_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 * ${CHART_WORKGROUP_SIZE}u;\n  if (i >= params.count) { return; }\n  flagged = false;\n  let m = material(points[i]);\n  if (params.wavelength_mode != 0u) {\n    values[i] = table[m * params.columns + selectors[i]];\n  } else {\n    for (var c = 0u; c < params.columns; c++) { values[i * params.columns + c] = table[m * params.columns + c]; }\n  }\n  flags[i] = select(0u, 1u, flagged);\n}\n`;\n"]}
+{"version":3,"file":"wgsl-chart-kernel.js","sourceRoot":"","sources":["../../src/gpu/wgsl-chart-kernel.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAC;AACxC,uEAAuE;AACvE,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC;IACjJ,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAW,CAAC,CAAC;AAE1C,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoInB,oBAAoB;;uCAER,oBAAoB;;;;;;;;;;;CAW1D,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * WGSL kernel for the `webgpu-f32` chart-radiance stage (#277), one invocation per query point. It\n * evaluates the chart's material classification (`resolveChartScene().materialAt`) in float32 and looks up\n * the material's value in a table the host computed in float64 with the reference's own operations.\n *\n * Every classification decision (half-plane, disk, sector, cell and gap boundaries) is evaluated with an\n * a-priori bound on how far the float32 decision value can be from the float64 reference value: the\n * point's float32 rounding, each float32 operation (E = 2^-23: one WGSL rounding of + − ×, in either\n * direction, W3C WGSL \"Floating Point Accuracy\"), the float32 rounding of the constants and the\n * reference's own float64 rounding. A point whose decision value lies within four times its bound is\n * flagged, and the host recomputes it with the reference. So every unflagged point has exactly the\n * reference's material, and its value is the reference value rounded once to float32.\n *\n * Siemens-star sectors are decided only by the signs of cross products with the sector boundary\n * directions (host float64 cos/sin, rounded once to float32): the sign of v chooses the half-plane, a\n * binary search over that half-plane's boundaries finds the sector, and the two enclosing cross products\n * carry the bound. The kernel calls no transcendental function, so neither the WGSL `atan2` bound nor the\n * realm's float64 `Math.atan2` enters. See docs/WEBGPU.md, \"Scene radiance on the GPU\".\n */\n\nexport const CHART_WORKGROUP_SIZE = 256;\n/** Preset codes of `Params.preset`, in `CHART_SCENE_PRESETS` order. */\nexport const CHART_PRESET_CODE = Object.freeze({ uniform: 0, \"slanted-edge\": 1, \"siemens-star\": 2, \"step-wedge\": 3, \"grey-ramp\": 4, checkerboard: 5,\n  \"point-grid\": 6, patches: 7 } as const);\n\nexport const CHART_RADIANCE_WGSL = /* wgsl */ `\nconst E: f32 = 1.1920928955078125e-7;\nconst SAFETY: f32 = 4.0;\nconst SLACK: f32 = 1e-14;\nstruct Params {\n  count: u32, columns: u32, preset: u32, na: u32,\n  nb: u32, nc: u32, wavelength_mode: u32, pad0: u32,\n  f0: f32, f1: f32, f2: f32, f3: f32,\n  f4: f32, f5: f32, f6: f32, f7: f32,\n};\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> points: array<vec2<f32>>;\n@group(0) @binding(2) var<storage, read> table: array<f32>;\n@group(0) @binding(3) var<storage, read> aux: array<f32>;\n@group(0) @binding(4) var<storage, read> selectors: array<u32>;\n@group(0) @binding(5) var<storage, read_write> values: array<f32>;\n@group(0) @binding(6) var<storage, read_write> flags: array<u32>;\n\nvar<private> flagged: bool;\nfn check(distance: f32, bound: f32) { if (!(abs(distance) > SAFETY * bound)) { flagged = true; } }\n// Flags t when it lies within the bound of an integer n with lo <= n <= hi.\nfn check_integer(t: f32, bound: f32, lo: f32, hi: f32) {\n  let n = round(t);\n  if (SAFETY * bound >= 0.5) { flagged = true; return; }\n  if (n >= lo && n <= hi) { check(t - n, bound); }\n}\n// x = (a + b) * scale, with the bound of its distance from the float64 reference value.\nfn scaled_sum_bound(a: f32, b: f32, s: f32, scale: f32, x: f32, constant_rounding: f32) -> f32 {\n  return E * ((abs(a) + abs(b) + abs(s)) * abs(scale) + (1.0 + constant_rounding) * abs(x)) + SLACK * (abs(x) + 1.0);\n}\nfn cross_d(u: f32, v: f32, k: u32) -> f32 { return v * aux[2u * k] - u * aux[2u * k + 1u]; }\nfn cross_bound(u: f32, v: f32, k: u32, d: f32) -> f32 {\n  return E * (3.0 * abs(v * aux[2u * k]) + 3.0 * abs(u * aux[2u * k + 1u]) + abs(d)) + SLACK * (abs(u) + abs(v));\n}\nfn material(p: vec2<f32>) -> u32 {\n  let u = p.x;\n  let v = p.y;\n  switch (params.preset) {\n    case 0u: { return 0u; }\n    case 1u: {\n      // Light where u·cos t − v·sin t ≥ 0.\n      let a = u * params.f0;\n      let b = v * params.f1;\n      let d = a - b;\n      check(d, E * (3.0 * abs(a) + 3.0 * abs(b) + abs(d)) + SLACK * (abs(u) + abs(v)));\n      return select(0u, 1u, d >= 0.0);\n    }\n    case 2u: {\n      let uu = u * u;\n      let vv = v * v;\n      let q = uu + vv;\n      check(q - params.f0, E * (4.0 * q + 2.0 * params.f0) + SLACK * (q + params.f0));\n      if (q > params.f0) { return 2u; }\n      // Boundaries b_k = π(k/cycles − 1), k = 0 … 2·cycles. In the half-plane v ≥ 0 the angle lies in [0, π],\n      // between b_cycles and b_2cycles; for v < 0 in [−π, 0), between b_0 and b_cycles. Within one half-plane,\n      // sign(cross(k)) = sign(θ − b_k), so a binary search on the cross-product signs finds the sector. A point\n      // within the bound of a boundary (the u-axis and the ±π cut included) is caught by the two final checks.\n      var low = select(0u, params.na, v >= 0.0);\n      var high = low + params.na;\n      loop {\n        if (high - low <= 1u) { break; }\n        let middle = (low + high) >> 1u;\n        if (cross_d(u, v, middle) >= 0.0) { low = middle; } else { high = middle; }\n      }\n      let k = low;\n      let lo = cross_d(u, v, k);\n      let hi = cross_d(u, v, k + 1u);\n      if (lo < 0.0 || hi >= 0.0) { flagged = true; }\n      check(lo, cross_bound(u, v, k, lo));\n      check(hi, cross_bound(u, v, k + 1u, hi));\n      return select(0u, 1u, k % 2u == 0u);\n    }\n    case 3u, 4u: {\n      let s = u + 1.0;\n      let t = s * params.f0;\n      check_integer(t, scaled_sum_bound(u, 1.0, s, params.f0, t, 0.0), 1.0, f32(params.na - 1u));\n      return u32(clamp(floor(t), 0.0, f32(params.na - 1u)));\n    }\n    case 5u: {\n      let s = u + 1.0;\n      let x = s * params.f0;\n      let w = params.f1 - v;\n      let y = w * params.f0;\n      check_integer(x, scaled_sum_bound(u, 1.0, s, params.f0, x, 0.0), -3.0e38, 3.0e38);\n      check_integer(y, scaled_sum_bound(params.f1, v, w, params.f0, y, 0.0), -3.0e38, 3.0e38);\n      let i = i32(floor(x));\n      let j = i32(floor(y));\n      return select(0u, 1u, (i + j) % 2 == 0);\n    }\n    case 6u: {\n      let s = u + 1.0;\n      let x = s * params.f0;\n      let w = params.f1 - v;\n      let y = w * params.f2;\n      check_integer(x, scaled_sum_bound(u, 1.0, s, params.f0, x, 0.0), 1.0, f32(params.na - 1u));\n      check_integer(y, scaled_sum_bound(params.f1, v, w, params.f2, y, 1.0), 1.0, f32(params.nb - 1u));\n      let i = u32(clamp(floor(x), 0.0, f32(params.na - 1u)));\n      let j = u32(clamp(floor(y), 0.0, f32(params.nb - 1u)));\n      let c = j * params.na + i;\n      let dx = u - aux[2u * c];\n      let dy = v - aux[2u * c + 1u];\n      let ex = E * (abs(u) + abs(aux[2u * c]) + abs(dx));\n      let ey = E * (abs(v) + abs(aux[2u * c + 1u]) + abs(dy));\n      let d2 = dx * dx + dy * dy;\n      check(d2 - params.f3, 2.0 * (abs(dx) * ex + abs(dy) * ey) + ex * ex + ey * ey + E * (2.0 * d2 + params.f3) + SLACK * (d2 + params.f3));\n      return select(0u, 1u, d2 <= params.f3);\n    }\n    default: {\n      let s = u + 1.0;\n      let fx = s * params.f0;\n      let w = params.f1 - v;\n      let fy = w * params.f2;\n      let bx = scaled_sum_bound(u, 1.0, s, params.f0, fx, 0.0);\n      let by = scaled_sum_bound(params.f1, v, w, params.f2, fy, 1.0);\n      check_integer(fx, bx, -3.0e38, 3.0e38);\n      check_integer(fy, by, -3.0e38, 3.0e38);\n      let background = params.nc;\n      let ifx = floor(fx);\n      let ify = floor(fy);\n      if (ifx < 0.0 || ify < 0.0 || ifx >= f32(params.na) || ify >= f32(params.nb)) { return background; }\n      let index = u32(ify) * params.na + u32(ifx);\n      let x = fx - ifx;\n      let y = fy - ify;\n      check(x - params.f3, bx + E * params.f3);\n      check(x - params.f4, bx + E * params.f4);\n      check(y - params.f3, by + E * params.f3);\n      check(y - params.f4, by + E * params.f4);\n      if (index >= params.nc || x < params.f3 || x > params.f4 || y < params.f3 || y > params.f4) { return background; }\n      return index;\n    }\n  }\n}\n@compute @workgroup_size(${CHART_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 * ${CHART_WORKGROUP_SIZE}u;\n  if (i >= params.count) { return; }\n  flagged = false;\n  let m = material(points[i]);\n  if (params.wavelength_mode != 0u) {\n    values[i] = table[m * params.columns + selectors[i]];\n  } else {\n    for (var c = 0u; c < params.columns; c++) { values[i * params.columns + c] = table[m * params.columns + c]; }\n  }\n  flags[i] = select(0u, 1u, flagged);\n}\n`;\n"]}

package/dist/gpu/wgsl-display-view-quality-kernel.d.ts

@@ -0,0 +1,95 @@
+export declare const DISPLAY_VIEW_QUALITY_WORKGROUP_SIZE = 64;
+/** Largest footprint per axis (real pixels), as the Speed kernel. */
+export declare const DISPLAY_VIEW_QUALITY_MAXIMUM_PIXELS_PER_AXIS = 6;
+/** Uniform parameter words (see `Params`): 56 words, 224 bytes. */
+export declare const DISPLAY_VIEW_QUALITY_PARAM_WORDS = 56;
+/** Words per lattice-group record: lx0, ly0, lw, lh, lbase, first tap (the blocked site pass, #492), cu (f32), cv (f32). */
+export declare const DISPLAY_VIEW_QUALITY_GROUP_WORDS = 8;
+/** Words per tap record: group, dp offset, dq offset, pad. */
+export declare const DISPLAY_VIEW_QUALITY_TAP_WORDS = 4;
+/** Floats per native site of the site buffer: mean, variance, third cumulant, their three bounds, flag (u32 bits), electrons. */
+export declare const DISPLAY_VIEW_QUALITY_SITE_FLOATS = 8;
+/** Floats per display pixel in the output buffer: m0 m1 m2, v00 v11 v22, c01 c02 c12, mean bound, variance bound (absolute). */
+export declare const DISPLAY_VIEW_QUALITY_OUTPUT_FLOATS = 11;
+/** Floats per column or row record of the geometry buffer (the Speed layout). */
+export declare const DISPLAY_VIEW_QUALITY_GEOMETRY_STRIDE = 20;
+/** Candidate table: entries per phase (the 7 × 7 window of AHD's reach 3) and floats per entry (dx, dy, dh0, dh1, dh2, dv0, dv1, dv2). */
+export declare const DISPLAY_VIEW_QUALITY_CANDIDATE_ENTRIES = 49;
+export declare const DISPLAY_VIEW_QUALITY_CANDIDATE_FLOATS = 8;
+/** Layout of the aux table (float32 words). */
+export declare const DISPLAY_VIEW_QUALITY_AUX: Readonly<{
+    /** Per phase p, channel c, tap t: dx, dy, weight, 0 (the bilinear kernels, 4 taps; unused taps have weight 0). */
+    bilinear: 0;
+    /** Per phase p, channel c: 1 / Σ_t w_t² of the bilinear kernel (host float64). */
+    inverseW2: 192;
+    /** 16 Gauss–Legendre nodes then 16 weights on [−1, 1]. */
+    gaussLegendre: 208;
+    /** Per phase: the entry count (as u32 bits) and 3 pad words, then the entries (dx, dy, dense weights of candidate 0 and 1 per channel). */
+    candidates: 240;
+    candidatePhaseStride: number;
+    size: number;
+}>;
+/** Pixel flag bits of the output flag word. */
+export declare const DISPLAY_VIEW_QUALITY_FLAG: Readonly<{
+    /** A site the pixel read had an uncertain lattice material (recompute on the host). */
+    materialUncertain: 1;
+    /** A site the pixel read lies outside the band's site window (a host geometry error; recompute). */
+    siteOutsideWindow: 2;
+    /** The correction needed a grid state the table does not hold (recompute, or compute the state and dispatch again). */
+    stateMissing: 4;
+    /** A sample's pixel variance lies within its bound of the correction threshold (recompute). */
+    thresholdTie: 8;
+    /** Informational: the pixel's expected value includes the low-signal correction. */
+    corrected: 16;
+    /** The bits that require the host's recomputation. */
+    recompute: 15;
+}>;
+/** Words of the grid-key bitmap: one bit per grid key (AHD_KEY_LEVELS³ keys). */
+export declare const DISPLAY_VIEW_QUALITY_BITMAP_WORDS: number;
+/**
+ * A site whose uncertain lattice points (the material module's flag) could move its electrons by more than this fraction of
+ * their value is flagged for host recomputation; a smaller uncertainty enters the site's bound instead (the tap weights times
+ * the largest value difference between any two materials at that tap).
+ */
+export declare const DISPLAY_VIEW_QUALITY_UNCERTAINTY_LIMIT: number;
+/** Bound constant of a clipped-normal slope Φ(z) (in units of E): z's 8E through φ·|z| ≤ 0.24 plus the Abramowitz–Stegun 147E. */
+export declare const DISPLAY_VIEW_QUALITY_SLOPE_U = 200;
+/**
+ * Pass 1: the material of every lattice point of every group (the module's `material_at`, its uncertainty in bit 31; the output
+ * is `lattice_out`, since a material module may declare its own `lattice`, as #491's composite module does). The group
+ * records hold each group's lattice window (lx0, ly0, lw, lh), its first index in the lattice buffer and the point constants
+ * c_u = 0.5 + f_x − W/2 and c_v = 0.5 + f_y − H/2 (exact in float32, checked by the host).
+ */
+export declare const DISPLAY_VIEW_QUALITY_LATTICE_WGSL: string;
+/**
+ * Pass 2: the expected electrons, readout moments and white clip of every native site of the band's window, with their bounds.
+ * The site's electrons are Σ_t table[(m_t·3 + c)·T + t] + dark_c, every term non-negative and rounded once on the host, so the
+ * sum carries (T + 3)·E relative (`params.site_gamma`, the host's value). An uncertain lattice point adds the tap's value spread
+ * over the materials (`spread`, host float64) to the site's uncertainty, which enters its bounds, or flags the site when it
+ * exceeds UNCERTAINTY_LIMIT of the electrons. One dispatch covers the `params.count` sites from `params.site_first` (#492: the
+ * host splits a band's sites over several dispatches so that no dispatch gathers more than its tap budget).
+ */
+export declare const DISPLAY_VIEW_QUALITY_SITES_WGSL: string;
+/**
+ * Pass 2 with the defocus disc (#492): the same site electrons from a factored table, summed in blocks.
+ *
+ * - **Factored table.** A neutral material's value is its reflectance times the white's combined kernel (the reference forms it
+ *   so: reflectance[m]·neutral_c(t)), so the table holds one neutral row per channel and one row per spectral material, and
+ *   `materials` holds per material its row (0 for neutral, 1 + s for spectral material s) and its reflectance as float32 bits
+ *   (1 for a spectral material, an exact product). A scene of thousands of neutral materials (#491's composite: 4 143) then
+ *   needs 3·T values instead of 3·T per material.
+ * - **Blocked sum.** Every group's taps form a dense cw × ch rectangle (the combined kernel's window, row-major from the group's
+ *   first tap, `groups[g + 5]`), so a site sums each row of a group into a row partial, the rows into a group partial and the
+ *   groups into the total. No tap records are read: the tap's lattice offset within its group is its (dx, dy).
+ *
+ * Every term is non-negative and carries two host roundings (u each, u = E/2: the row value and the reflectance), one product
+ * (E) and at most cw + ch + G additions, plus the dark electrons' addition, so the electrons carry (cw_max + ch_max + G + 3)·E
+ * relative (`params.site_gamma`; recursive summation of the up to 4·(2·96 + 2)² = 150 544 taps of a combined radius of 96 would
+ * carry (T + 3)·E ≈ 1.8 % instead). The uncertainty, summed the same way, is scaled by 1 + site_gamma, and `params.site_tiny`
+ * (host float64, rounded up) bounds the terms below the float32 normal range, which a device may flush to zero.
+ */
+export declare const DISPLAY_VIEW_QUALITY_SITES_BLOCKED_WGSL: string;
+/** Pass 3: the display pixels (see the module comment). */
+export declare const DISPLAY_VIEW_QUALITY_PIXELS_WGSL: string;
+/** The lattice pass with a material module appended (`fn material_at(p: vec2<f32>) -> u32`, `var<private> material_uncertain: bool`). */
+export declare function assembleDisplayViewQualityLatticeWgsl(materialModuleWgsl: string): string;