@relu-interactives/spatial-ecs 0.3.1 → 0.3.4

package/dist/systems/index.cjs

@@ -18,6 +18,8 @@ var OutputPass_js = require('three/examples/jsm/postprocessing/OutputPass.js');
 var HueSaturationShader_js = require('three/examples/jsm/shaders/HueSaturationShader.js');
 var SepiaShader_js = require('three/examples/jsm/shaders/SepiaShader.js');
 var VignetteShader_js = require('three/examples/jsm/shaders/VignetteShader.js');
+var XRControllerModelFactory_js = require('three/examples/jsm/webxr/XRControllerModelFactory.js');
+var XRHandModelFactory_js = require('three/examples/jsm/webxr/XRHandModelFactory.js');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespace(e) {
@@ -2080,7 +2082,8 @@ var _VRTeleportAreaComponent = class _VRTeleportAreaComponent extends Component
   constructor(options) {
     super();
     this.enabled = options?.enabled ?? true;
-    this.shape = options?.shape ?? "plane";
+    const shape = options?.shape;
+    this.shape = shape === "cylinder" ? "circle" : options?.shape ?? "plane";
     this.width = options?.width ?? 10;
     this.depth = options?.depth ?? 10;
   }
@@ -4901,6 +4904,15 @@ function buildComponentValueMaps(snapshot) {
       snapshot.components,
       "ScriptObjectComponent"
     ),
+    xrRigValues: readByComponent(snapshot.components, "XRRigComponent"),
+    vrTeleportAreaValues: readByComponent(
+      snapshot.components,
+      "VRTeleportAreaComponent"
+    ),
+    xrInteractableValues: readByComponent(
+      snapshot.components,
+      "XRInteractableComponent"
+    ),
     instancedMeshValues: readByComponent(snapshot.components, "InstancedMeshComponent"),
     instanceSlotValues: readByComponent(snapshot.components, "InstanceSlotComponent"),
     prefabNodeValues: readByComponent(snapshot.components, "PrefabNode"),
@@ -5026,6 +5038,67 @@ function restorePostCreateComponents(world, objectManagementSystem, targetEntity
       soc.data = remapEntityRefsInScriptData(data, idMap);
     }
   }
