@woosh/meep-engine 3.36.0 → 3.37.0

package/src/shade/renderer/animation/chunk_pose_accumulator.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_atomic_add_f32_storage } from "../shader/chunk/atomic/chunk_atomic_add_f32_storage.js";
 import {
     POSE_ACCUMULATOR_OFFSET_DIRTY,
     POSE_ACCUMULATOR_OFFSET_ROTATION,
@@ -20,9 +21,8 @@ import {
  * The importing shader binds:
  *   `var<storage, read_write> pose_accumulator: array<atomic<u32>>;`
  *
- * f32 atomic-add isn't native to WGSL. We implement it as a
- * `atomicCompareExchangeWeak` spin: load the current u32, reinterpret as
- * f32, add the contribution, reinterpret back, CAS. Contention is
+ * f32 atomic-add isn't native to WGSL. The shared `atomic_add_f32_storage`
+ * helper uses a compare-exchange retry loop over plain f32 bits. Contention is
  * typically low (each `(row, channel)` has 1–2 contributors in a
  * normalised blend), so the spin rarely loops more than once.
  *
@@ -55,29 +55,19 @@ fn pose_accumulator_slot_base(row: u32) -> u32 {
     return row * POSE_ACCUMULATOR_STRIDE;
 }
 
-fn pose_accumulator_atomic_add_f32(word_index: u32, value: f32) {
-    loop {
-        let old_u = atomicLoad(&pose_accumulator[word_index]);
-        let new_f = bitcast<f32>(old_u) + value;
-        let new_u = bitcast<u32>(new_f);
-        let result = atomicCompareExchangeWeak(&pose_accumulator[word_index], old_u, new_u);
-        if result.exchanged { break; }
-    }
-}
-
 fn pose_accumulator_add_translation(row: u32, value: vec3<f32>, mask: u32) {
     let base = pose_accumulator_slot_base(row) + POSE_OFFSET_TRANSLATION;
     var dirty_bits: u32 = 0u;
     if (mask & 0x1u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 0u, value.x);
+        atomic_add_f32_storage(&pose_accumulator[base + 0u], value.x);
         dirty_bits |= POSE_DIRTY_TX;
     }
     if (mask & 0x2u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 1u, value.y);
+        atomic_add_f32_storage(&pose_accumulator[base + 1u], value.y);
         dirty_bits |= POSE_DIRTY_TY;
     }
     if (mask & 0x4u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 2u, value.z);
+        atomic_add_f32_storage(&pose_accumulator[base + 2u], value.z);
         dirty_bits |= POSE_DIRTY_TZ;
     }
     if dirty_bits != 0u {
@@ -106,10 +96,10 @@ fn pose_accumulator_add_rotation(row: u32, value: vec4<f32>, mask: u32, weight:
     let w = select(weight, value.w, (mask & 0x8u) != 0u);
 
     let base = pose_accumulator_slot_base(row) + POSE_OFFSET_ROTATION;
-    pose_accumulator_atomic_add_f32(base + 0u, value.x);
-    pose_accumulator_atomic_add_f32(base + 1u, value.y);
-    pose_accumulator_atomic_add_f32(base + 2u, value.z);
-    pose_accumulator_atomic_add_f32(base + 3u, w);
+    atomic_add_f32_storage(&pose_accumulator[base + 0u], value.x);
+    atomic_add_f32_storage(&pose_accumulator[base + 1u], value.y);
+    atomic_add_f32_storage(&pose_accumulator[base + 2u], value.z);
+    atomic_add_f32_storage(&pose_accumulator[base + 3u], w);
     atomicOr(&pose_accumulator[pose_accumulator_slot_base(row) + POSE_OFFSET_DIRTY], POSE_DIRTY_R);
 }
 
@@ -117,19 +107,19 @@ fn pose_accumulator_add_scale(row: u32, value: vec3<f32>, mask: u32) {
     let base = pose_accumulator_slot_base(row) + POSE_OFFSET_SCALE;
     var dirty_bits: u32 = 0u;
     if (mask & 0x1u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 0u, value.x);
+        atomic_add_f32_storage(&pose_accumulator[base + 0u], value.x);
         dirty_bits |= POSE_DIRTY_SX;
     }
     if (mask & 0x2u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 1u, value.y);
+        atomic_add_f32_storage(&pose_accumulator[base + 1u], value.y);
         dirty_bits |= POSE_DIRTY_SY;
     }
     if (mask & 0x4u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 2u, value.z);
