rig-play 1.11.1 → 1.11.2

package/dist/index.js

@@ -8777,6 +8777,116 @@ function applySetToPose(view, raw, set) {
     clips
   };
 }
+const SEEK_FINE_STEP_LIMIT = 4096;
+const SEEK_COARSE_STRIDE = 8;
+const SEEK_EXACT_LIMIT = 1024;
+function capturePhysicsContext(ctx) {
+  const states = /* @__PURE__ */ new Map();
+  for (const [name, s] of ctx.states) states.set(name, { ...s });
+  return {
+    phase: ctx.phase,
+    time: ctx.time,
+    last: ctx.last,
+    loop: ctx.loop,
+    env: ctx.env,
+    states
+  };
+}
+function restorePhysicsContext(ctx, snap) {
+  ctx.phase = snap.phase;
+  ctx.time = snap.time;
+  ctx.last = snap.last;
+  if (snap.loop === void 0) delete ctx.loop;
+  else ctx.loop = snap.loop;
+  if (snap.env === void 0) delete ctx.env;
+  else ctx.env = snap.env;
+  ctx.states.clear();
+  for (const [name, s] of snap.states) ctx.states.set(name, { ...s });
+}
+function captureStepperState(stepper) {
+  if ("first" in stepper) {
+    const internal2 = stepper;
+    return {
+      kind: "track",
+      steps: internal2.steps,
+      latest: internal2.latest,
+      refused: internal2.refused,
+      trackTime: internal2.track.trackTime,
+      last: internal2.track.last,
+      ctx: capturePhysicsContext(internal2.track.ctx)
+    };
+  }
+  const internal = stepper;
+  const entry = internal.mixer.tracks[0] ?? null;
+  return {
+    kind: "tracks",
+    started: internal.started,
+    steps: internal.steps,
+    time: internal.time,
+    refused: internal.refused,
+    animationsChanged: internal.mixer.animationsChanged,
+    propertyIds: new Map(internal.mixer.propertyIds),
+    entry: entry === null ? null : {
+      delay: entry.delay,
+      trackTime: entry.trackTime,
+      trackLast: entry.trackLast,
+      nextTrackLast: entry.nextTrackLast,
+      trackEnd: entry.trackEnd,
+      animationLast: entry.animationLast,
+      nextAnimationLast: entry.nextAnimationLast,
+      mixTime: entry.mixTime,
+      mixDuration: entry.mixDuration,
+      totalAlpha: entry.totalAlpha,
+      alpha: entry.alpha,
+      additive: entry.additive,
+      keepHold: entry.keepHold,
+      timelineMode: [...entry.timelineMode],
+      timelineHoldMix: [...entry.timelineHoldMix],
+      timelinesRotation: [...entry.timelinesRotation]
+    },
+    ctx: capturePhysicsContext(internal.path.ctx)
+  };
+}
+function restoreStepperState(stepper, snap) {
+  if (snap.kind === "track") {
+    const internal2 = stepper;
+    internal2.steps = snap.steps;
+    internal2.latest = snap.latest;
+    internal2.refused = snap.refused;
+    internal2.track.trackTime = snap.trackTime;
+    internal2.track.last = snap.last;
+    restorePhysicsContext(internal2.track.ctx, snap.ctx);
+    return;
+  }
+  const internal = stepper;
+  internal.started = snap.started;
+  internal.steps = snap.steps;
+  internal.time = snap.time;
+  internal.refused = snap.refused;
+  internal.mixer.animationsChanged = snap.animationsChanged;
+  internal.mixer.propertyIds.clear();
+  for (const [k, v] of snap.propertyIds) internal.mixer.propertyIds.set(k, v);
+  const entry = internal.mixer.tracks[0] ?? null;
+  if (entry !== null && snap.entry !== null) {
+    entry.delay = snap.entry.delay;
+    entry.trackTime = snap.entry.trackTime;
+    entry.trackLast = snap.entry.trackLast;
+    entry.nextTrackLast = snap.entry.nextTrackLast;
+    entry.trackEnd = snap.entry.trackEnd;
+    entry.animationLast = snap.entry.animationLast;
+    entry.nextAnimationLast = snap.entry.nextAnimationLast;
+    entry.mixTime = snap.entry.mixTime;
+    entry.mixDuration = snap.entry.mixDuration;
+    entry.totalAlpha = snap.entry.totalAlpha;
+    entry.alpha = snap.entry.alpha;
+    entry.additive = snap.entry.additive;
+    entry.keepHold = snap.entry.keepHold;
+    entry.timelineMode = [...snap.entry.timelineMode];
+    entry.timelineHoldMix = [...snap.entry.timelineHoldMix];
+    entry.timelinesRotation = [...snap.entry.timelinesRotation];
+  }
+  restorePhysicsContext(internal.path.ctx, snap.ctx);
+}
 class RigPlayer {
   /**
    * The renderer this player draws through — its knobs and counters are the
@@ -8831,6 +8941,7 @@ class RigPlayer {
   /** The un-overridden pose from the track/tracks (or setup pose when `setSet` is called before `play`). */
   rawPose = null;
   setup = null;
+  seekCache = null;
   setList;
   setsByName;
   activeSet = null;
@@ -8928,6 +9039,7 @@ class RigPlayer {
     const alpha = options.alpha ?? 1;
     const additive = options.additive ?? false;
     this.paused = false;
+    this.clearSeekCache();
     const plain = track === 0 && mix === 0 && alpha === 1 && !additive;
     if (!plain) this.beyondBase = true;
     if (this.tracks === null && plain && !this.trackMode) {
@@ -8956,6 +9068,7 @@ class RigPlayer {
   queue(name, options = {}) {
     const track = options.track ?? 0;
     this.beyondBase = true;
+    this.clearSeekCache();
     const tracks = this.compose();
     tracks.addAnimation(track, name, { loop: options.loop ?? true, mixDuration: options.mix ?? 0, delay: options.delay ?? 0, alpha: options.alpha ?? 1, additive: options.additive ?? false });
     this.trackCount = Math.max(this.trackCount, track + 1);
@@ -8968,6 +9081,7 @@ class RigPlayer {
    */
   clear(track = 0, options = {}) {
     this.beyondBase = true;
+    this.clearSeekCache();
     const tracks = this.compose();
     tracks.setEmptyAnimation(track, options.mix ?? 0);
     this.trackCount = Math.max(this.trackCount, track + 1);
@@ -8981,6 +9095,7 @@ class RigPlayer {
    */
   queueClear(track = 0, options = {}) {
     this.beyondBase = true;
+    this.clearSeekCache();
     const tracks = this.compose();
     tracks.addEmptyAnimation(track, options.mix ?? 0, options.delay ?? 0);
     this.trackCount = Math.max(this.trackCount, track + 1);
@@ -8995,6 +9110,7 @@ class RigPlayer {
    */
   setAlpha(track, alpha) {
     this.beyondBase = true;
+    this.clearSeekCache();
     const tracks = this.compose();
     tracks.setAlpha(track, alpha);
     this.setRawPose(tracks.step(0));
@@ -9025,6 +9141,7 @@ class RigPlayer {
    */
   compose() {
     if (this.tracks !== null) return this.tracks;
+    this.clearSeekCache();
     const tracks = openTracks(this.view, { reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
     const single = this.track;
     const time = single?.trackTime ?? 0;
@@ -9061,8 +9178,10 @@ class RigPlayer {
   environment(environment) {
     if (environment === null) {
       this.env = null;
+      this.clearSeekCache();
       this.stepper()?.setEnvironment(DEFAULT_ENVIRONMENT);
     } else if (environment !== void 0) {
+      this.clearSeekCache();
       const live = this.stepper();
       if (live) {
         live.setEnvironment(environment);
@@ -9101,20 +9220,99 @@ class RigPlayer {
     this.paused = false;
   }
   /**
-   * Moves a single animation on track 0 to `time`: the tracks are reopened
-   * with that animation and stepped forward in `seekStep` increments (the
-   * last one shorter) until the time is reached. Events and completes crossed
-   * on the way are not fired. It has a meaning for one animation on one
-   * track only — the player cannot replay when a mix, a second track or a
-   * queue was asked for — so after any of those it refuses by name; step the
-   * player forward instead.
+   * Moves a single animation on track 0 to `time`: snapshot-backed deterministic
+   * seek (#141) that produces the exact pose and physics state of reopening at 0
+   * and stepping forward in `seekStep` increments (the last one shorter) until
+   * `time` is reached. Events and completes crossed on the way are not fired.
+   * It has a meaning for one animation on one track only — the player cannot
+   * replay when a mix, a second track or a queue was asked for — so after any
+   * of those it refuses by name; step the player forward instead.
    */
   seek(time) {
     if (this.animation === null) throw new Error("seek before play: no animation is open");
     if (!(time >= 0) || !Number.isFinite(time)) throw new Error(`seek time must be a finite time at or above 0, got ${String(time)}`);
     if (this.beyondBase) throw new Error("seek is defined for a single animation on track 0; after a mix, another track, a queue or a clear the player cannot replay to a time — step it forward with frame/advance instead");
-    this.reopen();
-    this.stepTo(time);
+    const cache = this.ensureSeekCache();
+    const stepper = this.tracks ?? this.track;
+    const exactHit = cache.exact.get(time);
+    if (exactHit !== void 0) {
+      restoreStepperState(stepper, exactHit.state);
+      this.rawPose = exactHit.rawPose;
+      this.pose = exactHit.pose;
+      return;
+    }
+    const steps = Math.floor(time / this.seekStep);
+    while (cache.frontierSteps < steps) {
+      const raw = cache.frontier.step(this.seekStep);
+      cache.frontierSteps++;
+      if (cache.frontierSteps <= SEEK_FINE_STEP_LIMIT || cache.frontierSteps % SEEK_COARSE_STRIDE === 0) {
+        cache.grid.set(cache.frontierSteps, {
+          state: captureStepperState(cache.frontier),
+          rawPose: raw
+        });
+      }
+    }
+    const gridHit = cache.grid.get(steps);
+    if (gridHit !== void 0) {
+      restoreStepperState(stepper, gridHit.state);
+      this.rawPose = gridHit.rawPose;
+    } else {
+      const baseStep = steps - steps % SEEK_COARSE_STRIDE;
+      const baseSnap = cache.grid.get(baseStep);
+      restoreStepperState(stepper, baseSnap.state);
+      this.rawPose = baseSnap.rawPose;
+      for (let i = baseStep; i < steps; i++) this.rawPose = stepper.step(this.seekStep);
+    }
+    const rest = time - stepper.trackTime;
+    if (rest > 0) this.rawPose = stepper.step(rest);
+    if (this.rawPose !== null) this.setRawPose(this.rawPose);
+    if (this.rawPose !== null && this.pose !== null) {
+      if (cache.exact.size >= SEEK_EXACT_LIMIT) {
+        const oldest = cache.exact.keys().next().value;
+        if (oldest !== void 0) cache.exact.delete(oldest);
+      }
+      cache.exact.set(time, {
+        state: captureStepperState(stepper),
+        rawPose: this.rawPose,
+        pose: this.pose
+      });
+    }
+  }
+  clearSeekCache() {
+    this.seekCache = null;
+  }
+  ensureSeekCache() {
+    const mode = this.tracks !== null ? "tracks" : "track";
+    if (this.seekCache !== null && this.seekCache.mode === mode) {
+      return this.seekCache;
+    }
+    if (this.tracks === null && this.track === null) {
+      this.reopen();
+    }
+    let frontier;
+    let firstPose;
+    if (mode === "tracks") {
+      const tracks = openTracks(this.view, { reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
+      tracks.setAnimation(0, this.animation, { loop: this.loop, mixDuration: 0 });
+      firstPose = tracks.start();
+      this.applyEnvironment(tracks);
+      frontier = tracks;
+    } else {
+      const track = openTrack(this.view, this.animation, { loop: this.loop, reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
+      firstPose = track.first;
+      this.applyEnvironment(track);
+      frontier = track;
+    }
+    const grid = /* @__PURE__ */ new Map();
+    grid.set(0, { state: captureStepperState(frontier), rawPose: firstPose });
+    this.seekCache = {
+      mode,
+      frontier,
+      frontierSteps: 0,
+      grid,
+      exact: /* @__PURE__ */ new Map()
+    };
+    return this.seekCache;
   }
   /** Whatever is open, opened again with track 0's animation as `play` last set it, at pose 0: the single track, or the tracks under `tracks: true`. */
   reopen() {
@@ -9217,6 +9415,7 @@ class RigPlayer {
     this.source = frameSource(view, this.read.parsed);
     this.skinName = name;
     this.setup = null;
+    this.clearSeekCache();
     if (this.animation !== null && (this.track !== null || this.tracks !== null)) {
       const time = this.time;
       this.reopen();
@@ -9259,6 +9458,7 @@ class RigPlayer {
     }
     if (name === null) {
       this.activeSet = null;
+      this.clearSeekCache();
       const base2 = this.rawPose ?? (this.setup ?? (this.setup = poseRawSetup(this.view)));
       this.rawPose = base2;
       this.pose = base2;
@@ -9271,6 +9471,7 @@ class RigPlayer {
       );
     }
     this.activeSet = found;
+    this.clearSeekCache();
     const base = this.rawPose ?? (this.setup ?? (this.setup = poseRawSetup(this.view)));
     this.rawPose = base;
     this.pose = applySetToPose(this.view, base, found);
@@ -9320,6 +9521,7 @@ class RigPlayer {
   set adjust(fn) {
     if (fn !== null && typeof fn !== "function") throw new Error(`adjust must be a function or null, got ${typeof fn}`);
     this.adjustFn = fn;
+    this.clearSeekCache();
     this.repose();
   }
   /**
@@ -9330,6 +9532,7 @@ class RigPlayer {
    * changed, then `draw`. Nothing before `play`.
    */
   repose() {
+    this.clearSeekCache();
     const stepper = this.tracks ?? this.track;
     if (stepper === null || this.pose === null) return;
     this.setRawPose(stepper.step(0));
@@ -9422,6 +9625,7 @@ class RigPlayer {
   /** Removes the renderer's elements and hands its GPU pages back. The assets stay the caller's. */
   dispose() {
     this.renderer.dispose();
+    this.clearSeekCache();
     this.tracks = null;
     this.track = null;
     this.pose = null;