rig-play 1.9.1 → 1.9.2

package/README.md

@@ -219,7 +219,10 @@ apart), `pause()` / `resume()` hold and release it, `timeScale` scales every
 step, and `seek(t)` moves it to a time. A seek is "reopen, then step to the
 time" in `seekStep` increments (1/60 s by default) — never a jump, because a
 physics rig has history and its pose at a time depends on the steps that
-reached it. `on('event', …)` receives the event keys each step crosses, in the
+reached it. The physics integrates on rig-c's render clock (`physicsClockStep`:
+each step and 2⁻³⁰ of it more), so stepping at a fixed rate — `frame(1/60)`, a
+capture, a test — shows no single-frame spring jump where a frame ends on a
+physics step; the animation, the events and `time` stay on the steps (#103). `on('event', …)` receives the event keys each step crosses, in the
 runtime's order across a loop's wrap; `on('complete', …)` fires once a step
 completes a cycle. `skin` (a constructor option) poses under a named skin;
 without it the rig is posed the way a fresh Spine skeleton is, with no skin

package/dist/index.js

@@ -4927,6 +4927,17 @@ function setupPosed(doc, plant, mode) {
   if (world === null || shown === null || setup.slots === null || setup.drawOrder === null) throw new CoreInputError("the raw setup pose was not posed");
   return { world, shown, slots: setup.slots, drawOrder: setup.drawOrder };
 }
+const PHYSICS_CLOCK_LEAD = 2 ** -30;
+function physicsClockStep(step) {
+  return step + step * PHYSICS_CLOCK_LEAD;
+}
+function checkedClock(clock, who) {
+  return (dt) => {
+    const moved = clock(dt);
+    if (typeof moved !== "number" || !Number.isFinite(moved) || moved < 0) throw new CoreInputError(`${who} clock moved the physics by ${String(moved)} for a step of ${dt}, not a finite time at or above 0`);
+    return moved;
+  };
+}
 function loopedTime(trackTime, duration) {
   return duration === 0 ? 0 : trackTime % duration;
 }
@@ -5031,7 +5042,10 @@ function openTrack(doc, animation, options, plant = {}) {
   if (typeof options !== "object" || options === null || typeof options.loop !== "boolean") throw new CoreInputError(`the live track's options.loop is ${JSON.stringify(options?.loop)}, not true or false`);
   if (options.reset !== "animation" && options.reset !== "setup") throw new CoreInputError(`the live track's options.reset is ${JSON.stringify(options.reset)}, not "animation" or "setup"`);
   if (options.adjust !== void 0 && typeof options.adjust !== "function") throw new CoreInputError(`the live track's options.adjust is ${typeof options.adjust}, not a function`);
-  const { track, first } = openRawTrack(doc, animation, plant, options.reset, options.loop ? LOOPED : HELD, options.adjust);
+  if (options.clock !== void 0 && typeof options.clock !== "function") throw new CoreInputError(`the live track's options.clock is ${typeof options.clock}, not a function`);
+  const mode = options.loop ? LOOPED : HELD;
+  const clock = options.clock === void 0 ? void 0 : checkedClock(options.clock, "the live track's");
+  const { track, first } = openRawTrack(doc, animation, plant, options.reset, clock === void 0 ? mode : { ...mode, clock: (dt) => clock(dt) }, options.adjust);
   return new Track(track, first);
 }
 class Track {
@@ -5953,13 +5967,16 @@ function delayOf(v, call) {
 function openTracks(doc, options, plant = {}) {
   if (typeof options !== "object" || options === null || options.reset !== "animation" && options.reset !== "setup") throw new CoreInputError(`the live tracks' options.reset is ${JSON.stringify(options?.reset)}, not "animation" or "setup"`);
   if (options.adjust !== void 0 && typeof options.adjust !== "function") throw new CoreInputError(`the live tracks' options.adjust is ${typeof options.adjust}, not a function`);
-  return new Tracks(doc, options.reset, options.adjust, plant, openRawTracksPath(doc, plant));
+  if (options.clock !== void 0 && typeof options.clock !== "function") throw new CoreInputError(`the live tracks' options.clock is ${typeof options.clock}, not a function`);
+  const clock = options.clock === void 0 ? void 0 : checkedClock(options.clock, "the live tracks'");
+  return new Tracks(doc, options.reset, options.adjust, clock, plant, openRawTracksPath(doc, plant));
 }
 class Tracks {
-  constructor(doc, reset, adjust, plant, path) {
+  constructor(doc, reset, adjust, clock, plant, path) {
     this.doc = doc;
     this.reset = reset;
     this.adjust = adjust;
+    this.clock = clock;
     this.plant = plant;
     this.path = path;
     this.started = false;
@@ -6064,7 +6081,7 @@ class Tracks {
     const { doc, path } = this;
     const ctx = path.ctx;
     const before = ctx.time;
-    ctx.time += dt;
+    ctx.time += this.clock === void 0 ? dt : this.clock(dt);
     const pose = new Pose(doc, this.plant);
     const animationTime = this.mixer.apply(pose);
     const mixed = new Map(doc.slots.map((s, k) => [s.name, { deform: pose.slots[k].deform, seen: pose.slots[k].seen }]));
@@ -8582,7 +8599,7 @@ class RigPlayer {
     if (this.tracks === null && plain && !this.trackMode) {
       this.animation = name;
       this.loop = loop;
-      this.track = openTrack(this.view, name, { loop, reset: "animation", adjust: this.adjustHook });
+      this.track = openTrack(this.view, name, { loop, reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
       this.pose = this.track.first;
       return;
     }
@@ -8673,7 +8690,7 @@ class RigPlayer {
    */
   compose() {
     if (this.tracks !== null) return this.tracks;
-    const tracks = openTracks(this.view, { reset: "animation", adjust: this.adjustHook });
+    const tracks = openTracks(this.view, { reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
     const single = this.track;
     const time = single?.trackTime ?? 0;
     if (single !== null && this.animation !== null) {
@@ -8713,14 +8730,14 @@ class RigPlayer {
   /** 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() {
     if (this.tracks !== null) {
-      const tracks = openTracks(this.view, { reset: "animation", adjust: this.adjustHook });
+      const tracks = openTracks(this.view, { reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
       tracks.setAnimation(0, this.animation, { loop: this.loop, mixDuration: 0 });
       this.trackCount = 1;
       this.tracks = tracks;
       this.pose = tracks.start();
       return;
     }
-    this.track = openTrack(this.view, this.animation, { loop: this.loop, reset: "animation", adjust: this.adjustHook });
+    this.track = openTrack(this.view, this.animation, { loop: this.loop, reset: "animation", adjust: this.adjustHook, clock: physicsClockStep });
     this.pose = this.track.first;
   }
   /** Steps whatever is open forward to `time` in `seekStep` increments, the last one shorter. */
@@ -8748,7 +8765,11 @@ class RigPlayer {
    * Steps the track by `dt × timeScale` seconds and fires the step's listeners,
    * without drawing. A paused player, or a step of zero, keeps the pose it
    * holds without re-posing it, so a held rig costs the renderer's dirty
-   * checks and nothing else.
+   * checks and nothing else. The physics clock moves by `physicsClockStep`
+   * of the step — the step and 2⁻³⁰ of it more, rig-c's render clock — so a
+   * caller stepping at a fixed rate whose frame is a whole number of physics
+   * steps (`frame(1/60)`, a capture) shows no spring jump; the animation time,
+   * the events and `time` stay on the steps themselves (#103).
    */
   advance(dt) {
     if (this.pose === null) return;