@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-LY4T37YK.js

@@ -0,0 +1,307 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/orbital/index.ts
+var orbital_exports = {};
+__export(orbital_exports, {
+  AttentionEngine: () => AttentionEngine,
+  TimeManager: () => TimeManager,
+  calculatePosition: () => calculatePosition,
+  dateToJulian: () => dateToJulian,
+  generateOrbitalPath: () => generateOrbitalPath,
+  julianToDate: () => julianToDate,
+  toDegrees: () => toDegrees
+});
+
+// src/orbital/KeplerianCalculator.ts
+function toRadians(degrees) {
+  return degrees * (Math.PI / 180);
+}
+function toDegrees(radians) {
+  return radians * (180 / Math.PI);
+}
+function normalizeAngle(degrees) {
+  degrees = degrees % 360;
+  if (degrees < 0) degrees += 360;
+  return degrees;
+}
+function solveKeplerEquation(meanAnomaly, eccentricity, tolerance = 1e-8) {
+  let E = meanAnomaly;
+  let delta = Infinity;
+  let iterations = 0;
+  const maxIterations = 100;
+  while (Math.abs(delta) > tolerance && iterations < maxIterations) {
+    const f = E - eccentricity * Math.sin(E) - meanAnomaly;
+    const fPrime = 1 - eccentricity * Math.cos(E);
+    delta = f / fPrime;
+    E = E - delta;
+    iterations++;
+  }
+  return E;
+}
+function calculateTrueAnomaly(eccentricAnomaly, eccentricity) {
+  const cosE = Math.cos(eccentricAnomaly);
+  const sinE = Math.sin(eccentricAnomaly);
+  const cosV = (cosE - eccentricity) / (1 - eccentricity * cosE);
+  const sinV = Math.sqrt(1 - eccentricity * eccentricity) * sinE / (1 - eccentricity * cosE);
+  return Math.atan2(sinV, cosV);
+}
+function calculatePosition(elements, julianDate) {
+  const {
+    semiMajorAxis,
+    eccentricity,
+    inclination,
+    longitudeAscending,
+    argumentPeriapsis,
+    meanAnomalyEpoch,
+    orbitalPeriod
+  } = elements;
+  const meanMotion = 360 / orbitalPeriod;
+  const meanAnomaly = normalizeAngle(meanAnomalyEpoch + meanMotion * julianDate);
+  const M = toRadians(meanAnomaly);
+  const E = solveKeplerEquation(M, eccentricity);
+  const v = calculateTrueAnomaly(E, eccentricity);
+  const r = semiMajorAxis * (1 - eccentricity * Math.cos(E));
+  const xOrbital = r * Math.cos(v);
+  const yOrbital = r * Math.sin(v);
+  const i = toRadians(inclination);
+  const omega = toRadians(argumentPeriapsis);
+  const Omega = toRadians(longitudeAscending);
+  const cosOmega = Math.cos(omega);
+  const sinOmega = Math.sin(omega);
+  const cosI = Math.cos(i);
+  const sinI = Math.sin(i);
+  const cosCapOmega = Math.cos(Omega);
+  const sinCapOmega = Math.sin(Omega);
+  const x = (cosCapOmega * cosOmega - sinCapOmega * sinOmega * cosI) * xOrbital + (-cosCapOmega * sinOmega - sinCapOmega * cosOmega * cosI) * yOrbital;
+  const y = (sinCapOmega * cosOmega + cosCapOmega * sinOmega * cosI) * xOrbital + (-sinCapOmega * sinOmega + cosCapOmega * cosOmega * cosI) * yOrbital;
+  const z = sinOmega * sinI * xOrbital + cosOmega * sinI * yOrbital;
+  return { x, y, z };
+}
+function dateToJulian(date) {
+  const j2000 = (/* @__PURE__ */ new Date("2000-01-01T12:00:00Z")).getTime();
+  const ms = date.getTime();
+  return (ms - j2000) / (1e3 * 60 * 60 * 24);
+}
+function julianToDate(julianDate) {
+  const j2000 = (/* @__PURE__ */ new Date("2000-01-01T12:00:00Z")).getTime();
+  const ms = j2000 + julianDate * (1e3 * 60 * 60 * 24);
+  return new Date(ms);
+}
+function generateOrbitalPath(elements, numPoints = 100) {
+  const points = [];
+  const orbitalPeriod = elements.orbitalPeriod;
+  for (let i = 0; i < numPoints; i++) {
+    const julianDate = i / numPoints * orbitalPeriod;
+    points.push(calculatePosition(elements, julianDate));
+  }
+  points.push(points[0]);
+  return points;
+}
+
+// src/orbital/TimeManager.ts
+var TimeManager = class {
+  julianDate;
+  timeScale = 1;
+  // 1 = real-time, 10 = 10x speed
+  isPaused = false;
+  lastUpdateTime = 0;
+  callbacks = /* @__PURE__ */ new Set();
+  intervalId = null;
+  constructor(startDate = /* @__PURE__ */ new Date()) {
+    this.julianDate = dateToJulian(startDate);
+    this.lastUpdateTime = Date.now();
+  }
+  /**
+   * Start the time simulation loop
+   */
+  start() {
+    if (this.intervalId !== null) {
+      return;
+    }
+    this.lastUpdateTime = Date.now();
+    this.intervalId = setInterval(() => {
+      this.update(Date.now());
+    }, 1e3 / 60);
+  }
+  /**
+   * Stop the time simulation loop
+   */
+  stop() {
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+  /**
+   * Update tick
+   */
+  update(currentTime) {
+    if (!this.isPaused) {
+      const deltaMs = currentTime - this.lastUpdateTime;
+      this.advance(deltaMs);
+    }
+    this.lastUpdateTime = currentTime;
+  }
+  /**
+   * Advance simulation time
+   *
+   * @param deltaMs - Milliseconds elapsed in real time
+   */
+  advance(deltaMs) {
+    if (this.isPaused) return;
+    const realDays = deltaMs / (1e3 * 60 * 60 * 24);
+    const simulationDays = realDays * this.timeScale;
+    this.julianDate += simulationDays;
+    this.notifyCallbacks();
+  }
+  /**
+   * Pause time progression
+   */
+  pause() {
+    this.isPaused = true;
+  }
+  /**
+   * Resume time progression
+   */
+  play() {
+    this.isPaused = false;
+    this.lastUpdateTime = Date.now();
+  }
+  /**
+   * Toggle pause/play
+   */
+  togglePause() {
+    if (this.isPaused) {
+      this.play();
+    } else {
+      this.pause();
+    }
+  }
+  /**
+   * Set time scale (speed multiplier)
+   *
+   * @param scale - Time scale (1 = real-time, 10 = 10x speed, etc.)
+   */
+  setTimeScale(scale) {
+    this.timeScale = Math.max(0.1, scale);
+  }
+  /**
+   * Get current time scale
+   */
+  getTimeScale() {
+    return this.timeScale;
+  }
+  /**
+   * Set simulation date
+   *
+   * @param date - JavaScript Date object
+   */
+  setDate(date) {
+    this.julianDate = dateToJulian(date);
+    this.notifyCallbacks();
+  }
+  /**
+   * Get current simulation date as Julian date
+   */
+  getJulianDate() {
+    return this.julianDate;
+  }
+  /**
+   * Get current simulation date as JavaScript Date
+   */
+  getDate() {
+    return julianToDate(this.julianDate);
+  }
+  /**
+   * Check if time is paused
+   */
+  getIsPaused() {
+    return this.isPaused;
+  }
+  /**
+   * Register a callback for time updates
+   *
+   * @param callback - Function to call when time updates
+   */
+  onUpdate(callback) {
+    this.callbacks.add(callback);
+  }
+  /**
+   * Unregister a time update callback
+   *
+   * @param callback - Callback function to remove
+   */
+  offUpdate(callback) {
+    this.callbacks.delete(callback);
+  }
+  /**
+   * Notify all registered callbacks of time update
+   */
+  notifyCallbacks() {
+    const date = this.getDate();
+    for (const callback of this.callbacks) {
+      callback(this.julianDate, date);
+    }
+  }
+  /**
+   * Get time state for serialization
+   */
+  getState() {
+    return {
+      julianDate: this.julianDate,
+      timeScale: this.timeScale,
+      isPaused: this.isPaused,
+      date: this.getDate().toISOString()
+    };
+  }
+};
+
+// src/orbital/AttentionEngine.ts
+var AttentionEngine = class {
+  /**
+   * Calculates the attention weight of a target entity relative to an observer.
+   * Incorporates 4 factors: Proximity, Movement, Base Saliency, and Recency (mocked).
+   */
+  static calculateWeight(observerPos, target) {
+    const dx = target.position[0] - observerPos[0];
+    const dy = target.position[1] - observerPos[1];
+    const dz = target.position[2] - observerPos[2];
+    const distSq = dx * dx + dy * dy + dz * dz;
+    const proximityWeight = Math.max(0, 1 - distSq / 1e4);
+    let movementWeight = 0;
+    if (target.velocity) {
+      const speedSq = target.velocity.x ** 2 + target.velocity.y ** 2 + target.velocity.z ** 2;
+      movementWeight = Math.min(1, speedSq / 100);
+    }
+    const saliencyWeight = target.saliencyBase || 0.1;
+    const recencyWeight = 0.5;
+    const total = proximityWeight * 0.5 + movementWeight * 0.3 + saliencyWeight * 0.1 + recencyWeight * 0.1;
+    return Math.min(1, Math.max(0, total));
+  }
+  /**
+   * Filters a massive array of entities down to strictly the top K most attended
+   * objects around the observer to save inference/rendering payload.
+   */
+  static getTopKEntities(observerPos, entities, k) {
+    if (entities.length <= k) return entities.map((e) => e.id);
+    const scores = entities.map((e) => ({
+      entityId: e.id,
+      weight: this.calculateWeight(observerPos, e)
+    }));
+    scores.sort((a, b) => b.weight - a.weight);
+    return scores.slice(0, k).map((s) => s.entityId);
+  }
+};
+
+export {
+  toDegrees,
+  calculatePosition,
+  dateToJulian,
+  julianToDate,
+  generateOrbitalPath,
+  TimeManager,
+  AttentionEngine,
+  orbital_exports
+};