@relu-interactives/spatial-ecs 0.5.0 → 0.5.1

package/dist/{index-CppKDxbu.d.ts → index-D2Jt_JzH.d.ts}

@@ -736,6 +736,10 @@ declare class XREnvironmentSystem implements EcsSystem {
     private roomCaptureRequested;
     /** This frame's inverse viewer matrix, or null when unavailable. */
     private viewerInverse;
+    /** This frame's viewer position in reference space, for room election. */
+    private viewerPos;
+    /** The ONE global room mesh currently allowed to spawn. */
+    private electedGlobalMesh;
     private readonly tmpViewerMatrix;
     private readonly tmpViewPos;
     update(world: World, deltaTime?: number): void;
@@ -786,6 +790,13 @@ declare class XREnvironmentSystem implements EcsSystem {
     private findRig;
     private syncPlanes;
     private syncMeshes;
+    /**
+     * Pick THE room's global mesh: the one whose scan origin is nearest the
+     * viewer, sticky to the current choice within a margin so origin jitter
+     * can't flap the room. Without a viewer pose (or with a single candidate)
+     * the first candidate stands; ties are impossible to break anyway.
+     */
+    private electGlobalMesh;
     /**
      * Admission control for a NOT-yet-spawned surface. With a viewer pose
      * available, the surface must behave world-anchored for a few frames before

package/dist/{index-I2IsocYW.d.cts → index-DaG03vyN.d.cts}

@@ -736,6 +736,10 @@ declare class XREnvironmentSystem implements EcsSystem {
     private roomCaptureRequested;
     /** This frame's inverse viewer matrix, or null when unavailable. */
     private viewerInverse;
+    /** This frame's viewer position in reference space, for room election. */
+    private viewerPos;
+    /** The ONE global room mesh currently allowed to spawn. */
+    private electedGlobalMesh;
     private readonly tmpViewerMatrix;
     private readonly tmpViewPos;
     update(world: World, deltaTime?: number): void;
@@ -786,6 +790,13 @@ declare class XREnvironmentSystem implements EcsSystem {
     private findRig;
     private syncPlanes;
     private syncMeshes;
+    /**
+     * Pick THE room's global mesh: the one whose scan origin is nearest the
+     * viewer, sticky to the current choice within a margin so origin jitter
+     * can't flap the room. Without a viewer pose (or with a single candidate)
+     * the first candidate stands; ties are impossible to break anyway.
+     */
+    private electGlobalMesh;
     /**
      * Admission control for a NOT-yet-spawned surface. With a viewer pose
      * available, the surface must behave world-anchored for a few frames before

package/dist/index.cjs

@@ -12978,6 +12978,11 @@ function debugColorFor(kind, semanticLabel) {
 }
 __name(debugColorFor, "debugColorFor");
 var GLOBAL_MESH_DEBUG_OPACITY = 0.35;
+var GLOBAL_MESH_SWITCH_MARGIN = 1.5;
+function isGlobalMeshSurface(mesh) {
+  return (mesh.semanticLabel ?? null) === "global mesh";
+}
+__name(isGlobalMeshSurface, "isGlobalMeshSurface");
 var DEBUG_RENDER_ORDER = 900;
 var ROOM_CAPTURE_DELAY_SECONDS = 3;
 var SYNTHETIC_FLOOR_EXTENT = 50;
@@ -13016,6 +13021,10 @@ var _XREnvironmentSystem = class _XREnvironmentSystem {
     this.roomCaptureRequested = false;
     /** This frame's inverse viewer matrix, or null when unavailable. */
     this.viewerInverse = null;
+    /** This frame's viewer position in reference space, for room election. */
+    this.viewerPos = null;
+    /** The ONE global room mesh currently allowed to spawn. */
+    this.electedGlobalMesh = null;
     this.tmpViewerMatrix = new THREE56__namespace.Matrix4();
     this.tmpViewPos = new THREE56__namespace.Vector3();
   }
@@ -13056,7 +13065,14 @@ var _XREnvironmentSystem = class _XREnvironmentSystem {
     const useMesh = (mode === "mesh" || mode === "auto") && meshesAvailable;
     const usePlanes = mode === "planes" || mode === "auto" && !useMesh;
     const viewer = frame.getViewerPose?.(referenceSpace);
-    this.viewerInverse = viewer ? this.tmpViewerMatrix.fromArray(viewer.transform.matrix).invert() : null;
+    if (viewer) {
+      const vm = viewer.transform.matrix;
+      this.viewerPos = { x: vm[12], y: vm[13], z: vm[14] };
+      this.viewerInverse = this.tmpViewerMatrix.fromArray(vm).invert();
+    } else {
+      this.viewerPos = null;
+      this.viewerInverse = null;
+    }
     if (usePlanes) {
       this.syncPlanes(world, frame, referenceSpace, deltaTime);
     } else if (this.planes.size > 0) {
@@ -13211,7 +13227,17 @@ var _XREnvironmentSystem = class _XREnvironmentSystem {
     for (const mesh of this.pendingMeshes.keys()) {
       if (!detected.has(mesh)) this.pendingMeshes.delete(mesh);
     }
+    const electedGlobal = this.electGlobalMesh(frame, detected, referenceSpace);
     for (const mesh of detected) {
+      if (isGlobalMeshSurface(mesh) && mesh !== electedGlobal) {
+        const stale = this.meshes.get(mesh);
+        if (stale) {
+          this.destroyEntry(world, stale);
+          this.meshes.delete(mesh);
+        }
+        this.pendingMeshes.delete(mesh);
+        continue;
+      }
       const pose = frame.getPose(mesh.meshSpace, referenceSpace);
       if (!pose) continue;
       const emulated = pose.emulatedPosition === true;
@@ -13235,6 +13261,45 @@ var _XREnvironmentSystem = class _XREnvironmentSystem {
       if (allowed) this.applyPose(world, entry.entityId, pose);
     }
   }
+  /**
+   * Pick THE room's global mesh: the one whose scan origin is nearest the
+   * viewer, sticky to the current choice within a margin so origin jitter
+   * can't flap the room. Without a viewer pose (or with a single candidate)
+   * the first candidate stands; ties are impossible to break anyway.
+   */
+  electGlobalMesh(frame, detected, referenceSpace) {
+    let nearest = null;
+    let nearestDist = Number.POSITIVE_INFINITY;
+    let currentDist = Number.POSITIVE_INFINITY;
+    let currentStillDetected = false;
+    for (const mesh of detected) {
+      if (!isGlobalMeshSurface(mesh)) continue;
+      if (!this.viewerPos) {
+        return this.electedGlobalMesh && detected.has(this.electedGlobalMesh) ? this.electedGlobalMesh : mesh;
+      }
+      const pose = frame.getPose(mesh.meshSpace, referenceSpace);
+      if (!pose) continue;
+      const m = pose.transform.matrix;
+      const d = Math.hypot(
+        m[12] - this.viewerPos.x,
+        m[13] - this.viewerPos.y,
+        m[14] - this.viewerPos.z
+      );
+      if (mesh === this.electedGlobalMesh) {
+        currentDist = d;
+        currentStillDetected = true;
+      }
+      if (d < nearestDist) {
+        nearestDist = d;
+        nearest = mesh;
+      }
+    }
+    if (currentStillDetected && currentDist < nearestDist + GLOBAL_MESH_SWITCH_MARGIN) {
+      return this.electedGlobalMesh;
+    }
+    this.electedGlobalMesh = nearest;
+    return nearest;
+  }
   /**
    * Admission control for a NOT-yet-spawned surface. With a viewer pose
    * available, the surface must behave world-anchored for a few frames before
@@ -13446,6 +13511,7 @@ var _XREnvironmentSystem = class _XREnvironmentSystem {
     this.clearMap(world, this.meshes);
     this.pendingPlanes.clear();
     this.pendingMeshes.clear();
+    this.electedGlobalMesh = null;
   }
   dispose(world) {
     this.clearAll(world);