@woosh/meep-engine 3.38.0 → 3.40.0

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_footprint_bias.js

@@ -0,0 +1,45 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_SAMPLE_BIAS_SLICES, AVBOIT_VOXEL_DOWNSCALE } from "./AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+
+/**
+ * How much further toward the camera, in virtual slices, a fragment has to look the integral up so
+ * that its own surface does not occlude it through the neighbouring voxel columns — given
+ * `virtual_fwidth`, the fragment's `fwidth` of its virtual slice coordinate
+ * (`avboit_view_depth_to_virtual`), which the caller takes in the fragment stage.
+ *
+ * The volume is 1/8 resolution and every column holds a surface at the depth under the column's
+ * centre. The draw reads the four nearest columns bilinearly, up to one voxel away. On a surface
+ * tilted away from the camera, the neighbour on its near side holds the same surface nearer by the
+ * surface's depth change over that distance, and once that exceeds the two-slice base bias the
+ * surface occludes itself — by an amount that depends on where the pixel sits in its voxel, so an
+ * overlapping layer showed 8-pixel stripes (ledger entry 26: 3–5 sRGB codes on the device at 45–60°).
+ * A voxel's width of the surface's own depth change, `AVBOIT_VOXEL_DOWNSCALE × fwidth`, covers the
+ * farthest column the lookup reaches. The virtual coordinate is convex along a plane seen in
+ * perspective, so its derivative at the fragment bounds the change toward the near side.
+ *
+ * What it costs: a tilted fragment is not occluded by what lies within that band in front of it, the
+ * depth the volume cannot tell apart from the surface itself at this resolution. The band is capped at
+ * the base bias of the coarsest slicing, `V / P` base biases — the separation every surface already
+ * has whenever the volume is full and the warp halves down to `V = P` — so where the derivative runs
+ * away, at a silhouette or a grazing angle, the extra a fragment ignores is never more than that. The
+ * whole reach is the base bias plus the band: at most `2 + 2 V / P` virtual slices, twice the coarsest
+ * separation when the volume is full, about the coarsest separation at `V = 4096`. Past the cap (about
+ * 85° at 1080p in a sparse volume) the stripes can return.
+ *
+ * A fragment that writes nothing into the volume — an additive particle's — has nothing of its own there
+ * to occlude it and takes no footprint.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_footprint_bias = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_footprint_bias(warp: ptr<storage, ${AVBOIT_WARP_STRUCT.wgsl_ref}, read>, virtual_fwidth: f32) -> f32 {
+    let cap = ${AVBOIT_SAMPLE_BIAS_SLICES.toFixed(1)} * f32((*warp).virtual_count) / f32(max((*warp).physical_count, 1u));
+    return min(${AVBOIT_VOXEL_DOWNSCALE.toFixed(1)} * virtual_fwidth, cap);
+}
+    `, [
+        AVBOIT_WARP_STRUCT.declaration_chunk,
+    ]
+);

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_integral_depth_coordinate.d.ts

@@ -10,6 +10,10 @@
  * centre `(p + 0.5) / (P + 1)`: a run boundary lands exactly on a texel and the sample is the sum of
  * the slices before it, with no share of the slice after.
  *
+ * `footprint_bias` is added to the base bias, in the same virtual slices: what the fragment's own
+ * surface needs on top of it not to occlude itself through the neighbouring voxel columns
+ * (`avboit_footprint_bias`), or `0` for a surface that writes nothing into the volume.
+ *
  * @type {CodeChunk}
  */
 export const chunk_avboit_integral_depth_coordinate: CodeChunk;

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_integral_depth_coordinate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_avboit_integral_depth_coordinate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_integral_depth_coordinate.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,qDAFU,SAAS,CAgBjB;0BAlCwB,uCAAuC"}
+{"version":3,"file":"chunk_avboit_integral_depth_coordinate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_integral_depth_coordinate.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AACH,qDAFU,SAAS,CAgBjB;0BAtCwB,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_integral_depth_coordinate.js

@@ -16,14 +16,18 @@ import { chunk_avboit_warp } from "./chunk_avboit_warp.js";
  * centre `(p + 0.5) / (P + 1)`: a run boundary lands exactly on a texel and the sample is the sum of
  * the slices before it, with no share of the slice after.
  *
+ * `footprint_bias` is added to the base bias, in the same virtual slices: what the fragment's own
+ * surface needs on top of it not to occlude itself through the neighbouring voxel columns
+ * (`avboit_footprint_bias`), or `0` for a surface that writes nothing into the volume.
+ *
  * @type {CodeChunk}
  */
 export const chunk_avboit_integral_depth_coordinate = CodeChunk.from(
     //language=WGSL
     `
-fn avboit_integral_depth_coordinate(warp: ptr<storage, ${AVBOIT_WARP_STRUCT.wgsl_ref}, read>, z_view: f32) -> f32 {
+fn avboit_integral_depth_coordinate(warp: ptr<storage, ${AVBOIT_WARP_STRUCT.wgsl_ref}, read>, z_view: f32, footprint_bias: f32) -> f32 {
     let v = avboit_view_depth_to_virtual(warp, z_view);
-    let v_biased = max(v - ${AVBOIT_SAMPLE_BIAS_SLICES}, 0.0);
+    let v_biased = max(v - ${AVBOIT_SAMPLE_BIAS_SLICES} - footprint_bias, 0.0);
     let p = avboit_warp(warp, v_biased);
     return (p + 0.5) / f32((*warp).physical_count + 1u);
 }

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_sample_transmittance.d.ts

@@ -1,7 +1,8 @@
 /**
  * The RGB transmittance of everything in front of a fragment: a trilinear sample of the integral
  * texture at the biased, warped depth, turned back into transmittance. The draw weights a fragment's
- * whole contribution by it.
+ * whole contribution by it. `footprint_bias` is the fragment's `avboit_footprint_bias`, or `0` for a
+ * surface that writes nothing into the volume; see `avboit_integral_depth_coordinate`.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_sample_transmittance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_avboit_sample_transmittance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_sample_transmittance.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,gDAFU,SAAS,CAqBjB;0BA/BwB,uCAAuC"}
+{"version":3,"file":"chunk_avboit_sample_transmittance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_sample_transmittance.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,gDAFU,SAAS,CAsBjB;0BAjCwB,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_sample_transmittance.js

@@ -6,7 +6,8 @@ import { chunk_avboit_integral_depth_coordinate } from "./chunk_avboit_integral_
 /**
  * The RGB transmittance of everything in front of a fragment: a trilinear sample of the integral
  * texture at the biased, warped depth, turned back into transmittance. The draw weights a fragment's
- * whole contribution by it.
+ * whole contribution by it. `footprint_bias` is the fragment's `avboit_footprint_bias`, or `0` for a
+ * surface that writes nothing into the volume; see `avboit_integral_depth_coordinate`.
  *
  * @type {CodeChunk}
  */
@@ -19,8 +20,9 @@ fn avboit_sample_transmittance(
     integral_sampler: sampler,
     screen_uv: vec2<f32>,
     z_view: f32,
+    footprint_bias: f32,
 ) -> vec3<f32> {
-    let w = avboit_integral_depth_coordinate(warp, z_view);
+    let w = avboit_integral_depth_coordinate(warp, z_view, footprint_bias);
     let extinction = textureSampleLevel(integral, integral_sampler, vec3<f32>(screen_uv, w), 0.0).rgb;
     return avboit_extinction_to_transmittance(extinction);
 }

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_level_word.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Word `word` of the warp's occupancy at `virtual_count` virtual slices, from that word's undilated
+ * bits `marked` and its neighbours' `marked_below` and `marked_above` (0 where there is none): dilated
+ * by one slice each side, across word boundaries, with nothing at or past `virtual_count`.
+ *
+ * Dilation is applied at the resolution being tried rather than once at the finest, because a
+ * one-slice margin at 1024 slices is a quarter of a slice at 256 and rounds away; the margin is what
+ * keeps a fragment on the edge of a meshlet's bounds from linear-splatting into a neighbouring run.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp_level_word: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_warp_level_word.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_level_word.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_warp_level_word.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_level_word.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,2CAFU,SAAS,CAejB;0BA3BwB,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_level_word.js

@@ -0,0 +1,28 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_avboit_dilate_word } from "./chunk_avboit_dilate_word.js";
+
+/**
+ * Word `word` of the warp's occupancy at `virtual_count` virtual slices, from that word's undilated
+ * bits `marked` and its neighbours' `marked_below` and `marked_above` (0 where there is none): dilated
+ * by one slice each side, across word boundaries, with nothing at or past `virtual_count`.
+ *
+ * Dilation is applied at the resolution being tried rather than once at the finest, because a
+ * one-slice margin at 1024 slices is a quarter of a slice at 256 and rounds away; the margin is what
+ * keeps a fragment on the edge of a meshlet's bounds from linear-splatting into a neighbouring run.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp_level_word = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_warp_level_word(marked_below: u32, marked: u32, marked_above: u32, word: u32, virtual_count: u32) -> u32 {
+    let dilated = avboit_dilate_word(marked, marked_below >> 31u, (marked_above & 1u) << 31u);
+    let present = virtual_count - min(word * 32u, virtual_count);
+    if (present >= 32u) {
+        return dilated;
+    }
+    return dilated & ((1u << present) - 1u);
+}
+    `,
+    [chunk_avboit_dilate_word]
+);

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_lut_entry.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The warp LUT entry of slice `bit` of a 32-slice occupancy word `word`, given `below`, the occupied
+ * slices in the words before it: occupied slices before this one, shifted up, with this slice's own
+ * occupancy in bit 0 — see `AVBOIT_WARP_STRUCT`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp_lut_entry: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_warp_lut_entry.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_lut_entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_warp_lut_entry.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_lut_entry.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,0CAFU,SAAS,CAUjB;0BAjBwB,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_lut_entry.js

@@ -0,0 +1,18 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * The warp LUT entry of slice `bit` of a 32-slice occupancy word `word`, given `below`, the occupied
+ * slices in the words before it: occupied slices before this one, shifted up, with this slice's own
+ * occupancy in bit 0 — see `AVBOIT_WARP_STRUCT`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp_lut_entry = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_warp_lut_entry(word: u32, bit: u32, below: u32) -> u32 {
+    let prefix = below + countOneBits(word & ((1u << bit) - 1u));
+    return (prefix << 1u) | ((word >> bit) & 1u);
+}
+    `
+);

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_marks.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The slices of a slicing into `virtual_count` virtual slices that the occupied finest slices of
+ * occupancy word `word` (`bits`, finest slices `32 word` to `32 word + 31`) touch: two words of that
+ * slicing's occupancy, from its word `(word · virtual_count) / V_max` on.
+ *
+ * Finest slice `f` touches virtual slices `floor(f V / V_max)` to `ceil((f + 1) V / V_max) - 1` — every
+ * one it shares a length of depth with. At an octave, where `V_max / V` is a power of two, a virtual
+ * slice is occupied exactly when one of the finest slices halving would OR into it is; between octaves
+ * a boundary falls inside a finest slice and both virtual slices take it, which keeps the warp
+ * conservative there — no fragment of an occupied finest slice lands in an unoccupied virtual one.
+ *
+ * Marked a run of occupied slices at a time; a word holds at most 16. Thirty-two finest slices touch
+ * at most 33 virtual ones, so two words always hold them. Division-free: `V_max` is a power of two.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp_marks: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_warp_marks.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_marks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_warp_marks.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_marks.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,sCAFU,SAAS,CAyBjB;0BA3CwB,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_marks.js

@@ -0,0 +1,44 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { AVBOIT_VIRTUAL_SLICES_MAX } from "./AVBOIT_CONSTANTS.js";
+import { chunk_avboit_occupancy_word_mask } from "./chunk_avboit_occupancy_word_mask.js";
+
+/**
+ * The slices of a slicing into `virtual_count` virtual slices that the occupied finest slices of
+ * occupancy word `word` (`bits`, finest slices `32 word` to `32 word + 31`) touch: two words of that
+ * slicing's occupancy, from its word `(word · virtual_count) / V_max` on.
+ *
+ * Finest slice `f` touches virtual slices `floor(f V / V_max)` to `ceil((f + 1) V / V_max) - 1` — every
+ * one it shares a length of depth with. At an octave, where `V_max / V` is a power of two, a virtual
+ * slice is occupied exactly when one of the finest slices halving would OR into it is; between octaves
+ * a boundary falls inside a finest slice and both virtual slices take it, which keeps the warp
+ * conservative there — no fragment of an occupied finest slice lands in an unoccupied virtual one.
+ *
+ * Marked a run of occupied slices at a time; a word holds at most 16. Thirty-two finest slices touch
+ * at most 33 virtual ones, so two words always hold them. Division-free: `V_max` is a power of two.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp_marks = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_warp_marks(bits: u32, word: u32, virtual_count: u32) -> vec2u {
+    let shift = ${Math.log2(AVBOIT_VIRTUAL_SLICES_MAX)}u;
+    let base = ((word * virtual_count) >> shift) * 32u;
+    var marks = vec2u(0u);
+    var rest = bits;
+    for (var run = 0u; run < 16u && rest != 0u; run++) {
+        let start = countTrailingZeros(rest);
+        let free_bits = ~rest & (0xFFFFFFFFu << start);
+        let end = select(countTrailingZeros(free_bits), 32u, free_bits == 0u);
+        rest = select(rest & (0xFFFFFFFFu << end), 0u, end == 32u);
+        let first = ((word * 32u + start) * virtual_count) >> shift;
+        let last = (((word * 32u + end) * virtual_count + ${AVBOIT_VIRTUAL_SLICES_MAX - 1}u) >> shift) - 1u;
+        let lo = i32(first - base);
+        let hi = i32(last - base);
+        marks |= vec2u(avboit_occupancy_word_mask(0u, lo, hi), avboit_occupancy_word_mask(1u, lo, hi));
+    }
+    return marks;
+}
+    `,
+    [chunk_avboit_occupancy_word_mask]
+);

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_step_count.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Virtual slice count of step `step` (1 to `steps - 1`) between the octave `octave` and the one above
+ * it: `2 octave · 2^(-step / steps)`, rounded — finer for a smaller `step`, never reaching either
+ * octave.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp_step_count: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_warp_step_count.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_step_count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_warp_step_count.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_step_count.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,2CAFU,SAAS,CASjB;0BAhBwB,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_warp_step_count.js

