@woosh/meep-engine 3.36.0 → 3.38.0

package/src/shade/renderer/light/environment/shader_project_environment_sh.js

@@ -1,3 +1,4 @@
+import { WebGPUExtensionType } from "../../../descriptor/WebGPUExtensionType.js";
 import { chunk_get_ibl_irradiance } from "../../deferred/indirect/chunk_get_ibl_irradiance.js";
 import { PI_DECLARATION } from "../../shader/chunk/math/PI_DECLARATION.js";
 import { chunk_sphere_fibonacci_point } from "../../shader/chunk/geometry/sphere/chunk_sphere_fibonacci_point.js";
@@ -21,12 +22,12 @@ export const ENVIRONMENT_SH_TYPE = WebGPUArray.from(vec4f, 4);
 
 /**
  * Directions the projection samples, spread evenly over the sphere (`sphere_fibonacci_point`).
- * The field is the environment at the roughness diffuse reads it at, so this is far more than its
- * two bands can hold, and it costs nothing that recurs: the pass runs when the environment changes.
+ * The field is already prefiltered at the roughness diffuse reads it at; these samples project
+ * that smooth field into two bands. The pass runs only when the environment changes.
  *
  * @type {number}
  */
-export const ENVIRONMENT_SH_SAMPLE_COUNT = 1024;
+export const ENVIRONMENT_SH_SAMPLE_COUNT = 256;
 
 const resources = new ShaderResourceSetDescriptor();
 
