@relu-interactives/spatial-ecs 0.3.10 → 0.3.11

package/dist/index.cjs

@@ -2830,7 +2830,6 @@ var _XRInteractableComponent = class _XRInteractableComponent extends Component
     this.enabled = options?.enabled ?? true;
     this.grabbable = options?.grabbable ?? true;
     this.pointable = options?.pointable ?? true;
-    this.grabMode = options?.grabMode ?? "kinematic";
     this.grabReach = options?.grabReach ?? "both";
     this.distanceBehavior = options?.distanceBehavior ?? "snap";
     this.grabGesture = options?.grabGesture ?? "any";
@@ -2855,7 +2854,9 @@ var _XRInteractableComponent = class _XRInteractableComponent extends Component
     );
     this.throwOnRelease = options?.throwOnRelease ?? true;
     this.throwStrength = options?.throwStrength ?? 1;
-    this.highlightOnHover = options?.highlightOnHover ?? true;
+    this.hoverBehavior = options?.hoverBehavior ?? "color";
+    this.hoverColor = options?.hoverColor ?? "#4da3ff";
+    this.hoverScale = options?.hoverScale ?? 1.06;
   }
 };
 __name(_XRInteractableComponent, "XRInteractableComponent");
@@ -4866,9 +4867,6 @@ function restorePostCreateComponents(world, objectManagementSystem, targetEntity
       if (typeof sourceInteractable.pointable === "boolean") {
         interactable.pointable = sourceInteractable.pointable;
       }
-      if (typeof sourceInteractable.grabMode === "string") {
-        interactable.grabMode = sourceInteractable.grabMode;
-      }
       if (typeof sourceInteractable.grabReach === "string") {
         interactable.grabReach = sourceInteractable.grabReach;
       }
@@ -4927,8 +4925,16 @@ function restorePostCreateComponents(world, objectManagementSystem, targetEntity
           z: typeof grabRot.z === "number" ? grabRot.z : 0
         };
       }
-      if (typeof sourceInteractable.highlightOnHover === "boolean") {
-        interactable.highlightOnHover = sourceInteractable.highlightOnHover;
+      if (typeof sourceInteractable.hoverBehavior === "string") {
+        interactable.hoverBehavior = sourceInteractable.hoverBehavior;
+      } else if (sourceInteractable.highlightOnHover === false) {
+        interactable.hoverBehavior = "none";
+      }
+      if (typeof sourceInteractable.hoverColor === "string") {
+        interactable.hoverColor = sourceInteractable.hoverColor;
+      }
+      if (typeof sourceInteractable.hoverScale === "number") {
+        interactable.hoverScale = sourceInteractable.hoverScale;
       }
     }
   }