+        atomic_add_f32_storage(&pose_accumulator[base + 2u], value.z);
         dirty_bits |= POSE_DIRTY_SZ;
     }
     if dirty_bits != 0u {
         atomicOr(&pose_accumulator[pose_accumulator_slot_base(row) + POSE_OFFSET_DIRTY], dirty_bits);
     }
 }
-`);
+`, [chunk_atomic_add_f32_storage]);

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js

@@ -6,7 +6,8 @@ import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { SKINNING_BINDING_STRUCT } from "../SKINNING_BINDING_STRUCT.js";
-import { chunk_aabb_atomic_f32 } from "./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";
 
 /**
  * Workgroup size — also the per-meshlet vertex stride. One thread per
@@ -113,7 +114,7 @@ fn main(
     // Note that the storage sentinels in \`meshlet.bounds_box\` and
     // \`geometry.bounding_box\` ARE true ±inf — the scatter pass
     // writes the u32 bit pattern directly via \`atomicStore\`, no
-    // const-fold involved, and \`aabb_atomic_min_f32\` bitcasts
+    // const-fold involved, and \`atomic_min_f32_storage\` bitcasts
     // back to f32 at runtime where ±inf is a valid value.
     var thread_min = vec3<f32>( 3.4028234e38);
     var thread_max = vec3<f32>(-3.4028234e38);
@@ -164,23 +165,23 @@ fn main(
         let final_max = wg_max[0];
 
         let m_bounds_base = m_base_words + MESHLET_BOUNDS_OFFSET;
-        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 0u], final_min.x);
-        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 1u], final_min.y);
-        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 2u], final_min.z);
-        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 3u], final_max.x);
-        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 4u], final_max.y);
-        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 5u], final_max.z);
+        atomic_min_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 0u], final_min.x);
+        atomic_min_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 1u], final_min.y);
+        atomic_min_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 2u], final_min.z);
+        atomic_max_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 3u], final_max.x);
+        atomic_max_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 4u], final_max.y);
+        atomic_max_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 5u], final_max.z);
 
         let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE + GEOMETRY_BBOX_OFFSET;
-        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 0u], final_min.x);
-        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 1u], final_min.y);
-        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 2u], final_min.z);
-        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 3u], final_max.x);
-        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 4u], final_max.y);
-        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 5u], final_max.z);
+        atomic_min_f32_storage(&geometry_metadata_atomic[g_base + 0u], final_min.x);
+        atomic_min_f32_storage(&geometry_metadata_atomic[g_base + 1u], final_min.y);
+        atomic_min_f32_storage(&geometry_metadata_atomic[g_base + 2u], final_min.z);
+        atomic_max_f32_storage(&geometry_metadata_atomic[g_base + 3u], final_max.x);
+        atomic_max_f32_storage(&geometry_metadata_atomic[g_base + 4u], final_max.y);
+        atomic_max_f32_storage(&geometry_metadata_atomic[g_base + 5u], final_max.z);
     }
 }
-`, [chunk_aabb_atomic_f32]);
+`, [chunk_atomic_min_f32_storage, chunk_atomic_max_f32_storage]);
 
 /**
  * Compute shader that reduces a clone meshlet's deformed vertex

package/src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.js

@@ -1,7 +1,7 @@
 import {
     chunk_lpv_mesh_interpolate_radiance_via_atlas
 } from "../../global_illumination/probe/octahedral/sample/chunk_lpv_mesh_interpolate_radiance_via_atlas.js";
-import { chunk_roughness_to_mip_ratio } from "../../light/environment/chunk_sphere_probe_roughness_to_lod.js";
+import { chunk_roughness_to_mip_ratio } from "../../light/environment/chunk_roughness_to_mip_ratio.js";
 
 import {
     chunk_lpv_mesh_interpolate_probe_irradiance_pre