@relu-interactives/spatial-ecs 0.3.4 → 0.3.6

package/dist/systems/index.cjs

@@ -2109,6 +2109,7 @@ var XRInteractableComponent = _XRInteractableComponent;
 var _XRRigComponent = class _XRRigComponent extends Component {
   constructor(options) {
     super();
+    this.trackingOrigin = options?.trackingOrigin ?? "floor";
     this.locomotion = options?.locomotion ?? "teleport";
     this.moveSpeed = options?.moveSpeed ?? 2;
     this.snapTurn = options?.snapTurn ?? true;
@@ -2119,6 +2120,29 @@ var _XRRigComponent = class _XRRigComponent extends Component {
 __name(_XRRigComponent, "XRRigComponent");
 var XRRigComponent = _XRRigComponent;
 
+// core/components/XRInteractor.ts
+var _XRInteractorComponent = class _XRInteractorComponent extends Component {
+  constructor(options) {
+    super();
+    this.interactorType = options?.interactorType ?? "both";
+    this.handPreset = options?.handPreset ?? "default";
+    this.handColor = options?.handColor ?? "#e8b48a";
+    this.handOpacity = options?.handOpacity ?? 1;
+    this.handEmissiveIntensity = options?.handEmissiveIntensity ?? 0;
+    this.showRay = options?.showRay ?? true;
+  }
+};
+__name(_XRInteractorComponent, "XRInteractorComponent");
+var XRInteractorComponent = _XRInteractorComponent;
+var _XRInteractorSideComponent = class _XRInteractorSideComponent extends Component {
+  constructor(options) {
+    super();
+    this.side = options?.side ?? "left";
+  }
+};
+__name(_XRInteractorSideComponent, "XRInteractorSideComponent");
+var XRInteractorSideComponent = _XRInteractorSideComponent;
+
 // core/utils/dracoDecoderPath.ts
 var LOCAL_DRACO_DECODER_RELATIVE_PATH = "./assets/draco/";
 var DRACO_DECODER_CDN_PATH = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/";
@@ -4913,6 +4937,14 @@ function buildComponentValueMaps(snapshot) {
       snapshot.components,
       "XRInteractableComponent"
     ),
+    xrInteractorValues: readByComponent(
+      snapshot.components,
+      "XRInteractorComponent"
+    ),
+    xrInteractorSideValues: readByComponent(
+      snapshot.components,
+      "XRInteractorSideComponent"
+    ),
     instancedMeshValues: readByComponent(snapshot.components, "InstancedMeshComponent"),
     instanceSlotValues: readByComponent(snapshot.components, "InstanceSlotComponent"),
     prefabNodeValues: readByComponent(snapshot.components, "PrefabNode"),
@@ -5099,6 +5131,60 @@ function restorePostCreateComponents(world, objectManagementSystem, targetEntity
       }
     }
   }
+  {
+    const sourceInteractor = asRecord3(
+      values.xrInteractorValues.get(sourceEntityId)
+    );
+    const interactor = world.getComponent(targetEntityId, XRInteractorComponent);
+    if (sourceInteractor && interactor) {
+      if (typeof sourceInteractor.interactorType === "string") {
+        interactor.interactorType = sourceInteractor.interactorType;
+      }
+      if (typeof sourceInteractor.handPreset === "string") {
+        interactor.handPreset = sourceInteractor.handPreset;
+      }
+      if (typeof sourceInteractor.handColor === "string") {
+        interactor.handColor = sourceInteractor.handColor;
+      }
+      if (typeof sourceInteractor.handOpacity === "number") {
+        interactor.handOpacity = sourceInteractor.handOpacity;
+      }
+      if (typeof sourceInteractor.handEmissiveIntensity === "number") {
+        interactor.handEmissiveIntensity = sourceInteractor.handEmissiveIntensity;
+      }
+      if (typeof sourceInteractor.showRay === "boolean") {
+        interactor.showRay = sourceInteractor.showRay;
+      }
+    }
+  }
+  {
+    const sourceSide = asRecord3(
+      values.xrInteractorSideValues.get(sourceEntityId)
+    );
+    if (sourceSide && typeof sourceSide.side === "string") {
+      const existing = world.getComponent(
+        targetEntityId,
+        XRInteractorSideComponent
+      );
+      if (existing) {
+        existing.side = sourceSide.side;
+      } else {
+        world.addComponent(
+          targetEntityId,
+          new XRInteractorSideComponent({
+            side: sourceSide.side
+          })
+        );
+      }
+    }
+  }
+  {
+    const sourceRigOrigin = asRecord3(values.xrRigValues.get(sourceEntityId));
+    const rigForOrigin = world.getComponent(targetEntityId, XRRigComponent);
+    if (sourceRigOrigin && rigForOrigin && typeof sourceRigOrigin.trackingOrigin === "string") {
+      rigForOrigin.trackingOrigin = sourceRigOrigin.trackingOrigin;
+    }
+  }
   {
     const imComponent = world.getComponent(targetEntityId, InstancedMeshComponent);
     if (imComponent && imComponent.instanceEntityIds.length > 0) {
@@ -5688,6 +5774,7 @@ var HYDRATABLE_ENTITY_KINDS = /* @__PURE__ */ new Set([
   "instanceSlot",
   "scriptObject",
   "xrRig",
+  "xrInteractor",
   "teleportArea"
 ]);
 
@@ -7698,6 +7785,9 @@ var _XRInputSystem = class _XRInputSystem {
         state.hasAxes = false;
         state.buttons = [];
       }
+    }
+    for (const record of this.records.values()) {
+      const state = record.state;
       if (record.pendingSelectStart) {
         state.select = true;
         state.selectStart = true;
@@ -7895,6 +7985,32 @@ var _XRInteractionSystem = class _XRInteractionSystem {
 };
 __name(_XRInteractionSystem, "XRInteractionSystem");
 var XRInteractionSystem = _XRInteractionSystem;
+var ARC_GRAVITY = 9.8;
+var ARC_SPEED = 7;
+var ARC_STEPS = 24;
+var ARC_MAX_TIME = 2;
+function sampleTeleportArc(origin, direction, out = [], options) {
+  const speed = options?.speed ?? ARC_SPEED;
+  const gravity = options?.gravity ?? ARC_GRAVITY;
+  const steps = Math.max(2, options?.steps ?? ARC_STEPS);
+  const maxTime = options?.maxTime ?? ARC_MAX_TIME;
+  out.length = 0;
+  const velocity = direction.clone().normalize().multiplyScalar(speed);
+  for (let i = 0; i < steps; i += 1) {
+    const t = i / (steps - 1) * maxTime;
+    out.push(
+      new THREE14__namespace.Vector3(
+        origin.x + velocity.x * t,
+        origin.y + velocity.y * t - 0.5 * gravity * t * t,
+        origin.z + velocity.z * t
+      )
+    );
+  }
+  return out;
+}
+__name(sampleTeleportArc, "sampleTeleportArc");
+
+// core/systems/XRLocomotionSystem.ts
 var UP = new THREE14__namespace.Vector3(0, 1, 0);
 var AXIS_DEADZONE = 0.5;
 var _XRLocomotionSystem = class _XRLocomotionSystem {
@@ -7902,13 +8018,26 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
     this.raycaster = new THREE14__namespace.Raycaster();
     /** Per-source latch so one stick push yields exactly one snap turn. */
     this.turnLatched = /* @__PURE__ */ new WeakSet();
-    /** Where the pointer currently lands, for the consumer to draw a marker. */
-    this.teleportPoint = null;
+    /** Reused arc buffer — aiming runs every frame. */
+    this.arcPoints = [];
+    /** Curve up to the landing point, for the visual system. Empty when not aiming. */
+    this.aimCurve = [];
+    this.landingPoint = null;
+    /** True once we've tried to self-heal camera parenting for this session. */
+    this.parentingChecked = false;
     this.inputSystem = inputSystem;
   }
   update(world, deltaTime) {
-    this.teleportPoint = null;
-    if (!world.isXrPresenting()) return;
+    this.aimCurve = [];
+    this.landingPoint = null;
+    if (!world.isXrPresenting()) {
+      this.parentingChecked = false;
+      return;
+    }
+    if (!this.parentingChecked) {
+      this.parentingChecked = true;
+      this.ensureCameraUnderRig(world);
+    }
     const rigEntityId = world.query(XRRigComponent, TransformComponent)[0];
     if (typeof rigEntityId !== "number") return;
     const rig = world.getComponent(rigEntityId, XRRigComponent);
@@ -7925,9 +8054,37 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
       this.applySmoothMove(world, rig, rigTransform, inputs, deltaTime);
     }
   }
+  /**
+   * Guarantee the render camera is a CHILD of the rig.
+   *
+   * Locomotion moves the rig, and three composes the head pose against
+   * `camera.parent` — so if the camera sits at the scene root instead, moving
+   * the rig does nothing at all and the player is frozen in place. Scenes
+   * authored before the rig existed (or with the camera re-parented by hand)
+   * would otherwise silently fail to move, which is exactly the symptom that is
+   * hardest to diagnose from inside a headset. Repairing it via `ParentId` lets
+   * `ObjectManagementSystem` reconcile the scene graph normally.
+   */
+  ensureCameraUnderRig(world) {
+    const rigEntityId = world.query(XRRigComponent)[0];
+    if (typeof rigEntityId !== "number") return;
+    const activeCamera = world.getCamera();
+    for (const entityId of world.query(CameraComponent, Object3DRef)) {
+      if (world.getComponent(entityId, Object3DRef)?.object !== activeCamera) {
+        continue;
+      }
+      const parent = world.getComponent(entityId, ParentId);
+      if (parent) {
+        if (parent.value !== rigEntityId) parent.value = rigEntityId;
+      } else {
+        world.addComponent(entityId, new ParentId(rigEntityId));
+      }
+      return;
+    }
+  }
   /**
    * Snap turning, not smooth turning — rotating the view continuously is the
-   * single biggest cause of VR nausea, so the comfort-safe option is the one
+   * single biggest cause of VR nausea, so the comfort-safe option is what's
    * wired to the stick.
    */
   applySnapTurn(rig, transform, inputs) {
@@ -7941,8 +8098,7 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
       }
       if (this.turnLatched.has(source)) continue;
       this.turnLatched.add(source);
-      const step = THREE14__namespace.MathUtils.degToRad(rig.snapTurnDegrees);
-      transform.rotation.y -= Math.sign(x) * step;
+      transform.rotation.y -= Math.sign(x) * THREE14__namespace.MathUtils.degToRad(rig.snapTurnDegrees);
     }
   }
   applySmoothMove(world, rig, transform, inputs, deltaTime) {
@@ -7967,16 +8123,41 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
     const targets = this.collectTeleportTargets(world);
     if (targets.length === 0) return;
     for (const input of inputs) {
-      this.raycaster.set(input.rayOrigin, input.rayDirection);
-      const hit = this.raycaster.intersectObjects(targets, true)[0];
+      if (!input.select && !input.selectEnd) continue;
+      const points = sampleTeleportArc(
+        input.rayOrigin,
+        input.rayDirection,
+        this.arcPoints
+      );
+      const hit = this.raycastArc(points, targets);
       if (!hit) continue;
-      this.teleportPoint = hit.point.clone();
+      this.landingPoint = hit.point;
+      this.aimCurve = points.slice(0, hit.segmentIndex + 1).concat(hit.point);
       if (input.selectEnd) {
         transform.position.x = hit.point.x;
         transform.position.y = hit.point.y;
         transform.position.z = hit.point.z;
+        this.aimCurve = [];
+        this.landingPoint = null;
+      }
+    }
+  }
+  /** Walk the arc segment-by-segment, returning the first surface hit. */
+  raycastArc(points, targets) {
+    for (let i = 1; i < points.length; i += 1) {
+      const from = points[i - 1];
+      const to = points[i];
+      const delta = new THREE14__namespace.Vector3().subVectors(to, from);
+      const distance = delta.length();
+      if (distance < 1e-6) continue;
+      this.raycaster.set(from, delta.divideScalar(distance));
+      this.raycaster.far = distance;
+      const hit = this.raycaster.intersectObjects(targets, true)[0];
+      if (hit) {
+        return { point: hit.point.clone(), segmentIndex: i - 1 };
       }
     }
+    return null;
   }
   collectTeleportTargets(world) {
     const objects = [];
@@ -7989,12 +8170,13 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
     }
     return objects;
   }