+  {
+    const sourceXrRig = asRecord3(values.xrRigValues.get(sourceEntityId));
+    const rig = world.getComponent(targetEntityId, XRRigComponent);
+    if (sourceXrRig && rig) {
+      if (typeof sourceXrRig.locomotion === "string") {
+        rig.locomotion = sourceXrRig.locomotion;
+      }
+      if (typeof sourceXrRig.moveSpeed === "number") {
+        rig.moveSpeed = sourceXrRig.moveSpeed;
+      }
+      if (typeof sourceXrRig.snapTurn === "boolean") {
+        rig.snapTurn = sourceXrRig.snapTurn;
+      }
+      if (typeof sourceXrRig.snapTurnDegrees === "number") {
+        rig.snapTurnDegrees = sourceXrRig.snapTurnDegrees;
+      }
+      if (typeof sourceXrRig.fallbackEyeHeight === "number") {
+        rig.fallbackEyeHeight = sourceXrRig.fallbackEyeHeight;
+      }
+    }
+  }
+  {
+    const sourceArea = asRecord3(values.vrTeleportAreaValues.get(sourceEntityId));
+    const area = world.getComponent(targetEntityId, VRTeleportAreaComponent);
+    if (sourceArea && area) {
+      if (typeof sourceArea.enabled === "boolean") {
+        area.enabled = sourceArea.enabled;
+      }
+      if (typeof sourceArea.shape === "string") {
+        area.shape = sourceArea.shape === "cylinder" ? "circle" : sourceArea.shape;
+      }
+      if (typeof sourceArea.width === "number") area.width = sourceArea.width;
+      if (typeof sourceArea.depth === "number") area.depth = sourceArea.depth;
+    }
+  }
+  {
+    const sourceInteractable = asRecord3(
+      values.xrInteractableValues.get(sourceEntityId)
+    );
+    const interactable = world.getComponent(
+      targetEntityId,
+      XRInteractableComponent
+    );
+    if (sourceInteractable && interactable) {
+      if (typeof sourceInteractable.enabled === "boolean") {
+        interactable.enabled = sourceInteractable.enabled;
+      }
+      if (typeof sourceInteractable.grabbable === "boolean") {
+        interactable.grabbable = sourceInteractable.grabbable;
+      }
+      if (typeof sourceInteractable.pointable === "boolean") {
+        interactable.pointable = sourceInteractable.pointable;
+      }
+      if (typeof sourceInteractable.grabMode === "string") {
+        interactable.grabMode = sourceInteractable.grabMode;
+      }
+      if (typeof sourceInteractable.highlightOnHover === "boolean") {
+        interactable.highlightOnHover = sourceInteractable.highlightOnHover;
+      }
+    }
+  }
   {
     const imComponent = world.getComponent(targetEntityId, InstancedMeshComponent);
     if (imComponent && imComponent.instanceEntityIds.length > 0) {
@@ -8043,6 +8116,128 @@ var _XRSessionSystem = class _XRSessionSystem {
 };
 __name(_XRSessionSystem, "XRSessionSystem");
 var XRSessionSystem = _XRSessionSystem;
+function buildGeometry2(area) {
+  if (area.shape === "circle") {
+    const radius = Math.max(5e-3, area.width / 2);
+    return new THREE14__namespace.CircleGeometry(radius, 48);
+  }
+  return new THREE14__namespace.PlaneGeometry(
+    Math.max(0.01, area.width),
+    Math.max(0.01, area.depth)
+  );
+}
+__name(buildGeometry2, "buildGeometry");
+function signatureOf(area) {
+  return `${area.shape}:${area.width}:${area.depth}`;
+}
+__name(signatureOf, "signatureOf");
+var _VRTeleportAreaSystem = class _VRTeleportAreaSystem {
+  constructor() {
+    this.signatures = /* @__PURE__ */ new Map();
+  }
+  update(world) {
+    const entityIds = world.query(VRTeleportAreaComponent, Object3DRef);
+    const alive = new Set(entityIds);
+    for (const tracked of this.signatures.keys()) {
+      if (!alive.has(tracked)) this.signatures.delete(tracked);
+    }
+    for (const entityId of entityIds) {
+      const area = world.getComponent(entityId, VRTeleportAreaComponent);
+      const object = world.getComponent(entityId, Object3DRef)?.object;
+      if (!area || !(object instanceof THREE14__namespace.Mesh)) continue;
+      const signature = signatureOf(area);
+      if (this.signatures.get(entityId) === signature) continue;
+      this.signatures.set(entityId, signature);
+      object.geometry?.dispose?.();
+      object.geometry = buildGeometry2(area);
+    }
+  }
+};
+__name(_VRTeleportAreaSystem, "VRTeleportAreaSystem");
+var VRTeleportAreaSystem = _VRTeleportAreaSystem;
+var _XRControllerVisualSystem = class _XRControllerVisualSystem {
+  constructor(slots = 2) {
+    this.controllerModelFactory = new XRControllerModelFactory_js.XRControllerModelFactory();
+    this.handModelFactory = new XRHandModelFactory_js.XRHandModelFactory();
+    this.group = new THREE14__namespace.Group();
+    this.built = false;
+    this.attachedTo = null;
+    /** Index → whether we've already attached visuals for that slot. */
+    this.ready = /* @__PURE__ */ new Set();
+    this.slots = slots;
+    this.group.name = "XRControllerVisuals";
+    this.group.userData.ecsPreviewHidden = true;
+  }
+  update(world) {
+    const renderer = world.getRenderer();
+    if (!renderer.xr?.enabled) return;
+    this.ensureAttached(world);
+    if (this.built) return;
+    for (let index = 0; index < this.slots; index += 1) {
+      if (this.ready.has(index)) continue;
+      const controller = renderer.xr.getController(index);
+      const grip = renderer.xr.getControllerGrip(index);
+      const hand = renderer.xr.getHand(index);
+      if (!controller || !grip || !hand) continue;
+      controller.add(this.createRay());
+      this.group.add(controller);
+      grip.add(this.controllerModelFactory.createControllerModel(grip));
+      this.group.add(grip);
+      hand.add(this.handModelFactory.createHandModel(hand, "mesh"));
+      this.group.add(hand);
+      this.ready.add(index);
+    }
+    if (this.ready.size >= this.slots) {
+      this.built = true;
+    }
+  }
+  /**
+   * Parent the visuals to the XR rig when there is one, so locomotion moves the
+   * hands with the player. Falls back to the scene root.
+   */
+  ensureAttached(world) {
+    const camera = world.getCamera();
+    const target = camera.parent ?? world.getScene();
+    if (this.attachedTo === target) return;
+    target.add(this.group);
+    this.attachedTo = target;
+  }
+  createRay() {
+    const geometry = new THREE14__namespace.BufferGeometry().setFromPoints([
+      new THREE14__namespace.Vector3(0, 0, 0),
+      new THREE14__namespace.Vector3(0, 0, -5)
+    ]);
+    const material = new THREE14__namespace.LineBasicMaterial({
+      color: "#4da3ff",
+      transparent: true,
+      opacity: 0.6,
+      depthTest: false
+    });
+    const line = new THREE14__namespace.Line(geometry, material);
+    line.name = "XRPointerRay";
+    line.renderOrder = 999;
+    return line;
+  }
+  dispose() {
+    this.group.removeFromParent();
+    this.group.traverse((child) => {
+      const mesh = child;
+      mesh.geometry?.dispose?.();
+      const material = mesh.material;
+      if (Array.isArray(material)) {
+        for (const entry of material) entry.dispose?.();
+      } else {
+        material?.dispose?.();
+      }
+    });
+    this.group.clear();
+    this.ready.clear();
+    this.built = false;
+    this.attachedTo = null;
+  }
+};
+__name(_XRControllerVisualSystem, "XRControllerVisualSystem");
+var XRControllerVisualSystem = _XRControllerVisualSystem;
 
 exports.AnimationSystem = AnimationSystem;
 exports.AudioSystem = AudioSystem;
@@ -8063,7 +8258,9 @@ exports.SCRIPT_OBJECT_ROOT_FLAG = SCRIPT_OBJECT_ROOT_FLAG;
 exports.ScriptBehaviourSystem = ScriptBehaviourSystem;
 exports.ScriptObjectSystem = ScriptObjectSystem;
 exports.TransformSyncSystem = TransformSyncSystem;
+exports.VRTeleportAreaSystem = VRTeleportAreaSystem;
 exports.VideoSystem = VideoSystem;
+exports.XRControllerVisualSystem = XRControllerVisualSystem;
 exports.XRInputSystem = XRInputSystem;
 exports.XRInteractionSystem = XRInteractionSystem;
 exports.XRLocomotionSystem = XRLocomotionSystem;