@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-KBVD5K7E.js

@@ -0,0 +1,560 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/vr/index.ts
+var vr_exports = {};
+__export(vr_exports, {
+  HandTracker: () => HandTracker,
+  HapticFeedback: () => HapticFeedback,
+  VRLocomotion: () => VRLocomotion,
+  WebXRManager: () => WebXRManager,
+  WebXRSystem: () => WebXRSystem
+});
+
+// src/vr/HandTracker.ts
+var HandTracker = class {
+  hands = /* @__PURE__ */ new Map();
+  gestureHistory = [];
+  maxHistory = 100;
+  constructor() {
+    this.hands.set("left", this.createDefaultState("left"));
+    this.hands.set("right", this.createDefaultState("right"));
+  }
+  createDefaultState(side) {
+    return {
+      side,
+      tracked: false,
+      joints: /* @__PURE__ */ new Map(),
+      gesture: "none",
+      confidence: 0,
+      pinchStrength: 0,
+      gripStrength: 0
+    };
+  }
+  /**
+   * Update joint positions for a hand
+   */
+  updateJoints(side, joints) {
+    const state = this.hands.get(side);
+    state.tracked = true;
+    state.joints.clear();
+    for (const [name, pos] of Object.entries(joints)) {
+      state.joints.set(name, pos);
+    }
+    state.gesture = this.detectGesture(state);
+    this.gestureHistory.push({ side, gesture: state.gesture, timestamp: Date.now() });
+    if (this.gestureHistory.length > this.maxHistory) this.gestureHistory.shift();
+  }
+  /**
+   * Update pinch/grip strength
+   */
+  updateStrength(side, pinch, grip) {
+    const state = this.hands.get(side);
+    state.pinchStrength = pinch;
+    state.gripStrength = grip;
+  }
+  /**
+   * Detect gesture from joint positions
+   */
+  detectGesture(state) {
+    if (state.pinchStrength > 0.8) return "pinch";
+    if (state.gripStrength > 0.8) return "grab";
+    const thumb = state.joints.get("thumb_tip");
+    const index = state.joints.get("index_tip");
+    const middle = state.joints.get("middle_tip");
+    if (thumb && index && middle) {
+      const indexDist = Math.sqrt(
+        (thumb.x - index.x) ** 2 + (thumb.y - index.y) ** 2 + (thumb.z - index.z) ** 2
+      );
+      if (indexDist > 0.1 && state.gripStrength < 0.3) return "point";
+    }
+    if (state.gripStrength > 0.6) return "fist";
+    if (state.gripStrength < 0.2 && state.pinchStrength < 0.2) return "open";
+    return "none";
+  }
+  getHand(side) {
+    return this.hands.get(side);
+  }
+  isTracked(side) {
+    return this.hands.get(side).tracked;
+  }
+  getGesture(side) {
+    return this.hands.get(side).gesture;
+  }
+  getGestureHistory() {
+    return [...this.gestureHistory];
+  }
+  getJoint(side, joint) {
+    return this.hands.get(side).joints.get(joint);
+  }
+};
+
+// src/vr/HapticFeedback.ts
+var HapticFeedback = class {
+  patterns = /* @__PURE__ */ new Map();
+  activePulses = [];
+  enabled = true;
+  globalIntensity = 1;
+  constructor() {
+    this.registerPresets();
+  }
+  registerPresets() {
+    this.registerPattern({
+      name: "tap",
+      loop: false,
+      pulses: [{ hand: "right", intensity: 0.5, durationMs: 50, frequency: 200 }]
+    });
+    this.registerPattern({
+      name: "grab",
+      loop: false,
+      pulses: [
+        { hand: "right", intensity: 0.3, durationMs: 30, frequency: 150 },
+        { hand: "right", intensity: 0.7, durationMs: 100, frequency: 250 }
+      ]
+    });
+    this.registerPattern({
+      name: "impact",
+      loop: false,
+      pulses: [{ hand: "both", intensity: 1, durationMs: 150, frequency: 300 }]
+    });
+    this.registerPattern({
+      name: "heartbeat",
+      loop: true,
+      pulses: [
+        { hand: "both", intensity: 0.6, durationMs: 80, frequency: 100 },
+        { hand: "both", intensity: 0.3, durationMs: 60, frequency: 100 }
+      ]
+    });
+  }
+  /**
+   * Register a haptic pattern
+   */
+  registerPattern(pattern) {
+    this.patterns.set(pattern.name, pattern);
+  }
+  /**
+   * Play a named pattern
+   */
+  play(patternName, hand) {
+    if (!this.enabled) return false;
+    const pattern = this.patterns.get(patternName);
+    if (!pattern) return false;
+    const now = Date.now();
+    for (const pulse of pattern.pulses) {
+      const effective = {
+        ...pulse,
+        hand: hand ?? pulse.hand,
+        intensity: pulse.intensity * this.globalIntensity
+      };
+      this.activePulses.push({ hand: effective.hand, pulse: effective, startTime: now });
+    }
+    return true;
+  }
+  /**
+   * Fire a single custom pulse
+   */
+  pulse(hand, intensity, durationMs, frequency = 200) {
+    if (!this.enabled) return;
+    const p = {
+      hand,
+      intensity: intensity * this.globalIntensity,
+      durationMs,
+      frequency
+    };
+    this.activePulses.push({ hand, pulse: p, startTime: Date.now() });
+  }
+  /**
+   * Stop all active haptics
+   */
+  stopAll() {
+    this.activePulses = [];
+  }
+  /**
+   * Get active pulse count
+   */
+  getActivePulseCount() {
+    return this.activePulses.length;
+  }
+  getPatternCount() {
+    return this.patterns.size;
+  }
+  getPattern(name) {
+    return this.patterns.get(name);
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  setGlobalIntensity(v) {
+    this.globalIntensity = Math.max(0, Math.min(1, v));
+  }
+  getGlobalIntensity() {
+    return this.globalIntensity;
+  }
+};
+
+// src/vr/VRLocomotion.ts
+var VRLocomotion = class {
+  config;
+  position = [0, 0, 0];
+  rotation = 0;
+  // yaw in degrees
+  teleportHistory = [];
+  boundaryDistance = Infinity;
+  constructor(config) {
+    this.config = {
+      mode: config?.mode ?? "teleport",
+      moveSpeed: config?.moveSpeed ?? 2,
+      snapAngle: config?.snapAngle ?? 45,
+      teleportRange: config?.teleportRange ?? 10,
+      boundaryFadeDistance: config?.boundaryFadeDistance ?? 0.5,
+      comfortVignette: config?.comfortVignette ?? true
+    };
+  }
+  /**
+   * Teleport to a target position
+   */
+  teleport(target) {
+    if (!target.valid) return false;
+    const dist = Math.sqrt((target.x - this.position[0]) ** 2 + (target.z - this.position[2]) ** 2);
+    if (dist > this.config.teleportRange) return false;
+    this.position = [target.x, target.y, target.z];
+    this.teleportHistory.push(target);
+    return true;
+  }
+  /**
+   * Smooth move
+   */
+  move(dx, dz, deltaTime) {
+    const speed = this.config.moveSpeed * deltaTime;
+    const rad = this.rotation * Math.PI / 180;
+    this.position[0] += (dx * Math.cos(rad) - dz * Math.sin(rad)) * speed;
+    this.position[2] += (dx * Math.sin(rad) + dz * Math.cos(rad)) * speed;
+  }
+  /**
+   * Snap turn
+   */
+  snapTurn(direction) {
+    this.rotation += direction === "right" ? this.config.snapAngle : -this.config.snapAngle;
+    this.rotation = (this.rotation % 360 + 360) % 360;
+  }
+  /**
+   * Update boundary distance
+   */
+  updateBoundary(distance) {
+    this.boundaryDistance = distance;
+  }
+  /**
+   * Get boundary fade factor (0 = fully faded, 1 = clear)
+   */
+  getBoundaryFade() {
+    if (this.boundaryDistance >= this.config.boundaryFadeDistance) return 1;
+    return Math.max(0, this.boundaryDistance / this.config.boundaryFadeDistance);
+  }
+  /**
+   * Should show comfort vignette
+   */
+  shouldShowVignette() {
+    return this.config.comfortVignette && this.config.mode === "smooth";
+  }
+  getPosition() {
+    return { x: this.position[0], y: this.position[1], z: this.position[2] };
+  }
+  getRotation() {
+    return this.rotation;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  setMode(mode) {
+    this.config.mode = mode;
+  }
+  getTeleportHistory() {
+    return [...this.teleportHistory];
+  }
+};
+
+// src/vr/WebXRManager.ts
+var WebXRManager = class {
+  session = null;
+  referenceSpace = null;
+  localReferenceSpace = null;
+  glContext = null;
+  // Callback for the render loop
+  onFrameCallback = null;
+  // Callbacks for session state
+  onSessionStart = null;
+  onSessionEnd = null;
+  constructor(context) {
+    if (context) {
+      this.glContext = context;
+    }
+  }
+  /**
+   * Check if VR is supported
+   */
+  async isSessionSupported() {
+    if (typeof navigator !== "undefined" && "xr" in navigator) {
+      return navigator.xr.isSessionSupported("immersive-vr");
+    }
+    return false;
+  }
+  /**
+   * Request an immersive VR session
+   */
+  async requestSession() {
+    if (!this.session) {
+      const sessionInit = { optionalFeatures: ["local-floor", "bounded-floor", "hand-tracking"] };
+      this.session = await navigator.xr.requestSession("immersive-vr", sessionInit);
+      this.session.addEventListener("end", this.onSessionEnded);
+      this.referenceSpace = await this.session.requestReferenceSpace("local-floor");
+      this.localReferenceSpace = await this.session.requestReferenceSpace("local");
+      if (this.onSessionStart) {
+        this.onSessionStart(this.session);
+      }
+      return this.session;
+    }
+    return this.session;
+  }
+  /**
+   * End the current session
+   */
+  async endSession() {
+    if (this.session) {
+      await this.session.end();
+    }
+  }
+  onSessionEnded = () => {
+    this.session = null;
+    this.referenceSpace = null;
+    this.localReferenceSpace = null;
+    if (this.onSessionEnd) {
+      this.onSessionEnd();
+    }
+  };
+  /**
+   * Start the XR render loop
+   */
+  setAnimationLoop(callback) {
+    this.onFrameCallback = callback;
+    if (this.session) {
+      this.session.requestAnimationFrame(this.onXRFrame);
+    }
+  }
+  onXRFrame = (time, frame) => {
+    if (!this.session) return;
+    const session = frame.session;
+    session.requestAnimationFrame(this.onXRFrame);
+    if (this.onFrameCallback) {
+      this.onFrameCallback(time, frame);
+    }
+  };
+  /**
+   * Get the current reference space (prefer local-floor)
+   */
+  getReferenceSpace() {
+    return this.referenceSpace || this.localReferenceSpace;
+  }
+  getSession() {
+    return this.session;
+  }
+};
+
+// src/vr/WebXRSystem.ts
+var WebXRSystem = class {
+  name = "WebXR";
+  priority = 50;
+  // Early — before physics needs controller input
+  mode = "inactive";
+  frameData = null;
+  eventListeners = /* @__PURE__ */ new Map();
+  supported = false;
+  // Stereo camera matrices
+  leftEye = null;
+  rightEye = null;
+  // Controller tracking
+  controllers = /* @__PURE__ */ new Map();
+  handJoints = /* @__PURE__ */ new Map();
+  // Physics integration callbacks
+  grabCallbacks = [];
+  releaseCallbacks = [];
+  // Locomotion
+  locomotionSpeed = 3;
+  // m/s
+  teleportTarget = null;
+  playerPosition = { x: 0, y: 0, z: 0 };
+  playerRotation = 0;
+  // Y-axis radians
+  // ---------------------------------------------------------------------------
+  // Lifecycle (EngineSystem)
+  // ---------------------------------------------------------------------------
+  async init() {
+    if (typeof navigator !== "undefined" && "xr" in navigator) {
+      try {
+        this.supported = await navigator.xr.isSessionSupported("immersive-vr");
+      } catch {
+        this.supported = false;
+      }
+    }
+  }
+  update(dt) {
+    if (this.mode === "inactive" || !this.frameData) return;
+    for (const [id, input] of this.controllers) {
+      if (input.grip > 0.8) {
+        for (const cb of this.grabCallbacks) cb(id, input.position);
+      }
+      if (id.includes("left") && (Math.abs(input.thumbstick.x) > 0.1 || Math.abs(input.thumbstick.y) > 0.1)) {
+        const sinR = Math.sin(this.playerRotation);
+        const cosR = Math.cos(this.playerRotation);
+        this.playerPosition.x += (input.thumbstick.x * cosR - input.thumbstick.y * sinR) * this.locomotionSpeed * dt;
+        this.playerPosition.z += (input.thumbstick.x * sinR + input.thumbstick.y * cosR) * this.locomotionSpeed * dt;
+      }
+      if (id.includes("right") && Math.abs(input.thumbstick.x) > 0.6) {
+        this.playerRotation += Math.sign(input.thumbstick.x) * (Math.PI / 6);
+      }
+    }
+    if (this.teleportTarget) {
+      this.playerPosition = { ...this.teleportTarget };
+      this.teleportTarget = null;
+    }
+  }
+  destroy() {
+    this.mode = "inactive";
+    this.frameData = null;
+    this.controllers.clear();
+    this.handJoints.clear();
+    this.eventListeners.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Session Management
+  // ---------------------------------------------------------------------------
+  isSupported() {
+    return this.supported;
+  }
+  getMode() {
+    return this.mode;
+  }
+  /** Simulate entering VR mode (for testing without real WebXR). */
+  enterVR() {
+    this.mode = "immersive-vr";
+    this.emit("sessionstart");
+  }
+  /** Simulate entering AR mode. */
+  enterAR() {
+    this.mode = "immersive-ar";
+    this.emit("sessionstart");
+  }
+  /** Exit immersive mode. */
+  exit() {
+    const wasActive = this.mode !== "inactive";
+    this.mode = "inactive";
+    this.frameData = null;
+    if (wasActive) this.emit("sessionend");
+  }
+  // ---------------------------------------------------------------------------
+  // Frame Data Injection (from actual WebXR or mock)
+  // ---------------------------------------------------------------------------
+  /**
+   * Submit frame data from the XR runtime.
+   * In production, this is called from the XR animation frame callback.
+   * In tests, this can be called manually with mock data.
+   */
+  submitFrame(data) {
+    this.frameData = data;
+    this.controllers = data.controllers;
+    this.handJoints = data.hands;
+    this.leftEye = data.views.find((v) => v.eye === "left") ?? null;
+    this.rightEye = data.views.find((v) => v.eye === "right") ?? null;
+  }
+  // ---------------------------------------------------------------------------
+  // Controller / Hand Queries
+  // ---------------------------------------------------------------------------
+  getController(id) {
+    return this.controllers.get(id);
+  }
+  getAllControllers() {
+    return new Map(this.controllers);
+  }
+  getHandJoints(side) {
+    return this.handJoints.get(side);
+  }
+  getHeadPosition() {
+    return this.frameData?.headPosition ?? { x: 0, y: 0, z: 0 };
+  }
+  getHeadRotation() {
+    return this.frameData?.headRotation ?? { x: 0, y: 0, z: 0 };
+  }
+  // ---------------------------------------------------------------------------
+  // Stereo Rendering
+  // ---------------------------------------------------------------------------
+  getLeftEye() {
+    return this.leftEye;
+  }
+  getRightEye() {
+    return this.rightEye;
+  }
+  getStereoViews() {
+    const views = [];
+    if (this.leftEye) views.push(this.leftEye);
+    if (this.rightEye) views.push(this.rightEye);
+    return views;
+  }
+  // ---------------------------------------------------------------------------
+  // Locomotion
+  // ---------------------------------------------------------------------------
+  getPlayerPosition() {
+    return { ...this.playerPosition };
+  }
+  getPlayerRotation() {
+    return this.playerRotation;
+  }
+  setLocomotionSpeed(speed) {
+    this.locomotionSpeed = speed;
+  }
+  /** Queue a teleport to a world position. Executes next frame. */
+  teleportTo(target) {
+    this.teleportTarget = { ...target };
+  }
+  // ---------------------------------------------------------------------------
+  // Physics Integration Callbacks
+  // ---------------------------------------------------------------------------
+  onGrab(cb) {
+    this.grabCallbacks.push(cb);
+  }
+  onRelease(cb) {
+    this.releaseCallbacks.push(cb);
+  }
+  // ---------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------
+  on(type, callback) {
+    if (!this.eventListeners.has(type)) this.eventListeners.set(type, []);
+    this.eventListeners.get(type).push(callback);
+  }
+  off(type, callback) {
+    const list = this.eventListeners.get(type);
+    if (list) {
+      const idx = list.indexOf(callback);
+      if (idx >= 0) list.splice(idx, 1);
+    }
+  }
+  emit(type, inputSource) {
+    const listeners = this.eventListeners.get(type);
+    if (listeners) {
+      const event = { type, inputSource, time: performance.now() };
+      for (const cb of listeners) cb(event);
+    }
+  }
+};
+
+export {
+  HandTracker,
+  HapticFeedback,
+  VRLocomotion,
+  WebXRManager,
+  WebXRSystem,
+  vr_exports
+};