-  /**
-   * Where the teleport pointer currently lands this frame, or null.
-   * Consumers use this to render an aim marker.
-   */
-  getTeleportPoint() {
-    return this.teleportPoint;
+  /** Arc points up to the landing spot this frame; empty when not aiming. */
+  getAimCurve() {
+    return this.aimCurve;
+  }
+  /** Where the arc currently lands, or null when not aiming at a valid area. */
+  getLandingPoint() {
+    return this.landingPoint;
   }
 };
 __name(_XRLocomotionSystem, "XRLocomotionSystem");
@@ -8034,6 +8216,8 @@ var _XRSessionSystem = class _XRSessionSystem {
   constructor(inputSystem) {
     this.presenting = false;
     this.capabilities = NO_XR_CAPABILITIES;
+    /** Y compensation applied when a floor-relative space was requested but not granted. */
+    this.appliedOriginOffset = 0;
     this.inputSystem = inputSystem ?? null;
   }
   update(world) {
@@ -8057,11 +8241,59 @@ var _XRSessionSystem = class _XRSessionSystem {
     if (session && this.inputSystem) {
       this.inputSystem.attachSession(session);
     }
+    this.applyTrackingOrigin(world, session ?? null);
     this.forEachBehaviour(world, (behaviour) => {
       behaviour.onXRSessionStart(this.capabilities);
     });
   }
+  /**
+   * Apply the rig's authored tracking origin, and compensate when the device
+   * cannot honour it.
+   *
+   * `floor` (`local-floor`) puts Y=0 on the user's real floor, which is what a
+   * scene authored standing on the ground expects. `eye` (`local`) puts Y=0 at
+   * the headset, for seated experiences.
+   *
+   * The compensation matters: `local-floor` is only ever REQUESTED as an
+   * optional feature (requiring it would make `requestSession` reject outright
+   * on devices that lack it). When it isn't granted, the runtime silently falls
+   * back to `local` — the origin jumps to head height and a floor-authored
+   * scene swallows the user, which is exactly the "I'm standing under the
+   * building" symptom. Offsetting the rig down by the eye height restores the
+   * intended floor relationship instead of leaving it broken.
+   */
+  applyTrackingOrigin(world, session) {
+    const rigEntityId = world.query(XRRigComponent, TransformComponent)[0];
+    if (typeof rigEntityId !== "number") return;
+    const rig = world.getComponent(rigEntityId, XRRigComponent);
+    const transform = world.getComponent(rigEntityId, TransformComponent);
+    if (!rig || !transform) return;
+    const renderer = world.getRenderer();
+    const wantsFloor = rig.trackingOrigin === "floor";
+    try {
+      renderer.xr.setReferenceSpaceType(wantsFloor ? "local-floor" : "local");
+    } catch {
+    }
+    const granted = session?.enabledFeatures;
+    const floorGranted = Array.isArray(granted) ? granted.includes("local-floor") : (
+      // No report at all: trust the request, since a wrong offset is worse
+      // than none on devices that did honour it.
+      true
+    );
+    this.appliedOriginOffset = wantsFloor && !floorGranted ? rig.fallbackEyeHeight : 0;
+    if (this.appliedOriginOffset !== 0) {
+      transform.position.y -= this.appliedOriginOffset;
+    }
+  }
   handleSessionEnd(world) {
+    if (this.appliedOriginOffset !== 0) {
+      const rigEntityId = world.query(XRRigComponent, TransformComponent)[0];
+      if (typeof rigEntityId === "number") {
+        const transform = world.getComponent(rigEntityId, TransformComponent);
+        if (transform) transform.position.y += this.appliedOriginOffset;
+      }
+      this.appliedOriginOffset = 0;
+    }
     this.capabilities = NO_XR_CAPABILITIES;
     this.inputSystem?.detachSession();
     this.forEachBehaviour(world, (behaviour) => {
@@ -8155,16 +8387,75 @@ var _VRTeleportAreaSystem = class _VRTeleportAreaSystem {
 };
 __name(_VRTeleportAreaSystem, "VRTeleportAreaSystem");
 var VRTeleportAreaSystem = _VRTeleportAreaSystem;
+function createHandMaterial(preset, options) {
+  const color = new THREE14__namespace.Color(options.color);
+  switch (preset) {
+    case "ghost":
+      return new THREE14__namespace.MeshBasicMaterial({
+        color,
+        transparent: true,
+        opacity: Math.min(1, Math.max(0.05, options.opacity * 0.45)),
+        depthWrite: false,
+        side: THREE14__namespace.DoubleSide
+      });
+    case "neon":
+      return new THREE14__namespace.MeshStandardMaterial({
+        color,
+        emissive: color,
+        emissiveIntensity: Math.max(0.5, options.emissiveIntensity || 2),
+        roughness: 0.35,
+        metalness: 0,
+        transparent: options.opacity < 1,
+        opacity: options.opacity
+      });
+    case "skeleton":
+      return new THREE14__namespace.MeshBasicMaterial({
+        color,
+        wireframe: true,
+        transparent: true,
+        opacity: options.opacity
+      });
+    case "custom":
+    case "default":
+      return new THREE14__namespace.MeshStandardMaterial({
+        color,
+        roughness: 0.85,
+        metalness: 0,
+        emissive: color,
+        emissiveIntensity: Math.max(0, options.emissiveIntensity),
+        transparent: options.opacity < 1,
+        opacity: options.opacity,
+        side: THREE14__namespace.DoubleSide
+      });
+    default: {
+      return new THREE14__namespace.MeshStandardMaterial({ color });
+    }
+  }
+}
+__name(createHandMaterial, "createHandMaterial");
+function applyHandMaterial(root, material) {
+  root.traverse((child) => {
+    const mesh = child;
+    if (!mesh.isMesh) return;
+    mesh.material = material;
+  });
+}
+__name(applyHandMaterial, "applyHandMaterial");
+var SLOTS = [
+  { index: 0, side: "left" },
+  { index: 1, side: "right" }
+];
 var _XRControllerVisualSystem = class _XRControllerVisualSystem {
-  constructor(slots = 2) {
+  constructor(options) {
     this.controllerModelFactory = new XRControllerModelFactory_js.XRControllerModelFactory();
     this.handModelFactory = new XRHandModelFactory_js.XRHandModelFactory();
     this.group = new THREE14__namespace.Group();
-    this.built = false;
+    this.slots = /* @__PURE__ */ new Map();
     this.attachedTo = null;
-    /** Index → whether we've already attached visuals for that slot. */
-    this.ready = /* @__PURE__ */ new Set();
-    this.slots = slots;
+    /** Last applied preset signature, so materials rebuild only on real change. */
+    this.handStyleSignature = "";
+    this.handMaterial = null;
+    this.interactionSystem = options?.interactionSystem ?? null;
     this.group.name = "XRControllerVisuals";
     this.group.userData.ecsPreviewHidden = true;
   }
@@ -8172,23 +8463,109 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
     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;
+    this.ensureSlots(world);
+    const interactor = this.resolveInteractor(world);
+    const type = interactor?.interactorType ?? "both";
+    const showControllers = type === "controllers" || type === "both";
+    const showHands = type === "hands" || type === "both";
+    this.syncHandMaterial(interactor);
+    for (const { index, side } of SLOTS) {
+      const visuals = this.slots.get(index);
+      if (!visuals) continue;
+      visuals.controllerModel.visible = showControllers;
+      visuals.handModel.visible = showHands;
+      visuals.ray.visible = this.shouldShowRay(interactor);
+      if (showHands && this.handMaterial) {
+        applyHandMaterial(visuals.handModel, this.handMaterial);
+      }
+      this.syncCustomContent(world, visuals, side);
+    }
+  }
+  /** The scene's interactor config, if one was authored. */
+  resolveInteractor(world) {
+    const entityId = world.query(XRInteractorComponent)[0];
+    if (typeof entityId !== "number") return null;
+    return world.getComponent(entityId, XRInteractorComponent) ?? null;
+  }
+  /**
+   * Re-parent the author's left/right interactor content onto the tracked grip
+   * space so it follows the hand.
+   *
+   * `ObjectManagementSystem` reconciles ECS objects back under their ParentId
+   * every frame, so this re-attach has to be re-asserted — the same coexistence
+   * dance the AR anchor system performs.
+   */
+  syncCustomContent(world, visuals, side) {
+    let content = null;
+    for (const entityId of world.query(
+      XRInteractorSideComponent,
+      Object3DRef
+    )) {
+      const slot = world.getComponent(entityId, XRInteractorSideComponent);
+      if (slot?.side !== side) continue;
+      content = world.getComponent(entityId, Object3DRef)?.object ?? null;
+      break;
+    }
+    if (!content) {
+      visuals.attachedCustom = null;
+      return;
+    }
+    if (content.parent !== visuals.grip) {
+      visuals.grip.add(content);
+    }
+    visuals.attachedCustom = content;
+  }
+  /** Rebuild the hand material only when the authored style actually changes. */
+  syncHandMaterial(interactor) {
+    const preset = interactor?.handPreset ?? "default";
+    const color = interactor?.handColor ?? "#e8b48a";
+    const opacity = interactor?.handOpacity ?? 1;
+    const emissive = interactor?.handEmissiveIntensity ?? 0;
+    const signature = `${preset}:${color}:${opacity}:${emissive}`;
+    if (signature === this.handStyleSignature && this.handMaterial) return;
+    this.handStyleSignature = signature;
+    this.handMaterial?.dispose();
+    this.handMaterial = createHandMaterial(preset, {
+      color,
+      opacity,
+      emissiveIntensity: emissive
+    });
+  }
+  /**
+   * The ray is meaningful only when it points at something. Authors can turn it
+   * off entirely; otherwise it appears on hover/grab so it isn't permanent
+   * clutter implying the whole scene is clickable.
+   */
+  shouldShowRay(interactor) {
+    if (interactor && !interactor.showRay) return false;
+    if (!this.interactionSystem) return true;
+    return this.interactionSystem.getHoveredEntityId() !== null || this.interactionSystem.isGrabbing();
+  }
+  /** Lazily build per-slot visuals; the device reports profiles late. */
+  ensureSlots(world) {
+    const renderer = world.getRenderer();
+    for (const { index } of SLOTS) {
+      if (this.slots.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;
+      const ray = this.createRay();
+      controller.add(ray);
+      const controllerModel = this.controllerModelFactory.createControllerModel(grip);
+      grip.add(controllerModel);
+      const handModel = this.handModelFactory.createHandModel(hand, "mesh");
+      hand.add(handModel);
+      this.group.add(controller, grip, hand);
+      this.slots.set(index, {
+        controller,
+        grip,
+        hand,
+        ray,
+        controllerModel,
+        handModel,
+        attachedCustom: null
+      });
     }
   }
   /**
@@ -8216,6 +8593,7 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
     const line = new THREE14__namespace.Line(geometry, material);
     line.name = "XRPointerRay";
     line.renderOrder = 999;
+    line.visible = false;
     return line;
   }
   dispose() {
@@ -8231,13 +8609,130 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
       }
     });
     this.group.clear();
-    this.ready.clear();
-    this.built = false;
+    this.slots.clear();
+    this.handMaterial?.dispose();
+    this.handMaterial = null;
+    this.handStyleSignature = "";
     this.attachedTo = null;
   }
 };
 __name(_XRControllerVisualSystem, "XRControllerVisualSystem");
 var XRControllerVisualSystem = _XRControllerVisualSystem;
+var MARKER_RADIUS = 0.28;
+var ACCENT = new THREE14__namespace.Color("#4da3ff");
+var _XRTeleportVisualSystem = class _XRTeleportVisualSystem {
+  constructor(locomotionSystem) {
+    this.group = new THREE14__namespace.Group();
+    this.arcGeometry = new THREE14__namespace.BufferGeometry();
+    this.marker = new THREE14__namespace.Group();
+    this.attached = false;
+    this.locomotionSystem = locomotionSystem;
+    this.group.name = "XRTeleportVisuals";
+    this.group.userData.ecsPreviewHidden = true;
+    const arcMaterial = new THREE14__namespace.LineBasicMaterial({
+      vertexColors: true,
+      transparent: true,
+      depthTest: false
+    });
+    this.arc = new THREE14__namespace.Line(this.arcGeometry, arcMaterial);
+    this.arc.frustumCulled = false;
+    this.arc.renderOrder = 998;
+    this.group.add(this.arc);
+    this.marker.add(this.createRing(), this.createDot());
+    this.marker.renderOrder = 999;
+    this.group.add(this.marker);
+    this.setVisible(false);
+  }
+  update(world) {
+    if (!this.attached) {
+      world.getScene().add(this.group);
+      this.attached = true;
+    }
+    const curve = this.locomotionSystem.getAimCurve();
+    const landing = this.locomotionSystem.getLandingPoint();
+    if (!landing || curve.length < 2) {
+      this.setVisible(false);
+      return;
+    }
+    this.updateArcGeometry(curve);
+    this.marker.position.copy(landing);
+    this.marker.position.y += 0.01;
+    this.setVisible(true);
+  }
+  updateArcGeometry(curve) {
+    const count = curve.length;
+    const positions = new Float32Array(count * 3);
+    const colors = new Float32Array(count * 3);
+    for (let i = 0; i < count; i += 1) {
+      const point = curve[i];
+      positions[i * 3] = point.x;
+      positions[i * 3 + 1] = point.y;
+      positions[i * 3 + 2] = point.z;
+      const t = count > 1 ? i / (count - 1) : 0;
+      const fade = 1 - t * 0.75;
+      colors[i * 3] = ACCENT.r * fade;
+      colors[i * 3 + 1] = ACCENT.g * fade;
+      colors[i * 3 + 2] = ACCENT.b * fade;
+    }
+    this.arcGeometry.setAttribute(
+      "position",
+      new THREE14__namespace.BufferAttribute(positions, 3)
+    );
+    this.arcGeometry.setAttribute("color", new THREE14__namespace.BufferAttribute(colors, 3));
+    this.arcGeometry.computeBoundingSphere();
+  }
+  createRing() {
+    const geometry = new THREE14__namespace.RingGeometry(
+      MARKER_RADIUS * 0.72,
+      MARKER_RADIUS,
+      48
+    );
+    geometry.rotateX(-Math.PI / 2);
+    return new THREE14__namespace.Mesh(
+      geometry,
+      new THREE14__namespace.MeshBasicMaterial({
+        color: ACCENT,
+        transparent: true,
+        opacity: 0.9,
+        side: THREE14__namespace.DoubleSide,
+        depthTest: false
+      })
+    );
+  }
+  createDot() {
+    const geometry = new THREE14__namespace.CircleGeometry(MARKER_RADIUS * 0.16, 24);
+    geometry.rotateX(-Math.PI / 2);
+    return new THREE14__namespace.Mesh(
+      geometry,
+      new THREE14__namespace.MeshBasicMaterial({
+        color: ACCENT,
+        transparent: true,
+        opacity: 0.55,
+        side: THREE14__namespace.DoubleSide,
+        depthTest: false
+      })
+    );
+  }
+  setVisible(visible) {
+    this.group.visible = visible;
+  }
+  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.attached = false;
+  }
+};
+__name(_XRTeleportVisualSystem, "XRTeleportVisualSystem");
+var XRTeleportVisualSystem = _XRTeleportVisualSystem;
 
 exports.AnimationSystem = AnimationSystem;
 exports.AudioSystem = AudioSystem;
@@ -8265,5 +8760,6 @@ exports.XRInputSystem = XRInputSystem;
 exports.XRInteractionSystem = XRInteractionSystem;
 exports.XRLocomotionSystem = XRLocomotionSystem;
 exports.XRSessionSystem = XRSessionSystem;
+exports.XRTeleportVisualSystem = XRTeleportVisualSystem;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map