@ikijs/engine 0.1.1 → 0.3.0

package/dist/index.mjs

@@ -1049,6 +1049,8 @@ var SWAY_X_AMP_B_DEG = 1.3;
 var SWAY_X_PERIOD_B_MS = 9700;
 var SWAY_Y_AMP_DEG = 1.6;
 var SWAY_Y_PERIOD_MS = 7300;
+var SWAY_Z_AMP_DEG = 1.1;
+var SWAY_Z_PERIOD_MS = 11300;
 function lerp(a, b, t) {
   return a + (b - a) * t;
 }
@@ -1061,6 +1063,22 @@ function randomInDisk(rng, radius) {
   return [r * Math.cos(theta), r * Math.sin(theta)];
 }
 var IdleMotion = class {
+  /**
+   * Every parameter id {@link update} and `emitRestingPose` write, in write
+   * order. Published so a host (or IkiMotion) can restore them after it
+   * stops driving — keep in step with those two methods; the test suite
+   * pins this list to the actual emissions.
+   */
+  drivenParameterIds = [
+    StandardParameter.EyeOpenLeft,
+    StandardParameter.EyeOpenRight,
+    StandardParameter.Breath,
+    StandardParameter.EyeballX,
+    StandardParameter.EyeballY,
+    StandardParameter.AngleX,
+    StandardParameter.AngleY,
+    StandardParameter.AngleZ
+  ];
   sink;
   rng;
   // Internal clock: advances by clamped dt, NOT by raw wall-clock jumps.
@@ -1122,6 +1140,7 @@ var IdleMotion = class {
     this.sink(StandardParameter.EyeballY, this.gazeCurrentY);
     this.sink(StandardParameter.AngleX, this.swayX());
     this.sink(StandardParameter.AngleY, this.swayY());
+    this.sink(StandardParameter.AngleZ, this.swayZ());
   }
   // ---------------------------------------------------------------------------
   // Private helpers
@@ -1134,6 +1153,7 @@ var IdleMotion = class {
     this.sink(StandardParameter.EyeballY, 0);
     this.sink(StandardParameter.AngleX, 0);
     this.sink(StandardParameter.AngleY, 0);
+    this.sink(StandardParameter.AngleZ, 0);
   }
   /** Returns the current eye-open value (0..1) and advances blink state. */
   advanceBlink() {
@@ -1165,6 +1185,10 @@ var IdleMotion = class {
   swayY() {
     return SWAY_Y_AMP_DEG * Math.sin(2 * Math.PI * this.clockMs / SWAY_Y_PERIOD_MS);
   }
+  /** Head roll sway in degrees, pure function of the internal clock. */
+  swayZ() {
+    return SWAY_Z_AMP_DEG * Math.sin(2 * Math.PI * this.clockMs / SWAY_Z_PERIOD_MS);
+  }
   /** Ease gaze current toward target; pick a new target on the internal clock. */
   advanceGaze(dt) {
     if (this.clockMs >= this.nextGazeRetargetMs) {
@@ -1187,6 +1211,8 @@ function signedNormalized(value, param) {
   return clamp((value - rest) / den, -1, 1);
 }
 var PhysicsMotion = class {
+  /** The output parameter of every rig, in rig order — what `emit` writes. */
+  drivenParameterIds;
   rigs;
   read;
   sink;
@@ -1200,6 +1226,7 @@ var PhysicsMotion = class {
     this.sink = sink;
     this.params = new Map(params.map((p) => [p.id, p]));
     this.state = rigs.map(() => ({ x: 0, v: 0 }));
+    this.drivenParameterIds = rigs.map((rig) => rig.output.parameter);
   }
   /**
    * Advance every rig to the given wall-clock timestamp (milliseconds).
@@ -1270,6 +1297,8 @@ var PhysicsMotion = class {
 var DEG2RAD = Math.PI / 180;
 var RAD2DEG = 180 / Math.PI;
 var HairChainMotion = class {
+  /** Every segment's output, chain by chain — what `emitSegment` writes. */
+  drivenParameterIds;
   chainData;
   params;
   deformers;
@@ -1290,6 +1319,9 @@ var HairChainMotion = class {
       ),
       state: chain.segments.map(() => ({ angle: 0, angularVelocity: 0 }))
     }));
+    this.drivenParameterIds = chains.flatMap(
+      (c) => c.segments.map((s) => s.output.parameter)
+    );
   }
   /**
    * Advance every chain to the given wall-clock timestamp (milliseconds).
@@ -1402,9 +1434,58 @@ var HairChainMotion = class {
     );
   }
 };
+
+// src/iki-motion.ts
+var IkiMotion = class {
+  /**
+   * Idle ids, then rig outputs, then chain-segment outputs, deduplicated and
+   * insertion-ordered. May name ids the model lacks (the player silently
+   * drops writes to unknown ids) — intersect with the model's parameters if
+   * you mirror into your own store.
+   */
+  drivenParameterIds;
+  idle;
+  physics;
+  chains;
+  constructor(model, read, sink) {
+    const rigs = model.physics ?? [];
+    const chains = model.physicsChains ?? [];
+    this.idle = new IdleMotion(sink);
+    this.physics = new PhysicsMotion(rigs, model.parameters, read, sink);
+    this.chains = new HairChainMotion(
+      chains,
+      model.parameters,
+      model.deformers ?? [],
+      read,
+      sink
+    );
+    this.drivenParameterIds = [
+      .../* @__PURE__ */ new Set([
+        ...this.idle.drivenParameterIds,
+        ...this.physics.drivenParameterIds,
+        ...this.chains.drivenParameterIds
+      ])
+    ];
+  }
+  /**
+   * Advance idle, then physics, then chains to the same wall-clock timestamp
+   * (milliseconds). Order is load-bearing: `PhysicsMotion` reads its input
+   * parameters (typically `ParamAngleX/Z`) through `read`, and the head sway
+   * idle wrote THIS frame is what the springs must lag behind; `HairChainMotion`
+   * then resolves its anchor deformer's world rotation from that same
+   * just-written pose (which may include a physics output). One timestamp for
+   * all three keeps their dt in lockstep.
+   */
+  update(nowMs) {
+    this.idle.update(nowMs);
+    this.physics.update(nowMs);
+    this.chains.update(nowMs);
+  }
+};
 export {
   HairChainMotion,
   IdleMotion,
+  IkiMotion,
   IkiPlayer,
   ParameterStore,
   PhysicsMotion,