@woosh/meep-engine 3.37.0 → 3.39.0

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

@@ -0,0 +1,4 @@
+/** A covering RGB-throughput surface; the existing particle/scalar entry point stays unchanged. */
+export const chunk_avboit_rgb_contribution: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_rgb_contribution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_rgb_contribution.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_rgb_contribution.js"],"names":[],"mappings":"AAGA,mGAAmG;AACnG,sDAc8C;0BAlBpB,uCAAuC"}

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

@@ -0,0 +1,19 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_avboit_premultiplied_contribution } from "./chunk_avboit_premultiplied_contribution.js";
+
+/** A covering RGB-throughput surface; the existing particle/scalar entry point stays unchanged. */
+export const chunk_avboit_rgb_contribution = CodeChunk.from(/* language=WGSL */ `
+fn avboit_rgb_contribution(
+    radiance: vec3<f32>, self_transmittance: vec3<f32>,
+    front_transmittance: vec3<f32>, fog: vec4<f32>,
+) -> AVBOITContribution {
+    let t = clamp(self_transmittance, vec3<f32>(1e-6), vec3<f32>(1.0));
+    let loss = vec3<f32>(1.0) - t;
+    var out: AVBOITContribution;
+    out.color = vec4<f32>((radiance * fog.w + loss * fog.xyz) * front_transmittance, 0.0);
+    out.norm = vec4<f32>(loss * front_transmittance, 0.0);
+    out.extinction = vec4<f32>(-log(t), 0.0);
+    out.emission = vec4<f32>(0.0);
+    return out;
+}
+`, [chunk_avboit_premultiplied_contribution]);

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_splat_slice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_avboit_splat_slice.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAuCjB;0BAzDwB,uCAAuC"}
+{"version":3,"file":"chunk_avboit_splat_slice.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAyCjB;0BA3DwB,uCAAuC"}

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

@@ -21,12 +21,10 @@ import { chunk_avboit_pack_counts } from "./chunk_avboit_pack_counts.js";
 export const chunk_avboit_splat_slice = CodeChunk.from(
     //language=WGSL
     `
-fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec2<u32>) {
+fn avboit_splat_counts(column: u32, slice: i32, counts: vec3<u32>, texel: vec2<u32>) {
     let physical = i32(warp.physical_count);
     let s = clamp(slice, 0, physical - 1);
 
-    let counts = avboit_extinction_to_counts(extinction);
-
     if (all(counts == vec3<u32>(0u))) {
         return;
     }
@@ -50,6 +48,10 @@ fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec
         }
     }
 }
+
+fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec2<u32>) {
+    avboit_splat_counts(column, slice, avboit_extinction_to_counts(extinction), texel);
+}
     `, [
         chunk_avboit_extinction_to_counts,
         chunk_avboit_overflows,

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

@@ -0,0 +1,4 @@
+/** Partition already quantized counts. Rounding two fractional extinctions can erase both. */
+export const chunk_avboit_split_counts: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_split_counts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_split_counts.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_split_counts.js"],"names":[],"mappings":"AAEA,8FAA8F;AAC9F,kDAIG;0BAPuB,uCAAuC"}

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

@@ -0,0 +1,8 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/** Partition already quantized counts. Rounding two fractional extinctions can erase both. */
+export const chunk_avboit_split_counts = CodeChunk.from(/* language=WGSL */ `
+fn avboit_split_counts(counts: vec3<u32>, fraction: f32) -> vec3<u32> {
+    return min(counts, vec3<u32>(vec3<f32>(counts) * clamp(fraction, 0.0, 1.0) + 0.5));
+}
+`);

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

@@ -164,7 +164,7 @@ export function avboit_create_accumulators(pass: FramePassBuilder, resolution: A
  *   sources of transparent fragments; the MBOIT orchestrator ignores them
  * @returns {number} resource ID of the composited color texture
  */
-export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, indirect_lighting_mode, avboit, side_channels, }: {
+export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, normal_texture, hzb_texture, environment_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, indirect_lighting_mode, avboit, side_channels, }: {
     graph: FrameGraph;
     buckets: number;
     view_ctx: GPUViewContext;

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,CA8RlB;+BAr8B8B,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,
     };
 
@@ -724,6 +725,9 @@ export function graph_rasterize_meshes_transparent_avboit({
                                                               viewport,
                                                               depth_texture,
                                                               color_texture,
+                                                              normal_texture,
+                                                              hzb_texture,
+                                                              environment_texture,
                                                               limits,
                                                               light_cluster_parameters,
                                                               light_cluster_lookup,
@@ -809,7 +813,7 @@ export function graph_rasterize_meshes_transparent_avboit({
     const primitive_front = construct_primitive_state(ShadeDrawMode.Triangles, ShadeDrawSide.Front);
     const primitive_double = construct_primitive_state(ShadeDrawMode.Triangles, ShadeDrawSide.Double);
 
-    const gr_hzb = graph_import_texture(graph, view_ctx.hierarchical_z_buffer.texture);
+    const gr_hzb = hzb_texture ?? graph_import_texture(graph, view_ctx.hierarchical_z_buffer.texture);
     const gr_camera = graph_import_buffer(graph, view_ctx.camera.buffer.buffer);
 
     const voxel_resolution = avboit_voxel_resolution(view_ctx.resolution);
@@ -819,6 +823,23 @@ export function graph_rasterize_meshes_transparent_avboit({
     const camera = view_ctx.camera.camera;
     const cluster_parameters = avboit_build_depth_curve(camera.near, camera.far);
 
+    // A background producer transports only immutable opaque radiance. Reject ambiguity before
+    // recording any preparation rather than letting channel registration order choose a winner.
+    const preparers = side_channels.filter(channel => typeof channel.avboit_prepare === "function");
+    if (preparers.length > 1) {
+        throw new Error("AVBOIT supports one refractive background producer per view");
+    }
+    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, 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;
+        }
+    }
+
     // Draw artifacts (shared with MBOIT)
     // ======
 
@@ -992,7 +1013,7 @@ export function graph_rasterize_meshes_transparent_avboit({
         shader: shader_avboit_resolve,
         output_resolution: view_ctx.resolution,
         inputs: {
-            tScene: color_texture,
+            tScene: background_color,
             tColor: accumulators.color,
             tNorm: accumulators.norm,
             tExtinction: accumulators.extinction,

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"}