@@ -0,0 +1,17 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * Virtual slice count of step `step` (1 to `steps - 1`) between the octave `octave` and the one above
+ * it: `2 octave · 2^(-step / steps)`, rounded — finer for a smaller `step`, never reaching either
+ * octave.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_warp_step_count = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_warp_step_count(octave: u32, steps: u32, step: u32) -> u32 {
+    return u32(round(f32(octave) * exp2(f32(steps - step) / f32(steps))));
+}
+    `
+);

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAwN7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IAtB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGU,sBAAsB,EAAzD,yBAAyB;IACA,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAiTlB;+BAx9B8B,qBAAqB;0CA9BV,uCAAuC"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAwN7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IAtB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGU,sBAAsB,EAAzD,yBAAyB;IACA,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAkTlB;+BA19B8B,qBAAqB;0CA9BV,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js

@@ -171,6 +171,7 @@ export function graph_avboit_build_warp({
         voxel_width: voxel_resolution[0],
         voxel_height: voxel_resolution[1],
         tint_from_base_color: avboit.transmission_tint_from_base_color ? 1 : 0,
+        steps_per_octave: avboit.warp_steps_per_octave,
         cluster_parameters,
     };
 
@@ -831,7 +832,8 @@ export function graph_rasterize_meshes_transparent_avboit({
     let background_color = color_texture;
     for (const channel of preparers) {
         const prepared = channel.avboit_prepare({ graph, view_ctx, camera: gr_camera, color_texture,
-            depth_texture, normal_texture, hzb_texture: gr_hzb, environment_texture });
+            depth_texture, normal_texture, hzb_texture: gr_hzb, environment_texture, light_cluster_parameters,
+            light_cluster_lookup, light_cluster_data, shadowmap_atlas, indirect_lighting_mode });
         if (prepared?.background_color !== undefined) {
             assert.isNonNegativeInteger(prepared.background_color, 'prepared.background_color');
             background_color = prepared.background_color;

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_build_warp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_build_warp.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_build_warp.js"],"names":[],"mappings":"AAWA;;GAEG;AACH,6DAUqC;AA0GrC,qDAIG;6BApI0B,sCAAsC;8BAErC,kCAAkC"}
+{"version":3,"file":"shader_avboit_build_warp.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_build_warp.js"],"names":[],"mappings":"AAcA;;GAEG;AACH,6DAYqC;AAwMrC,qDAIG;6BAtO0B,sCAAsC;8BAErC,kCAAkC"}

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_build_warp.js

@@ -1,3 +1,4 @@
+import { WebGPUExtensionType } from "../../../../descriptor/WebGPUExtensionType.js";
 import { u32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
@@ -6,8 +7,10 @@ import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { AVBOIT_OCCUPANCY_WORDS, AVBOIT_VIRTUAL_SLICES_MAX } from "./AVBOIT_CONSTANTS.js";
 import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
-import { chunk_avboit_dilate_word } from "./chunk_avboit_dilate_word.js";
-import { chunk_avboit_fold_pairs } from "./chunk_avboit_fold_pairs.js";
+import { chunk_avboit_warp_level_word } from "./chunk_avboit_warp_level_word.js";
+import { chunk_avboit_warp_lut_entry } from "./chunk_avboit_warp_lut_entry.js";
+import { chunk_avboit_warp_marks } from "./chunk_avboit_warp_marks.js";
+import { chunk_avboit_warp_step_count } from "./chunk_avboit_warp_step_count.js";
 
 /**
  * Per-frame inputs of the warp build, all of which land in the warp header.
@@ -20,6 +23,8 @@ export const AVBOIT_BUILD_WARP_SETTINGS_STRUCT = WebGPUStruct.from({
     voxel_height: u32,
     /** AVBOITSettings.transmission_tint_from_base_color as 0 / 1, copied into the header */
     tint_from_base_color: u32,
+    /** AVBOITSettings.warp_steps_per_octave: virtual resolutions tried per octave, 1 for octaves alone */
+    steps_per_octave: u32,
     /** the depth curve, see avboit_build_depth_curve */
     cluster_parameters: vec3f,
 }, "AVBOITBuildWarpSettings").pack();
@@ -32,102 +37,196 @@ resources.createGroup()
     .addStorageBuffer("warp", AVBOIT_WARP_STRUCT, true)
 ;
 
+/**
+ * Invocations of the warp build: one per occupancy word.
+ * @type {number}
+ */
+const WARP_THREADS = AVBOIT_OCCUPANCY_WORDS;
+
 /**
  * AVBOIT warp build: turns the finest-level occupancy bits into the depth-warp LUT (plan §3.4).
  *
- * One invocation does the whole thing. Per level: dilate by one slice each side at that level,
- * count; if the count fits the physical budget, or the level is already down at the physical count,
- * stop — otherwise halve the *undilated* bits by OR-ing adjacent pairs and go again. Dilation is
- * applied fresh at each level rather than once at the finest, because a one-slice margin at 1024
- * slices is a quarter of a slice at 256 and rounds away; the margin is what keeps a fragment on the
- * edge of a meshlet's bounds from linear-splatting into a neighbouring run.
+ * Per octave: dilate by one slice each side at that level, count; if the count fits the physical
+ * budget, or the level is already down at the physical count, stop — otherwise halve and go again.
+ * Each level is marked afresh from the finest bits ({@link chunk_avboit_warp_marks}), so halving is not
+ * a fold of the level above but the same rule every resolution uses: a slice is occupied when a finest
+ * slice it overlaps is.
+ *
+ * **Steps between octaves** (`steps_per_octave > 1`). Halving lands the occupied count anywhere from
+ * about half the budget to all of it, so up to half the precision the budget allows goes unused. Between
+ * the octave that fits and the one above it that did not, the build tries
+ * `2 L · 2^(-i / steps)` virtual slices, finest first, and takes the first that fits. Those do not nest
+ * in the finest slices; the overlap rule is conservative for them, and consumers take any virtual count
+ * — the coordinate is the finest one scaled by `V / V_max` — so nothing past this shader changes.
  *
  * The LUT is then an exclusive prefix count of the dilated bits, with the bit itself in the low
  * position — see `AVBOIT_WARP_STRUCT`.
  *
- * Single-lane by design, not as a fallback: 32 words and at most three halvings is a few thousand
- * bit operations, and staying single-lane is what lets the WGSL emulator run this shader as-is.
+ * One workgroup, an invocation per occupancy word, each holding its finest word for the whole build.
+ * A resolution tried is every invocation marking the virtual slices its runs touch — two words at most,
+ * OR-ed into workgroup memory, so all of them work at every resolution — then every word of that
+ * resolution dilated by its own invocation and a subgroup reduction of their counts. The LUT is a
+ * subgroup scan of the chosen words' counts and `V_max / WARP_THREADS` coalesced writes per invocation. Every decision is made on a count read
+ * back through `workgroupUniformLoad`, so the workgroup takes the same path through the loops. The
+ * emulator cannot run a workgroup that cooperates through barriers, so the pure parts are chunks with
+ * their own specs and the whole is verified on a device (AVBOIT ledger entry 28).
  */
 const body = CodeChunk.from(
     //language=WGSL
     `