@@ -7445,6 +7451,20 @@ var _PostprocessingSyncSystem = class _PostprocessingSyncSystem {
 __name(_PostprocessingSyncSystem, "PostprocessingSyncSystem");
 var PostprocessingSyncSystem = _PostprocessingSyncSystem;
 var MIN_SIZE = 1e-4;
+function toBodyType(RAPIER, bodyType) {
+  switch (bodyType) {
+    case "fixed":
+      return RAPIER.RigidBodyType.Fixed;
+    case "kinematicPosition":
+      return RAPIER.RigidBodyType.KinematicPositionBased;
+    case "kinematicVelocity":
+      return RAPIER.RigidBodyType.KinematicVelocityBased;
+    case "dynamic":
+    default:
+      return RAPIER.RigidBodyType.Dynamic;
+  }
+}
+__name(toBodyType, "toBodyType");
 function createRigidBodyDesc(RAPIER, bodyType) {
   if (bodyType === "fixed") {
     return RAPIER.RigidBodyDesc.fixed();
@@ -7743,7 +7763,8 @@ var _PhysicsSyncSystem = class _PhysicsSyncSystem {
         setPhysicsLiveRef(physics, "collider", null);
         continue;
       }
-      const rigidBodySignature = JSON.stringify(physics.values.rigidbody);
+      const { type: _desiredBodyType, ...rigidBodyRebuildValues } = physics.values.rigidbody;
+      const rigidBodySignature = JSON.stringify(rigidBodyRebuildValues);
       const previousRigidBodySignature = this.rigidBodySignatures.get(entityId);
       const hasRigidBody = this.rigidBodyHandles.has(entityId);
       const shouldRecreateBody = !hasRigidBody || previousRigidBodySignature !== rigidBodySignature;
@@ -7798,6 +7819,25 @@ var _PhysicsSyncSystem = class _PhysicsSyncSystem {
         continue;
       }
       setPhysicsLiveRef(physics, "rigidBody", body);
+      const desiredBodyType = this.isEditorMode ? "fixed" : physics.values.rigidbody.type;
+      const desiredRapierType = toBodyType(this.rapier, desiredBodyType);
+      if (body.bodyType() !== desiredRapierType) {
+        body.setBodyType(desiredRapierType, true);
+        if (!this.isEditorMode && desiredBodyType === "dynamic") {
+          body.setAdditionalMass(physics.values.rigidbody.mass, true);
+        }
+      }
+      const pending = physics.pendingVelocity;
+      if (pending) {
+        setPhysicsLiveRef(physics, "pendingVelocity", null);
+        if (!this.isEditorMode && desiredBodyType === "dynamic") {
+          try {
+            body.setLinvel(pending.linear, true);
+            body.setAngvel(pending.angular, true);
+          } catch {
+          }
+        }
+      }
       if (this.isEditorMode || physics.values.rigidbody.type !== "dynamic") {
         syncBodyFromTransform(body, transform);
       }
@@ -11054,6 +11094,8 @@ var _XRInteractionSystem = class _XRInteractionSystem {
     this.raycaster = new THREE51__namespace.Raycaster();
     this.grabs = /* @__PURE__ */ new Map();
     this.hoveredEntityId = null;
+    /** Per-hand hover, with the hit distance so the ray can stop at the surface. */
+    this.hovers = /* @__PURE__ */ new Map();
     /** Monotonic seconds, accumulated from deltaTime for velocity sampling. */
     this.elapsed = 0;
     this.inputSystem = inputSystem;
@@ -11067,6 +11109,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
     const inputs = this.inputSystem.getInputs();
     const interactables = this.collectInteractables(world);
     this.hoveredEntityId = null;
+    this.hovers.clear();
     for (const input of inputs) {
       if (!input.connected) {
         this.release(world, input);
@@ -11084,6 +11127,10 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       if (this.hoveredEntityId === null) {
         this.hoveredEntityId = candidate.entityId;
       }
+      this.hovers.set(input, {
+        entityId: candidate.entityId,
+        distance: candidate.distance
+      });
       const interactable = world.getComponent(
         candidate.entityId,
         XRInteractableComponent
@@ -11156,7 +11203,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       transform.position.x - hand.x,
       transform.position.y - hand.y,
       transform.position.z - hand.z
-    );
+    ).applyQuaternion(handQuaternion.clone().invert());
     record.handRotationOffset = handQuaternion.clone().invert().multiply(objectQuaternion);
     record.remote = false;
     record.tracker.clear();
@@ -11267,13 +11314,22 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       }
     }
     if (nearestId !== null) {
-      return { entityId: nearestId, viaDistance: false };
+      return {
+        entityId: nearestId,
+        viaDistance: false,
+        distance: nearestDistance
+      };
     }
-    const hitId = this.raycast(input, interactables);
-    if (hitId === null) return null;
+    const hit = this.raycast(input, interactables);
+    if (hit === null) return null;
+    const hitId = hit.entityId;
     const interactable = world.getComponent(hitId, XRInteractableComponent);
     const viaDistanceAllowed = interactable?.grabReach === "distance" || interactable?.grabReach === "both";
-    return { entityId: hitId, viaDistance: viaDistanceAllowed };
+    return {
+      entityId: hitId,
+      viaDistance: viaDistanceAllowed,
+      distance: hit.distance
+    };
   }
   collectInteractables(world) {
     const out = [];
@@ -11304,7 +11360,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
         nearestId = entry.entityId;
       }
     }
-    return nearestId;
+    return nearestId === null ? null : { entityId: nearestId, distance: nearestDistance };
   }
   /**
    * Pick the authored hold this hand should take.
@@ -11379,7 +11435,7 @@ var _XRInteractionSystem = class _XRInteractionSystem {
         transform.position.x - hand.x,
         transform.position.y - hand.y,
         transform.position.z - hand.z
-      );
+      ).applyQuaternion(handQuaternion.clone().invert());
     }
     const physics = world.getComponent(entityId, PhysicsComponent);
     let restoreBodyType = null;
@@ -11514,9 +11570,10 @@ var _XRInteractionSystem = class _XRInteractionSystem {
       transform.position.z = hand.z - anchor.z;
       writeEuler(transform.rotation, objectQuaternion);
     } else {
-      transform.position.x = hand.x + held.offset.x;
-      transform.position.y = hand.y + held.offset.y;
-      transform.position.z = hand.z + held.offset.z;
+      const carried = held.offset.clone().applyQuaternion(handQuaternion);
+      transform.position.x = hand.x + carried.x;
+      transform.position.y = hand.y + carried.y;
+      transform.position.z = hand.z + carried.z;
       writeEuler(transform.rotation, objectQuaternion);
     }
     held.tracker.record(
@@ -11569,19 +11626,14 @@ var _XRInteractionSystem = class _XRInteractionSystem {
     const physics = world.getComponent(held.entityId, PhysicsComponent);
     if (held.restoreBodyType !== null && physics) {
       physics.values.rigidbody.type = held.restoreBodyType;
-      const body = physics.rigidBody;
       const dynamic = held.restoreBodyType === "dynamic";
-      if (body && dynamic && interactable?.throwOnRelease) {
+      if (dynamic && interactable?.throwOnRelease) {
         const velocity = held.tracker.computeVelocity(this.elapsed).multiplyScalar(interactable.throwStrength);
-        try {
-          body.setLinvel(
-            { x: velocity.x, y: velocity.y, z: velocity.z },
-            true
-          );
-          const spin = held.angularVelocity;
-          body.setAngvel({ x: spin.x, y: spin.y, z: spin.z }, true);
-        } catch {
-        }
+        const spin = held.angularVelocity;
+        setPhysicsLiveRef(physics, "pendingVelocity", {
+          linear: { x: velocity.x, y: velocity.y, z: velocity.z },
+          angular: { x: spin.x, y: spin.y, z: spin.z }
+        });
       }
     }
     held.tracker.clear();
@@ -11629,6 +11681,30 @@ var _XRInteractionSystem = class _XRInteractionSystem {
   getHoveredEntityId() {
     return this.hoveredEntityId;
   }
+  /**
+   * What this hand is pointing at, with the distance to it.
+   *
+   * The distance is what lets the pointer ray stop at the surface instead of
+   * passing through the object.
+   */
+  getHoverFor(handedness) {
+    for (const [input, hover] of this.hovers) {
+      if (input.handedness === handedness) return hover;
+    }
+    return null;
+  }
+  /** Every entity under a pointer this frame — drives hover feedback. */
+  getHoveredEntityIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const hover of this.hovers.values()) ids.add(hover.entityId);
+    return ids;
+  }
+  /** Entities currently held, so hover feedback can skip them. */
+  getHeldEntityIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const record of this.grabs.values()) ids.add(record.entityId);
+    return ids;
+  }
   /** True when any source is holding something. */
   isGrabbing() {
     return this.grabs.size > 0;
@@ -12189,6 +12265,9 @@ function applyHandMaterial(root, material) {
   });
 }
 __name(applyHandMaterial, "applyHandMaterial");
