@woosh/meep-engine 3.35.0 → 3.37.0

package/src/engine/input/ecs/ism/trigger/InputTriggerSwitch.js

@@ -3,6 +3,11 @@ import { InputSource } from "../InputSource.js";
 import { InputTrigger } from "./InputTrigger.js";
 import { InputTriggerType } from "./InputTriggerType.js";
 
+/**
+ * @typedef {import('../InputSourceTable.js').InputSourceTable} InputSourceTable
+ * @typedef {import('../../../../../core/binary/BitSet.js').BitSet} BitSet
+ */
+
 /**
  * True while one switch is held.
  *

package/src/engine/input/ecs/ism/trigger/InputTriggerXRButton.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Trigger on a native XR button's pressed or touched switch.
+ * Subscribe to XRInputAction.completed for semantic select/squeeze completion.
+ */
+export class InputTriggerXRButton extends InputTriggerSwitch {
+    /**
+     * @param {'left'|'right'|'none'} handedness
+     * @param {number} index Native button index.
+     * @param {boolean} [touched=false] True selects touched; false selects pressed.
+     * @returns {InputTriggerXRButton}
+     */
+    static from(handedness: 'left' | 'right' | 'none', index: number, touched?: boolean): InputTriggerXRButton;
+}
+import { InputTriggerSwitch } from "./InputTriggerSwitch.js";
+//# sourceMappingURL=InputTriggerXRButton.d.ts.map

package/src/engine/input/ecs/ism/trigger/InputTriggerXRButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputTriggerXRButton.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/input/ecs/ism/trigger/InputTriggerXRButton.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH;IACI;;;;;OAKG;IACH,wBALW,MAAM,GAAC,OAAO,GAAC,MAAM,SACrB,MAAM,YACN,OAAO,GACL,oBAAoB,CAShC;CACJ;mCArBkC,yBAAyB"}

package/src/engine/input/ecs/ism/trigger/InputTriggerXRButton.js

@@ -0,0 +1,25 @@
+import { assert } from "../../../../../core/assert.js";
+import { xr_input_device_id } from "../device/XR_INPUT_DEVICE_IDS.js";
+import { InputSource } from "../InputSource.js";
+import { InputTriggerSwitch } from "./InputTriggerSwitch.js";
+
+/**
+ * Trigger on a native XR button's pressed or touched switch.
+ * Subscribe to XRInputAction.completed for semantic select/squeeze completion.
+ */
+export class InputTriggerXRButton extends InputTriggerSwitch {
+    /**
+     * @param {'left'|'right'|'none'} handedness
+     * @param {number} index Native button index.
+     * @param {boolean} [touched=false] True selects touched; false selects pressed.
+     * @returns {InputTriggerXRButton}
+     */
+    static from(handedness, index, touched = false) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.isBoolean(touched, 'touched');
+
+        const result = new InputTriggerXRButton();
+        result.source = InputSource.from(xr_input_device_id(handedness), index * 2 + (touched ? 1 : 0));
+        return result;
+    }
+}

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#413@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#418@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#413@#clear_field"(fluid: FluidComponent): void;
+    static "__#418@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#413@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#418@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#413@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#418@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

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