-const AVBOIT_OCCUPANCY_WORDS: u32 = ${AVBOIT_OCCUPANCY_WORDS}u;
-
-@compute @workgroup_size(1)
-fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
-
-    if (global_id.x != 0u) {
-        return;
+const AVBOIT_VIRTUAL_SLICES_MAX_U: u32 = ${AVBOIT_VIRTUAL_SLICES_MAX}u;
+const AVBOIT_WARP_THREADS: u32 = ${WARP_THREADS}u;
+const AVBOIT_WARP_SLICES_SHIFT: u32 = ${Math.log2(AVBOIT_VIRTUAL_SLICES_MAX)}u;
+// halvings from the finest resolution to a single slice, the most the octave loop can take
+const AVBOIT_WARP_OCTAVES: u32 = ${Math.log2(AVBOIT_VIRTUAL_SLICES_MAX) + 1}u;
+// LUT entries each invocation writes before the closing one
+const AVBOIT_WARP_LUT_ROUNDS: u32 = ${AVBOIT_VIRTUAL_SLICES_MAX / WARP_THREADS}u;
+const AVBOIT_WARP_MIN_SUBGROUP_SIZE: u32 = 4u;
+
+// the virtual slices the finest runs touch, undilated; alternate tries use alternate halves, each try
+// zeroing the half the next will mark
+var<workgroup> wg_marked: array<array<atomic<u32>, AVBOIT_WARP_THREADS>, 2>;
+// [0]: the octave's words, [1]: the step being tried; every word of the workgroup, 0 past the resolution
+var<workgroup> wg_words: array<array<u32, AVBOIT_WARP_THREADS>, 2>;
+// occupied slices in the chosen words before each one
+var<workgroup> wg_words_below: array<u32, AVBOIT_WARP_THREADS>;
+var<workgroup> wg_partials: array<u32, AVBOIT_WARP_THREADS / AVBOIT_WARP_MIN_SUBGROUP_SIZE>;
+var<workgroup> wg_broadcast: u32;
+
+// \`value\` summed over the workgroup, the same for every invocation
+fn avboit_warp_sum(value: u32, thread: u32, lane: u32, lane_count: u32) -> u32 {
+    let subgroup_total = subgroupAdd(value);
+    if (lane == 0u) {
+        wg_partials[thread / lane_count] = subgroup_total;
     }
+    workgroupBarrier();
+    if (thread == 0u) {
+        var total = 0u;
+        for (var s = 0u; s < AVBOIT_WARP_THREADS / lane_count; s++) {
+            total += wg_partials[s];
+        }
+        wg_broadcast = total;
+    }
+    return workgroupUniformLoad(&wg_broadcast);
+}
 
-    let physical = settings.physical_count;
-
-    var words: array<u32, AVBOIT_OCCUPANCY_WORDS>;
-    var dilated: array<u32, AVBOIT_OCCUPANCY_WORDS>;
+// \`value\` summed over the invocations before this one
+fn avboit_warp_sum_below(value: u32, thread: u32, lane: u32, lane_count: u32) -> u32 {
+    let subgroup = thread / lane_count;
+    let below_in_subgroup = subgroupExclusiveAdd(value);
+    let subgroup_total = subgroupAdd(value);
+    if (lane == 0u) {
+        wg_partials[subgroup] = subgroup_total;
+    }
+    workgroupBarrier();
+    var below = below_in_subgroup;
+    for (var s = 0u; s < subgroup; s++) {
+        below += wg_partials[s];
+    }
+    return below;
+}
 
-    for (var w = 0u; w < AVBOIT_OCCUPANCY_WORDS; w++) {
-        words[w] = occupancy[w];
-        dilated[w] = 0u;
+// every word of the slicing into \`virtual_count\` virtual slices into wg_words[slot]; its occupied count
+fn avboit_warp_try(virtual_count: u32, slot: u32, parity: u32, finest: u32, thread: u32, lane: u32, lane_count: u32) -> u32 {
+    let marks = avboit_warp_marks(finest, thread, virtual_count);
+    // a second word is marked only where that word holds a slice below virtual_count, so it exists
+    let first_word = (thread * virtual_count) >> AVBOIT_WARP_SLICES_SHIFT;
+    if (marks.x != 0u) {
+        atomicOr(&wg_marked[parity][first_word], marks.x);
     }
+    if (marks.y != 0u) {
+        atomicOr(&wg_marked[parity][first_word + 1u], marks.y);
+    }
+    workgroupBarrier();
 
-    var level_count = ${AVBOIT_VIRTUAL_SLICES_MAX}u;
-    var word_count = AVBOIT_OCCUPANCY_WORDS;
+    let marked_below = select(0u, atomicLoad(&wg_marked[parity][max(thread, 1u) - 1u]), thread > 0u);
+    let marked = atomicLoad(&wg_marked[parity][thread]);
+    let marked_above = select(0u, atomicLoad(&wg_marked[parity][min(thread + 1u, AVBOIT_WARP_THREADS - 1u)]), thread + 1u < AVBOIT_WARP_THREADS);
+    let word = avboit_warp_level_word(marked_below, marked, marked_above, thread, virtual_count);
+    wg_words[slot][thread] = word;
+    atomicStore(&wg_marked[1u - parity][thread], 0u);
 
-    loop {
-        var occupied = 0u;
+    return avboit_warp_sum(countOneBits(word), thread, lane, lane_count);
+}
 
-        for (var w = 0u; w < word_count; w++) {
-            var below = 0u;
-            if (w > 0u) {
-                below = words[w - 1u] >> 31u;
-            }
-            var above = 0u;
-            if (w + 1u < word_count) {
-                above = (words[w + 1u] & 1u) << 31u;
-            }
-            let d = avboit_dilate_word(words[w], below, above);
-            dilated[w] = d;
-            occupied += countOneBits(d);
-        }
+@compute @workgroup_size(AVBOIT_WARP_THREADS)
+fn main(
+    @builtin(local_invocation_index) thread: u32,
+    @builtin(subgroup_invocation_id) lane: u32,
+    @builtin(subgroup_size) lane_count: u32,
+) {
+    let physical = settings.physical_count;
+    let finest = occupancy[thread];
+    var tries = 0u;
+
+    var level = AVBOIT_VIRTUAL_SLICES_MAX_U;
 
-        if (occupied <= physical || level_count <= physical) {
+    for (var octave = 0u; octave < AVBOIT_WARP_OCTAVES; octave++) {
+        let occupied = avboit_warp_try(level, 0u, tries & 1u, finest, thread, lane, lane_count);
+        tries++;
+        if (occupied <= physical || level <= physical) {
             break;
         }
+        level = level / 2u;
+    }
 
-        // halve: two old words become one new word
-        let half_words = word_count / 2u;
-        for (var nw = 0u; nw < half_words; nw++) {
-            words[nw] = avboit_fold_pairs(words[2u * nw]) | (avboit_fold_pairs(words[2u * nw + 1u]) << 16u);
+    // between the octave that fits and the one above it, the finest step that fits as well
+    var slot = 0u;
+    let steps = max(settings.steps_per_octave, 1u);
+
+    if (steps > 1u && level < AVBOIT_VIRTUAL_SLICES_MAX_U) {
+        let octave = level;
+
+        for (var i = 1u; i < steps; i++) {
+            let candidate = avboit_warp_step_count(octave, steps, i);
+            let occupied = avboit_warp_try(candidate, 1u, tries & 1u, finest, thread, lane, lane_count);
+            tries++;
+            if (occupied <= physical) {
+                level = candidate;
+                slot = 1u;
+                break;
+            }
         }
+    }
 
-        word_count = half_words;
-        level_count = level_count / 2u;
+    // the chosen words were written behind the barriers of the count that chose them
+    let count = countOneBits(wg_words[slot][thread]);
+    let below = avboit_warp_sum_below(count, thread, lane, lane_count);
+    wg_words_below[thread] = below;
+    workgroupBarrier();
+
+    for (var i = 0u; i < AVBOIT_WARP_LUT_ROUNDS; i++) {
+        let v = i * AVBOIT_WARP_THREADS + thread;
+        if (v < level) {
+            let w = v >> 5u;
+            warp.lut[v] = avboit_warp_lut_entry(wg_words[slot][w], v & 31u, wg_words_below[w]);
+        }
     }
 
-    warp.virtual_count = level_count;
-    warp.physical_count = physical;
-    warp.voxel_width = settings.voxel_width;
-    warp.voxel_height = settings.voxel_height;
-    warp.tint_from_base_color = settings.tint_from_base_color;
-    warp.cluster_parameters = settings.cluster_parameters;
+    if (thread == AVBOIT_WARP_THREADS - 1u) {
+        let total = below + count;
 
-    var prefix = 0u;
+        warp.lut[level] = total << 1u;
+        warp.occupied_count = total;
 
-    for (var v = 0u; v < level_count; v++) {
-        let bit = (dilated[v >> 5u] >> (v & 31u)) & 1u;
-        warp.lut[v] = (prefix << 1u) | bit;
-        prefix += bit;
+        warp.virtual_count = level;
+        warp.physical_count = physical;
+        warp.voxel_width = settings.voxel_width;
+        warp.voxel_height = settings.voxel_height;
+        warp.tint_from_base_color = settings.tint_from_base_color;
+        warp.cluster_parameters = settings.cluster_parameters;
     }
-
-    warp.lut[level_count] = prefix << 1u;
-    warp.occupied_count = prefix;
 }
     `, [
-        chunk_avboit_dilate_word,
-        chunk_avboit_fold_pairs,
+        chunk_avboit_warp_level_word,
+        chunk_avboit_warp_lut_entry,
+        chunk_avboit_warp_marks,
+        chunk_avboit_warp_step_count,
     ]
 );
 
+body.addExtension(WebGPUExtensionType.Subgroups);
+
 export const shader_avboit_build_warp = ComputeShader.from({
     label: 'AVBOIT / build warp',
     resources,