@woosh/meep-engine 3.38.0 → 3.39.0

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,

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2HD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAiBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAtuBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAoCf;IA/KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA8HD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAiBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAzuBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -248,7 +248,10 @@ export class GPUSceneContext {
 
         this.volumetric_light_map = new Brick4LightMap(device);
 
-        this.#volumetrics = new GPUSceneVolumetrics(device, scene.volumetrics);
+        this.#volumetrics = new GPUSceneVolumetrics(
+            this.#scene_database.get('participating_media_volumes'),
+            scene.volumetrics
+        );
 
         this.#animation_manager = new GPUAnimationManager(device, `GPUSceneContext[${this.id}]/Animation`, this);
     }

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wDAGG;sCAbmC,0CAA0C"}
+{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wDAOG;sCAlBmC,0CAA0C"}

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.js

@@ -1,6 +1,7 @@
 import { GPUDatabaseDefinition } from "../buffer/table/GPUDatabaseDefinition.js";
 import { MESH_INSTANCE_METADATA_STRUCT } from "./MESH_INSTANCE_METADATA_STRUCT.js";
 import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "../volumetrics/PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
 
 /**
  * Schema for the scene's GPU-resident records — meshes and the
@@ -11,6 +12,10 @@ import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
 export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
     meshes: MESH_INSTANCE_METADATA_STRUCT,
     transforms: NODE3D_STRUCT,
+    // the scene's fog, smoke and cloud volumes (SceneVolumetrics), written whole by
+    // GPUSceneVolumetrics whenever their version moves; read by the froxel volumetrics and by the
+    // ray passes through chunk_participating_media_volumes_iterate
+    participating_media_volumes: PARTICIPATING_MEDIA_VOLUME_STRUCT,
 });
 
 // A mesh's transform. A mesh row and its transforms row are the same row — the entity's, one on —

package/src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.d.ts

@@ -4,7 +4,18 @@
  */
 export const C_MIE_SCATTERING_DECLARATION: CodeChunk;
 /**
- * Mie absorption
+ * Mie extinction: scattering plus absorption. Hillaire's Earth authors this and the scattering,
+ * not the absorption -- 0.004440 and 0.003996 per km.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/SkyAtmosphereCommon.cpp#L40
+ */
+export const C_MIE_EXTINCTION_DECLARATION: CodeChunk;
+/**
+ * Mie absorption, derived the way Hillaire does: extinction less scattering, 0.444e-6 per metre,
+ * a tenth of the extinction. The shadertoy port wrote the 4.4 extinction here as the absorption,
+ * which put the extinction at 8.396e-6.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/Game.cpp#L707
  */
 export const C_MIE_ABSORPTION_DECLARATION: CodeChunk;
 import { CodeChunk } from "../../compiler/CodeChunk.js";

package/src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"C_MIE_SCATTERING_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qDAGE;AAEF;;GAEG;AACH,qDAGE;0BAjBwB,6BAA6B"}
+{"version":3,"file":"C_MIE_SCATTERING_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qDAGE;AAEF;;;;;GAKG;AACH,qDAGE;AAEF;;;;;;GAMG;AACH,qDAOE;0BApCwB,6BAA6B"}