@@ -39,28 +40,56 @@ const body = CodeChunk.from(
     //language=WGSL
     `
 const SAMPLE_COUNT : u32 = ${ENVIRONMENT_SH_SAMPLE_COUNT}u;
+// The minimum subgroup size is four, so this holds every subgroup's partial sum.
+const MAX_SUBGROUP_PARTIALS : u32 = SAMPLE_COUNT / 4u;
+
+var<workgroup> wg_partial_count: atomic<u32>;
+var<workgroup> wg_sh_0: array<vec3<f32>, MAX_SUBGROUP_PARTIALS>;
+var<workgroup> wg_sh_1: array<vec3<f32>, MAX_SUBGROUP_PARTIALS>;
+var<workgroup> wg_sh_2: array<vec3<f32>, MAX_SUBGROUP_PARTIALS>;
+var<workgroup> wg_sh_3: array<vec3<f32>, MAX_SUBGROUP_PARTIALS>;
+
+// One workgroup projects the sphere, with one invocation per sample.
+@compute @workgroup_size(${ENVIRONMENT_SH_SAMPLE_COUNT})
+fn main(@builtin(local_invocation_index) thread_index: u32) {
+    let direction = sphere_fibonacci_point(f32(thread_index), f32(SAMPLE_COUNT));
+
+    // exactly what the forward mesh path takes as a surface's diffuse irradiance under IBL
+    let irradiance = get_ibl_irradiance(direction);
+    let basis = sh2_basis_at(direction);
+
+    let sh_0_partial = subgroupAdd(irradiance * basis[0]);
+    let sh_1_partial = subgroupAdd(irradiance * basis[1]);
+    let sh_2_partial = subgroupAdd(irradiance * basis[2]);
+    let sh_3_partial = subgroupAdd(irradiance * basis[3]);
+
+    // Workgroup variables start zeroed. One elected lane claims a distinct slot per subgroup;
+    // local invocation indices need not map to subgroups in contiguous blocks.
+    if (subgroupElect()) {
+        let slot = atomicAdd(&wg_partial_count, 1u);
+        wg_sh_0[slot] = sh_0_partial;
+        wg_sh_1[slot] = sh_1_partial;
+        wg_sh_2[slot] = sh_2_partial;
+        wg_sh_3[slot] = sh_3_partial;
+    }
+
+    workgroupBarrier();
+
+    if (thread_index != 0u) {
+        return;
+    }
 
-// One invocation: the projection is 1024 reads that happen when the environment changes and never
-// otherwise, and a single lane needs no reduction and runs whole on the emulator.
-@compute @workgroup_size(1)
-fn main() {
     var sh_0 = vec3<f32>(0.0);
     var sh_1 = vec3<f32>(0.0);
     var sh_2 = vec3<f32>(0.0);
     var sh_3 = vec3<f32>(0.0);
+    let partial_count = atomicLoad(&wg_partial_count);
 
-    for (var i = 0u; i < SAMPLE_COUNT; i++) {
-        let direction = sphere_fibonacci_point(f32(i), f32(SAMPLE_COUNT));
-
-        // exactly what the forward mesh path takes as a surface's diffuse irradiance under IBL
-        let irradiance = get_ibl_irradiance(direction);
-
-        let basis = sh2_basis_at(direction);
-
-        sh_0 += irradiance * basis[0];
-        sh_1 += irradiance * basis[1];
-        sh_2 += irradiance * basis[2];
-        sh_3 += irradiance * basis[3];
+    for (var i = 0u; i < partial_count; i++) {
+        sh_0 += wg_sh_0[i];
+        sh_1 += wg_sh_1[i];
+        sh_2 += wg_sh_2[i];
+        sh_3 += wg_sh_3[i];
     }
 
     // each sample stands for an equal share of the sphere
@@ -83,6 +112,8 @@ fn main() {
     PI_DECLARATION,
 ]);
 
+body.addExtension(WebGPUExtensionType.Subgroups);
+
 /**
  * The environment as RGB SH2 of radiance ({@link ENVIRONMENT_SH_TYPE}): the form the renderer's other
  * indirect lighting — Brick4, the light probe volume — already hands over, so the froxel GI stage

package/src/shade/renderer/particles/DESIGN.md

@@ -353,7 +353,7 @@ finished appending to the alive list:
   `particle_billboard_radius`, the largest offset `particle_billboard_offset` can produce for that
   size, velocity and projection, over every corner, every roll and any camera. The box has to hold
   the *quads*, not the centres, and it has to be camera-independent, because it is read on a later
-  frame. The merge is `aabb_atomic_min_f32` / `aabb_atomic_max_f32`, the same CAS-spin the
+  frame. The merge is `atomic_min_f32_storage` / `atomic_max_f32_storage`, the same CAS-spin the
   skinned-mesh bounds refresh uses; both load first and return without a CAS once the box holds the
   contribution, so what survives is load traffic, not exchanges. Dispatched indirectly from
   `sim_dispatch_args`, the args the coherence reset wrote from the GPU's own alive count.

package/src/shade/renderer/particles/bounds/chunk_particle_bounds.d.ts

@@ -13,7 +13,7 @@
  *
  * ## Why f32 in the buffer, and not an order-preserving encoding
  *
- * `aabb_atomic_min_f32` / `aabb_atomic_max_f32` are the engine's, shared with the skinned-mesh
+ * `atomic_min_f32_storage` / `atomic_max_f32_storage` are the engine's, shared with the skinned-mesh
  * bounds refresh, and they CAS-spin over the plain float so the words are readable as floats at
  * every moment of the frame. The sign-flip encoding that would let `atomicMin` do it in one
  * instruction leaves the buffer in a form only a decoder understands, and the publish pass reads

package/src/shade/renderer/particles/bounds/chunk_particle_bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/bounds/chunk_particle_bounds.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,0CAFU,SAAS,CAwEyC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,8CAFU,SAAS,CA4CsC;0BApL/B,oCAAoC"}
+{"version":3,"file":"chunk_particle_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/bounds/chunk_particle_bounds.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,0CAFU,SAAS,CAwE8E;AAEjG;;;;;;;;;;;;;;;;GAgBG;AACH,8CAFU,SAAS,CA4CsC;0BArL/B,oCAAoC"}

package/src/shade/renderer/particles/bounds/chunk_particle_bounds.js

@@ -1,5 +1,6 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_aabb_atomic_f32 } from "../../animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js";
+import { chunk_atomic_min_f32_storage } from "../../shader/chunk/atomic/chunk_atomic_min_f32_storage.js";
+import { chunk_atomic_max_f32_storage } from "../../shader/chunk/atomic/chunk_atomic_max_f32_storage.js";
 import { AABB3_STRUCT } from "../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
 import {
     PARTICLE_BOUNDS_BASE,
@@ -26,7 +27,7 @@ import { chunk_particle_render_math } from "../shaders/chunk_particle_render_mat
  *
  * ## Why f32 in the buffer, and not an order-preserving encoding
  *
- * `aabb_atomic_min_f32` / `aabb_atomic_max_f32` are the engine's, shared with the skinned-mesh
+ * `atomic_min_f32_storage` / `atomic_max_f32_storage` are the engine's, shared with the skinned-mesh
  * bounds refresh, and they CAS-spin over the plain float so the words are readable as floats at
  * every moment of the frame. The sign-flip encoding that would let `atomicMin` do it in one
  * instruction leaves the buffer in a form only a decoder understands, and the publish pass reads
@@ -71,12 +72,12 @@ fn particle_bounds_contribute(row : u32, center : vec3<f32>, radius : f32) {
     let lo = center - vec3<f32>(radius);
     let hi = center + vec3<f32>(radius);
 
-    aabb_atomic_min_f32(&counters[base + 0u], lo.x);
-    aabb_atomic_min_f32(&counters[base + 1u], lo.y);
-    aabb_atomic_min_f32(&counters[base + 2u], lo.z);
-    aabb_atomic_max_f32(&counters[base + 3u], hi.x);
-    aabb_atomic_max_f32(&counters[base + 4u], hi.y);
-    aabb_atomic_max_f32(&counters[base + 5u], hi.z);
+    atomic_min_f32_storage(&counters[base + 0u], lo.x);
+    atomic_min_f32_storage(&counters[base + 1u], lo.y);
+    atomic_min_f32_storage(&counters[base + 2u], lo.z);
+    atomic_max_f32_storage(&counters[base + 3u], hi.x);
+    atomic_max_f32_storage(&counters[base + 4u], hi.y);
+    atomic_max_f32_storage(&counters[base + 5u], hi.z);
 }
 
 // What the frame accumulated for one row. Empty (see \`particle_bounds_is_empty\`) when nothing
@@ -117,7 +118,7 @@ fn particle_bounds_reset(row : u32) {
 fn particle_bounds_is_empty(box : ${AABB3_STRUCT.wgsl_ref}) -> bool {
     return any(box.min > box.max);
 }
-`, [chunk_aabb_atomic_f32, AABB3_STRUCT.declaration_chunk]);
+`, [chunk_atomic_min_f32_storage, chunk_atomic_max_f32_storage, AABB3_STRUCT.declaration_chunk]);
 
 /**
  * One live particle's contribution to its emitter's box: where its quad is, and how far the quad

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

@@ -34,6 +34,23 @@
  * channel without the method is always asked.
  */
 export type AVBOITSideChannel = {
+    /**
+     * Optional optics preparation before occupancy; at most one producer per view. Inputs are
+     * immutable opaque resources. The returned background is read by the one shared resolve.
+     * Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
+     */
+    avboit_prepare?: (args: {
+        graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext;
+        camera: number;
+        color_texture: number;
+        depth_texture: number;
+        normal_texture: number;
+        hzb_texture: number;
+        environment_texture: number;
+    }) => {
+        background_color?: number;
+    };
     /**
      * add the channel's slices to the occupancy bits; returns the bits'
      * handle after the write. `cluster_parameters` is the frame's depth curve (`avboit_build_depth_curve`).

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

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoCc,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAM9D,MAAM,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAC,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAI1E,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAM9D,MAAM,OAAO"}

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

@@ -34,6 +34,13 @@
  * channel without the method is always asked.
  *
  * @typedef {object} AVBOITSideChannel
+ * @property {(args: {graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
+ *     view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext, camera: number,
+ *     color_texture: number, depth_texture: number, normal_texture: number,
+ *     hzb_texture: number, environment_texture: number}) => {background_color?: number}} [avboit_prepare]
+ *     Optional optics preparation before occupancy; at most one producer per view. Inputs are
+ *     immutable opaque resources. The returned background is read by the one shared resolve.
+ *     Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
  * @property {(args: {
  *     graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
  *     camera: number,

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

@@ -0,0 +1,4 @@
+/** Stable lost throughput at tiny extinction; a fixed norm cutoff drops bright faint surfaces. */
+export const chunk_avboit_renormalization: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_renormalization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_renormalization.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_renormalization.js"],"names":[],"mappings":"AAEA,kGAAkG;AAClG,qDAOG;0BAVuB,uCAAuC"}

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

@@ -0,0 +1,11 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/** Stable lost throughput at tiny extinction; a fixed norm cutoff drops bright faint surfaces. */
+export const chunk_avboit_renormalization = CodeChunk.from(/* language=WGSL */ `
+fn avboit_renormalization(extinction: vec3f, norm: vec3f) -> vec3f {
+    let x = max(extinction, vec3f(0.0));
+    let small_loss = x * (1.0 - 0.5 * x + x * x / 6.0);
+    let loss = select(vec3f(1.0) - exp(-x), small_loss, x < vec3f(0.001));
+    return select(vec3f(0.0), min(loss / max(norm, vec3f(1e-20)), vec3f(65504.0)), norm > vec3f(0.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_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/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,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"}

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

@@ -724,6 +724,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 +812,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 +822,22 @@ 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 });
+        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 +1011,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_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AA4EA,gDAUE;4BApF0B,gCAAgC"}
+{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AAwEA,gDAUE;4BAhF0B,gCAAgC"}

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

@@ -3,6 +3,7 @@ import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { chunk_avboit_renormalization } from "./chunk_avboit_renormalization.js";
 
 const resources = new ShaderResourceSetDescriptor();
 resources.createGroup()
@@ -19,7 +20,7 @@ resources.createGroup()
  *
  * ```
  * T_total = exp(-Σ extinction)
- * norm    = Σ norm > ε ? (1 - T_total) / Σ norm : 0
+ * norm    = Σ norm > 0 ? stable_lost_throughput(Σ extinction) / Σ norm : 0
  * out     = scene × T_total + Σ color × norm + Σ emission
  * ```
  *
@@ -58,19 +59,14 @@ fn main(
     let total_transmittance = exp(-accum_extinction);
 
     // sum of (1 - T_self) * T at each fragment; zero where nothing transparent was drawn
-    let safe = accum_norm > vec3<f32>(1e-4);
-    let renormalization = select(
-        vec3<f32>(0.0),
-        (vec3<f32>(1.0) - total_transmittance) / max(accum_norm, vec3<f32>(1e-4)),
-        safe
-    );
+    let renormalization = avboit_renormalization(accum_extinction, accum_norm);
 
     let transparent = accum_color * renormalization;
 
     return vec4<f32>(scene.rgb * total_transmittance + transparent + accum_emission, scene.a);
 }
     `, [
-        chunk_is_nan
+        chunk_is_nan, chunk_avboit_renormalization
     ]
 )
 

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

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_extract_instance_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/shader_bvh_extract_instance_leaves.js"],"names":[],"mappings":"AAUA,4CAA6C;AAkH7C;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAFU,aAAa,CAMpB;8BA7I2B,4BAA4B"}
+{"version":3,"file":"shader_bvh_extract_instance_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/shader_bvh_extract_instance_leaves.js"],"names":[],"mappings":"AAWA,4CAA6C;AAmH7C;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAFU,aAAa,CAMpB;8BA9I2B,4BAA4B"}

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

@@ -1,7 +1,8 @@
 import { WebGPUExtensionType } from "../../descriptor/WebGPUExtensionType.js";
 import { atomic_u32, f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { chunk_aabb_atomic_f32 } from "../animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js";
+import { chunk_atomic_min_f32_storage } from "../shader/chunk/atomic/chunk_atomic_min_f32_storage.js";
+import { chunk_atomic_max_f32_storage } from "../shader/chunk/atomic/chunk_atomic_max_f32_storage.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
@@ -107,17 +108,18 @@ fn main(
             group_high = max(group_high, wg_high[s]);
         }
 
-        aabb_atomic_min_f32(&scene_bounds[0], group_low.x);
-        aabb_atomic_min_f32(&scene_bounds[1], group_low.y);
-        aabb_atomic_min_f32(&scene_bounds[2], group_low.z);
-        aabb_atomic_max_f32(&scene_bounds[3], group_high.x);
-        aabb_atomic_max_f32(&scene_bounds[4], group_high.y);
-        aabb_atomic_max_f32(&scene_bounds[5], group_high.z);
+        atomic_min_f32_storage(&scene_bounds[0], group_low.x);
+        atomic_min_f32_storage(&scene_bounds[1], group_low.y);
+        atomic_min_f32_storage(&scene_bounds[2], group_low.z);
+        atomic_max_f32_storage(&scene_bounds[3], group_high.x);
+        atomic_max_f32_storage(&scene_bounds[4], group_high.y);
+        atomic_max_f32_storage(&scene_bounds[5], group_high.z);
     }
 }
 `, [
     chunk_scene_database_access,
-    chunk_aabb_atomic_f32,
+    chunk_atomic_min_f32_storage,
+    chunk_atomic_max_f32_storage,
 ]);
 
 body.addExtension(WebGPUExtensionType.Subgroups);

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Atomic f32 addition over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Each compare-exchange attempt adds to the current float value and writes the sum
+ * as plain f32 bits. Failed or spurious exchanges retry from a fresh atomic load,
+ * so concurrent additions are not lost.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_add_f32_storage: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_atomic_add_f32_storage.d.ts.map

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_atomic_add_f32_storage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAehB;0BAxBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.js

@@ -0,0 +1,25 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Atomic f32 addition over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Each compare-exchange attempt adds to the current float value and writes the sum
+ * as plain f32 bits. Failed or spurious exchanges retry from a fresh atomic load,
+ * so concurrent additions are not lost.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_add_f32_storage = CodeChunk.from(
+    //language=WGSL
+    `
+fn atomic_add_f32_storage(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
+    loop {
+        let old_u = atomicLoad(cell);
+        let old_f = bitcast<f32>(old_u);
+        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(old_f + value));
+        if result.exchanged {
+            break;
+        }
+    }
+}
+`);

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Atomic f32 maximum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_max_f32_storage: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_atomic_max_f32_storage.d.ts.map

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_atomic_max_f32_storage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAkBhB;0BA3BuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.js

@@ -0,0 +1,28 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Atomic f32 maximum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_max_f32_storage = CodeChunk.from(
+    //language=WGSL
+    `
+fn atomic_max_f32_storage(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
+    loop {
+        let old_u = atomicLoad(cell);
+        let old_f = bitcast<f32>(old_u);
+        if value <= old_f {
+            break;
+        }
+        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(value));
+        if result.exchanged {
+            break;
+        }
+    }
+}
+`);

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Atomic f32 minimum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_min_f32_storage: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_atomic_min_f32_storage.d.ts.map

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_atomic_min_f32_storage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAkBhB;0BA3BuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.js

@@ -0,0 +1,28 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Atomic f32 minimum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_min_f32_storage = CodeChunk.from(
+    //language=WGSL
+    `
+fn atomic_min_f32_storage(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
+    loop {
+        let old_u = atomicLoad(cell);
+        let old_f = bitcast<f32>(old_u);
+        if value >= old_f {
+            break;
+        }
+        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(value));
+        if result.exchanged {
+            break;
+        }
+    }
+}
+`);