@yagejs/core 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -99,6 +99,7 @@ __export(index_exports, {
   QueryCache: () => QueryCache,
   QueryCacheKey: () => QueryCacheKey,
   QueryResult: () => QueryResult,
+  RendererAdapterKey: () => RendererAdapterKey,
   SERIALIZABLE_KEY: () => SERIALIZABLE_KEY,
   Scene: () => Scene,
   SceneHookRegistry: () => SceneHookRegistry,
@@ -265,14 +266,52 @@ var Vec2 = class _Vec2 {
   static lerp(a, b, t) {
     return new _Vec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
   }
+  /** Move current toward target by at most maxDelta without overshooting. */
+  static moveTowards(current, target, maxDelta) {
+    const dx = target.x - current.x;
+    const dy = target.y - current.y;
+    const distanceSq = dx * dx + dy * dy;
+    if (distanceSq < EPSILON * EPSILON) {
+      return new _Vec2(target.x, target.y);
+    }
+    if (maxDelta <= 0) {
+      return new _Vec2(current.x, current.y);
+    }
+    const distance = Math.sqrt(distanceSq);
+    if (distance <= maxDelta) {
+      return new _Vec2(target.x, target.y);
+    }
+    const scale = maxDelta / distance;
+    return new _Vec2(current.x + dx * scale, current.y + dy * scale);
+  }
 };
 
 // src/MathUtils.ts
+var TAU = Math.PI * 2;
+var MIN_SMOOTH_TIME = 1e-4;
+function normalizeAngle(radians) {
+  const wrapped = ((radians + Math.PI) % TAU + TAU) % TAU - Math.PI;
+  return wrapped === -Math.PI && radians > 0 ? Math.PI : wrapped;
+}
+__name(normalizeAngle, "normalizeAngle");
 var MathUtils = {
   /** Linear interpolation between a and b. */
   lerp(a, b, t) {
     return a + (b - a) * t;
   },
+  /** Return the clamped interpolation factor that produces v between a and b. */
+  inverseLerp(a, b, v) {
+    if (a === b) return 0;
+    return MathUtils.clamp((v - a) / (b - a), 0, 1);
+  },
+  /** Interpolate between angles in radians along the shortest path. */
+  lerpAngle(a, b, t) {
+    return normalizeAngle(a + MathUtils.shortestAngleBetween(a, b) * t);
+  },
+  /** Signed shortest angular delta from a to b, in radians. */
+  shortestAngleBetween(a, b) {
+    return normalizeAngle(b - a);
+  },
   /** Clamp a value between min and max. */
   clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
@@ -282,6 +321,12 @@ var MathUtils = {
     const t = (value - inMin) / (inMax - inMin);
     return outMin + (outMax - outMin) * t;
   },
+  /** Bounce t between 0 and length. */
+  pingPong(t, length) {
+    if (length <= 0) return 0;
+    const wrapped = MathUtils.wrap(t, 0, length * 2);
+    return length - Math.abs(wrapped - length);
+  },
   /** Random float in [min, max). */
   randomRange(min, max) {
     return min + Math.random() * (max - min);
@@ -305,6 +350,34 @@ var MathUtils = {
     }
     return Math.max(current - step, target);
   },
+  /**
+   * Smoothly damp current toward target without overshooting.
+   * Pass the returned velocity back into the next call.
+   */
+  smoothDamp(current, target, velocity, smoothTime, deltaTime, maxSpeed = Infinity) {
+    if (deltaTime <= 0) {
+      return { value: current, velocity };
+    }
+    const safeSmoothTime = Math.max(MIN_SMOOTH_TIME, smoothTime);
+    const omega = 2 / safeSmoothTime;
+    const x = omega * deltaTime;
+    const exp = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x);
+    const originalTarget = target;
+    const maxChange = maxSpeed * safeSmoothTime;
+    const change = MathUtils.clamp(current - target, -maxChange, maxChange);
+    const adjustedTarget = current - change;
+    const temp = (velocity + omega * change) * deltaTime;
+    const nextVelocity = (velocity - omega * temp) * exp;
+    let value = adjustedTarget + (change + temp) * exp;
+    let resultVelocity = nextVelocity;
+    const targetIsAboveCurrent = originalTarget - current > 0;
+    const valuePassedTarget = targetIsAboveCurrent ? value > originalTarget : value < originalTarget;
+    if (valuePassedTarget) {
+      value = originalTarget;
+      resultVelocity = 0;
+    }
+    return { value, velocity: resultVelocity };
+  },
   /** Wrap value into the range [min, max). */
   wrap(value, min, max) {
     const range = max - min;
@@ -2069,6 +2142,29 @@ var SceneManager = class {
   _pendingChain = Promise.resolve();
   _mutationDepth = 0;
   _destroyed = false;
+  _autoPauseOnBlur = false;
+  _isBlurred = false;
+  _visibilityPausedScenes = /* @__PURE__ */ new Set();
+  _visibilityListenerCleanup;
+  /**
+   * Pause all non-paused scenes when `document.hidden` becomes `true`; restore
+   * them on focus. Default: `false`. Only scenes paused by this mechanism are
+   * restored — user-paused scenes (manual `scene.paused = true` or `pauseBelow`
+   * cascade) are never touched.
+   */
+  get autoPauseOnBlur() {
+    return this._autoPauseOnBlur;
+  }
+  set autoPauseOnBlur(value) {
+    if (this._autoPauseOnBlur === value) return;
+    this._autoPauseOnBlur = value;
+    if (!this._isBlurred) return;
+    if (value) {
+      this._applyBlurPause();
+    } else if (this._visibilityPausedScenes.size > 0) {
+      this._restoreBlurPause();
+    }
+  }
   /**
    * Set the engine context.
    * @internal
@@ -2079,6 +2175,40 @@ var SceneManager = class {
     this.assetManager = context.tryResolve(AssetManagerKey);
     this.hookRegistry = context.tryResolve(SceneHookRegistryKey);
     this.logger = context.tryResolve(LoggerKey);
+    if (this._visibilityListenerCleanup || typeof document === "undefined") {
+      return;
+    }
+    const onVisibilityChange = /* @__PURE__ */ __name(() => {
+      this._handleVisibilityChange(document.hidden);
+    }, "onVisibilityChange");
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    this._visibilityListenerCleanup = () => document.removeEventListener("visibilitychange", onVisibilityChange);
+  }
+  /**
+   * React to a visibility change. Parameterised on `hidden` so unit tests can
+   * drive it without a real `document`.
+   * @internal
+   */
+  _handleVisibilityChange(hidden) {
+    if (hidden && !this._isBlurred) {
+      this._isBlurred = true;
+      if (this._autoPauseOnBlur) this._applyBlurPause();
+    } else if (!hidden && this._isBlurred) {
+      this._isBlurred = false;
+      if (this._visibilityPausedScenes.size > 0) this._restoreBlurPause();
+    }
+  }
+  _applyBlurPause() {
+    for (const scene of this.activeScenes) {
+      scene.paused = true;
+      this._visibilityPausedScenes.add(scene);
+    }
+  }
+  _restoreBlurPause() {
+    for (const scene of this._visibilityPausedScenes) {
+      scene.paused = false;
+    }
+    this._visibilityPausedScenes.clear();
   }
   /** The topmost (active) scene. */
   get active() {
@@ -2205,6 +2335,9 @@ var SceneManager = class {
       this._cleanupRun(this._currentRun);
     }
     this._pendingChain = Promise.resolve();
+    this._visibilityListenerCleanup?.();
+    this._visibilityListenerCleanup = void 0;
+    this._visibilityPausedScenes.clear();
     this._withMutationSync(() => {
       while (this.stack.length > 0) {
         const scene = this.stack.pop();
@@ -2324,6 +2457,7 @@ var SceneManager = class {
     scene._destroyAllEntities();
     this.hookRegistry?.runAfterExit(scene);
     scene._clearScopedServices();
+    this._visibilityPausedScenes.delete(scene);
   }
   async _runTransition(kind, transition, fromScene, toScene) {
     if (this._destroyed) return;
@@ -3445,6 +3579,11 @@ var Engine = class {
   }
 };
 
+// src/RendererAdapter.ts
+var RendererAdapterKey = new ServiceKey(
+  "rendererAdapter"
+);
+
 // src/test-utils.ts
 var _TestScene = class extends Scene {
   static {
@@ -3529,6 +3668,7 @@ var VERSION = "0.0.0";
   QueryCache,
   QueryCacheKey,
   QueryResult,
+  RendererAdapterKey,
   SERIALIZABLE_KEY,
   Scene,
   SceneHookRegistry,