+
+// core/systems/XRControllerVisualSystem.ts
+var RAY_LENGTH = 5;
 var SLOTS = [
   { index: 0, side: "left" },
   { index: 1, side: "right" }
@@ -12227,6 +12306,7 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
       visuals.controllerModel.visible = showControllers && hasController;
       visuals.handModel.visible = showHands && hasHand;
       visuals.ray.visible = this.shouldShowRay(interactor);
+      this.fitRayToHover(visuals.ray, side);
       if (showHands && this.handMaterial) {
         applyHandMaterial(visuals.handModel, this.handMaterial);
       }
@@ -12307,6 +12387,18 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
     if (!this.interactionSystem) return true;
     return this.interactionSystem.getHoveredEntityId() !== null || this.interactionSystem.isGrabbing();
   }
+  /**
+   * Stop the ray at whatever it is pointing at.
+   *
+   * A fixed-length ray drawn with depth testing off punches straight through the
+   * object, so the user cannot tell where the pointer actually lands. Scaling it
+   * to the hit distance turns it into a pointer that meets the surface.
+   */
+  fitRayToHover(ray, side) {
+    const hover = this.interactionSystem?.getHoverFor(side) ?? null;
+    const length = hover && Number.isFinite(hover.distance) && hover.distance > 0 ? Math.min(hover.distance, RAY_LENGTH) : RAY_LENGTH;
+    ray.scale.z = length / RAY_LENGTH;
+  }
   /** Lazily build per-slot visuals; the device reports profiles late. */
   ensureSlots(world) {
     const renderer = world.getRenderer();
@@ -12348,7 +12440,7 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
   createRay() {
     const geometry = new THREE51__namespace.BufferGeometry().setFromPoints([
       new THREE51__namespace.Vector3(0, 0, 0),
-      new THREE51__namespace.Vector3(0, 0, -5)
+      new THREE51__namespace.Vector3(0, 0, -RAY_LENGTH)
     ]);
     const material = new THREE51__namespace.LineBasicMaterial({
       color: "#4da3ff",
@@ -13011,6 +13103,152 @@ var _XRHandPoseSystem = class _XRHandPoseSystem {
 };
 __name(_XRHandPoseSystem, "XRHandPoseSystem");
 var XRHandPoseSystem = _XRHandPoseSystem;
+var XR_HOVER_SHELL_FLAG = "__xrHoverShell";
+var SHELL_INFLATE = 1.04;
+var SCALE_SMOOTH_SECONDS = 0.09;
+var _XRHoverVisualSystem = class _XRHoverVisualSystem {
+  constructor(interactionSystem) {
+    this.records = /* @__PURE__ */ new Map();
+    this.interactionSystem = interactionSystem;
+  }
+  update(world, deltaTime) {
+    if (!world.isXrPresenting()) {
+      this.clearAll(world);
+      return;
+    }
+    const hovered = this.interactionSystem.getHoveredEntityIds();
+    const held = this.interactionSystem.getHeldEntityIds();
+    for (const entityId of hovered) {
+      if (held.has(entityId)) continue;
+      const interactable = world.getComponent(entityId, XRInteractableComponent);
+      if (!interactable?.enabled) continue;
+      if (interactable.hoverBehavior === "none") continue;
+      this.begin(world, entityId, interactable);
+    }
+    for (const [entityId, record] of this.records) {
+      if (!hovered.has(entityId) || held.has(entityId)) {
+        record.active = false;
+      }
+    }
+    this.animate(world, deltaTime);
+  }
+  begin(world, entityId, interactable) {
+    const existing = this.records.get(entityId);
+    if (existing) {
+      existing.active = true;
+      return;
+    }
+    const transform = world.getComponent(entityId, TransformComponent);
+    if (!transform) return;
+    const wantsColor = interactable.hoverBehavior === "color" || interactable.hoverBehavior === "both";
+    this.records.set(entityId, {
+      shell: wantsColor ? this.addShell(world, entityId, interactable) : null,
+      baseScale: new THREE51__namespace.Vector3(
+        transform.scale.x,
+        transform.scale.y,
+        transform.scale.z
+      ),
+      progress: 0,
+      active: true
+    });
+  }
+  /** Build an inflated back-face copy of the object's meshes. */
+  addShell(world, entityId, interactable) {
+    const object = world.getComponent(entityId, Object3DRef)?.object;
+    if (!object) return null;
+    const material = new THREE51__namespace.MeshBasicMaterial({
+      color: new THREE51__namespace.Color(interactable.hoverColor),
+      // Back faces only, so the shell shows just outside the silhouette instead
+      // of covering the object.
+      side: THREE51__namespace.BackSide,
+      transparent: true,
+      opacity: 0.85,
+      depthWrite: false
+    });
+    const group = new THREE51__namespace.Group();
+    group.name = "XRHoverShell";
+    group.userData[XR_HOVER_SHELL_FLAG] = true;
+    group.renderOrder = 998;
+    object.traverse((child) => {
+      if (!(child instanceof THREE51__namespace.Mesh) || !child.geometry) return;
+      if (child.userData[XR_HOVER_SHELL_FLAG]) return;
+      const clone3 = new THREE51__namespace.Mesh(child.geometry, material);
+      child.updateWorldMatrix(true, false);
+      object.updateWorldMatrix(true, false);
+      clone3.matrixAutoUpdate = false;
+      clone3.matrix.copy(object.matrixWorld).invert().multiply(child.matrixWorld).scale(new THREE51__namespace.Vector3(SHELL_INFLATE, SHELL_INFLATE, SHELL_INFLATE));
+      clone3.userData[XR_HOVER_SHELL_FLAG] = true;
+      clone3.raycast = () => {
+      };
+      group.add(clone3);
+    });
+    if (group.children.length === 0) {
+      material.dispose();
+      return null;
+    }
+    object.add(group);
+    return group;
+  }
+  animate(world, deltaTime) {
+    const step = 1 - Math.exp(-Math.max(0, deltaTime) / SCALE_SMOOTH_SECONDS);
+    for (const [entityId, record] of Array.from(this.records)) {
+      const interactable = world.getComponent(entityId, XRInteractableComponent);
+      const target = record.active ? 1 : 0;
+      record.progress += (target - record.progress) * step;
+      const wantsScale = interactable?.hoverBehavior === "scale" || interactable?.hoverBehavior === "both";
+      if (wantsScale) {
+        const transform = world.getComponent(entityId, TransformComponent);
+        if (transform) {
+          const factor = 1 + (interactable.hoverScale - 1) * Math.min(1, record.progress);
+          transform.scale.x = record.baseScale.x * factor;
+          transform.scale.y = record.baseScale.y * factor;
+          transform.scale.z = record.baseScale.z * factor;
+        }
+      }
+      if (!record.active && record.progress < 0.01) {
+        this.finish(world, entityId, record);
+      }
+    }
+  }
+  /** Remove the effect and restore the authored scale exactly. */
+  finish(world, entityId, record) {
+    const transform = world.getComponent(entityId, TransformComponent);
+    if (transform) {
+      transform.scale.x = record.baseScale.x;
+      transform.scale.y = record.baseScale.y;
+      transform.scale.z = record.baseScale.z;
+    }
+    this.disposeShell(record.shell);
+    this.records.delete(entityId);
+  }
+  disposeShell(shell) {
+    if (!shell) return;
+    shell.parent?.remove(shell);
+    shell.traverse((child) => {
+      if (child instanceof THREE51__namespace.Mesh) {
+        const material = child.material;
+        if (Array.isArray(material)) {
+          for (const entry of material) entry.dispose();
+        } else {
+          material?.dispose();
+        }
+      }
+    });
+  }
+  clearAll(world) {
+    for (const [entityId, record] of Array.from(this.records)) {
+      this.finish(world, entityId, record);
+    }
+  }
+  dispose() {
+    for (const record of this.records.values()) {
+      this.disposeShell(record.shell);
+    }
+    this.records.clear();
+  }
+};
+__name(_XRHoverVisualSystem, "XRHoverVisualSystem");
+var XRHoverVisualSystem = _XRHoverVisualSystem;
 
 // core/World.ts
 var _World = class _World {
@@ -14443,12 +14681,14 @@ exports.VideoSystem = VideoSystem;
 exports.World = World;
 exports.XRControllerVisualSystem = XRControllerVisualSystem;
 exports.XRHandPoseSystem = XRHandPoseSystem;
+exports.XRHoverVisualSystem = XRHoverVisualSystem;
 exports.XRInputSystem = XRInputSystem;
 exports.XRInteractionSystem = XRInteractionSystem;
 exports.XRLocomotionSystem = XRLocomotionSystem;
 exports.XRSessionSystem = XRSessionSystem;
 exports.XRTeleportVisualSystem = XRTeleportVisualSystem;
 exports.XR_FINGERS = XR_FINGERS;
+exports.XR_HOVER_SHELL_FLAG = XR_HOVER_SHELL_FLAG;
 exports.angularVelocityFrom = angularVelocityFrom;
 exports.applyHandMaterial = applyHandMaterial;
 exports.applyPrefabToSnapshotInstances = applyPrefabToSnapshotInstances;