@rig-c/play 1.18.0 → 1.19.0

package/dist/index.js

@@ -964,7 +964,8 @@ function clipHalf(input, p, q) {
   return { points: out, cut };
 }
 function clipThrough(shape, vertices, triangles, uvs, clip = clipTriangles, reading = {}) {
-  const plan = clipShapeOf(shape);
+  let plan = clipShapeOf(shape);
+  if (plan.kind === "pieces") plan = clipShapeOf({ ...shape, polygon: shape.polygon.map(Math.fround) });
   if (plan.kind === "refused") return null;
   if (plan.kind === "convex") return clip(plan.polygon, vertices, triangles, uvs);
   const f = Math.fround;
@@ -9034,7 +9035,37 @@ function channelValue(curve, i, c, t) {
   const y0 = p[o + q - 1];
   return y0 + (t - x0) / (p[o + q] - x0) * (p[o + q + 1] - y0);
 }
-const RUNTIME_STAGE = 1;
+function compileDeformCurve(keys) {
+  const curve = compileCurve(keys.map((k) => ({ time: k.time, values: [0], curve: "linear", stated: { time: k.stated, values: [0] } })), 1);
+  for (let i = 0; i < keys.length; i++) {
+    const a = keys[i];
+    curve.kinds[i] = a.curve === "linear" ? CURVE_LINEAR : a.curve === "stepped" ? CURVE_STEPPED : CURVE_BEZIER;
+    if (typeof a.curve === "string" || i + 1 === keys.length) continue;
+    const b = keys[i + 1];
+    const c = a.curve;
+    const inner = bezierPolyline(a.stated, 0, c[0], c[1], c[2], c[3], b.stated, DEFORM_CURVE_END);
+    const o = i * POLYLINE;
+    curve.polylines[o] = a.time;
+    curve.polylines[o + 1] = 0;
+    curve.polylines.set(inner, o + 2);
+    curve.polylines[o + POLYLINE - 2] = b.time;
+    curve.polylines[o + POLYLINE - 1] = 1;
+  }
+  return curve;
+}
+function deformFraction(curve, i, t) {
+  if (curve.kinds[i] === CURVE_STEPPED) return 0;
+  if (curve.kinds[i] === CURVE_LINEAR) return (t - curve.times[i]) / (curve.times[i + 1] - curve.times[i]);
+  const p = curve.polylines;
+  const o = i * POLYLINE;
+  let q = 2;
+  while (q < POLYLINE - 2 && p[o + q] < t) q += 2;
+  const x0 = p[o + q - 2], y0 = p[o + q - 1], x1 = p[o + q], y1 = p[o + q + 1];
+  if (q === 2) return y1 * (t - x0) / (x1 - x0);
+  if (q === POLYLINE - 2) return y0 + (1 - y0) * (t - x0) / (x1 - x0);
+  return y0 + (t - x0) / (x1 - x0) * (y1 - y0);
+}
+const RUNTIME_STAGE = 2;
 function missingText(m) {
   return `${m.feature}: ${m.detail}${m.animation === null ? "" : ` (animation "${m.animation}")`}`;
 }
@@ -9178,6 +9209,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
   }
   const attachments = [];
   let vertexCount = 0;
+  let deformCount = 0;
   const sourceOf = sourceOfDoc(doc);
   const attachmentView = plant.attachmentSkin === void 0 ? doc : underSkin(doc, plant.attachmentSkin);
   const resolvedBySlot = doc.slots.map(() => /* @__PURE__ */ new Map());
@@ -9198,7 +9230,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
     if ("conflict" in shown) return { index: -1, missing: ["skin-conflict", `slot "${slot.name}" placeholder "${placeholder}" is filled by skins that disagree`] };
     const row = shownRow(shown);
     const g = shown.record.geometry;
-    const at = { slot: si, name: row.name, skin: shown.skin, placeholder: shown.placeholder, path: CORE_REGION_KINDS.has(shown.record.kind) ? row.path : null, bone: indexOf(slot.bone), offset: vertexCount };
+    const at = { timeline: timelineIdentity(slot.name, shown), deformOffset: deformCount, slot: si, name: row.name, skin: shown.skin, placeholder: shown.placeholder, path: CORE_REGION_KINDS.has(shown.record.kind) ? row.path : null, bone: indexOf(slot.bone), offset: vertexCount };
     let made = null;
     let missing = null;
     if (g?.kind === "clipping") missing = ["clipping", `slot "${slot.name}" shows clipping attachment "${row.name}"`];
@@ -9240,6 +9272,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
     if (made === null) made = vertexAttachment(at, DRAW_NONE, new Float64Array(0), 0);
     attachments.push(made);
     vertexCount += made.count;
+    deformCount += made.deformCount;
     return { index: attachments.length - 1, missing };
   };
   const slots = doc.slots.map((slot, si) => {
@@ -9261,7 +9294,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
   const refused = [];
   let cursorMax = 0;
   for (const anim of doc.animations) {
-    const compiled = compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, (si, ph) => resolve(si, ph, anim.name));
+    const compiled = compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, doc, (si, ph) => resolve(si, ph, anim.name));
     const missing = refusals.byAnimation.get(anim.name);
     if (missing !== void 0 && missing.length > 0) refused.push({ animation: anim.name, missing });
     else {
@@ -9272,6 +9305,9 @@ function compileRuntime(doc, options = {}, plant = {}) {
   if (refusals.model.length > 0) throw new RuntimeRefusal(refusals.model);
   const names = doc.animations.map((a) => a.name);
   return {
+    omitDeform: plant.omitDeform === true,
+    deformAfterWeights: plant.deformAfterWeights === true,
+    deformCount,
     eventWrapOffByOne: plant.eventWrapOffByOne === true,
     restoreEventsFromStart: plant.restoreEventsFromStart === true,
     doc,
@@ -9303,7 +9339,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
 const NO_INTS = new Int32Array(0);
 const NO_NUMBERS = new Float64Array(0);
 function vertexAttachment(at, draw, local, count) {
-  return { ...at, draw, local, count, bindingCounts: NO_INTS, bindingBones: NO_INTS, bindingX: NO_NUMBERS, bindingY: NO_NUMBERS, bindingWeights: NO_NUMBERS };
+  return { ...at, draw, local, count, deformCount: draw === DRAW_MESH ? count : 0, bindingCounts: NO_INTS, bindingBones: NO_INTS, bindingX: NO_NUMBERS, bindingY: NO_NUMBERS, bindingWeights: NO_NUMBERS };
 }
 function meshAttachment(at, vertices, indexOf, rewrite, bones) {
   if (!vertices.weighted) {
@@ -9327,7 +9363,7 @@ function meshAttachment(at, vertices, indexOf, rewrite, bones) {
       ws.push(Math.fround(b.weight));
     }
   }
-  return { ...at, draw: DRAW_WEIGHTED, local: NO_NUMBERS, count: counts.length * 2, bindingCounts: Int32Array.from(counts), bindingBones: Int32Array.from(ids), bindingX: Float64Array.from(xs), bindingY: Float64Array.from(ys), bindingWeights: Float64Array.from(ws) };
+  return { ...at, deformCount: ids.length * 2, draw: DRAW_WEIGHTED, local: NO_NUMBERS, count: counts.length * 2, bindingCounts: Int32Array.from(counts), bindingBones: Int32Array.from(ids), bindingX: Float64Array.from(xs), bindingY: Float64Array.from(ys), bindingWeights: Float64Array.from(ws) };
 }
 function compileIk(r, index, applied, bones, indexOf) {
   return {
@@ -9387,13 +9423,12 @@ function compileTransform(r, index, applied, bones, indexOf) {
     clamp: r.clamp
   };
 }
-function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, resolve) {
+function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, doc, resolve) {
   const tl = anim.timelines;
   const name = anim.name;
   let cursors = 0;
   const deform = tl.attachments.filter((a) => a.deform !== null);
   const sequence = tl.attachments.filter((a) => a.sequence !== null);
-  if (deform.length > 0) refusals.note("deform-timeline", `${deform.length} deform timeline(s): ${deform.slice(0, 3).map((a) => `${a.skin}/${a.slot}/${a.attachment}`).join(", ")}${deform.length > 3 ? ", …" : ""}`, name);
   if (sequence.length > 0) refusals.note("sequence-timeline", `${sequence.length} sequence timeline(s): ${sequence.slice(0, 3).map((a) => `${a.skin}/${a.slot}/${a.attachment}`).join(", ")}${sequence.length > 3 ? ", …" : ""}`, name);
   if (tl.drawOrder.length > 0) refusals.note("draw-order-timeline", `${tl.drawOrder.length} draw-order key(s)`, name);
   const lastBy = (targets) => new Map(targets.map((t) => [t.name, t]));
@@ -9441,7 +9476,14 @@ function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, s
       constraintTimelines[c.index] = { constraint: c.index, curve: compileCurve(keyed.keys, TRANSFORM_PROPERTIES.length), cursor: cursors++, flags: null };
     }
   }
-  return { name, duration: tl.duration, bones, slots: slotTimelines, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map((key) => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
+  const deforms = deform.map((a) => {
+    const g = doc.skins.find((s) => s.name === a.skin)?.attachments[a.slot]?.[a.attachment]?.geometry;
+    if (g === void 0 || g.kind === "region" || g.kind === "linkedmesh") throw new RuntimeInputError(`deform "${a.skin}/${a.slot}/${a.attachment}" has no vertex geometry (readModel refuses it first)`);
+    const keys = a.deform;
+    const arrays = keys.map((k) => heldArray(g.vertices, k));
+    return { identity: `${a.skin}/${a.slot}/${a.attachment}`, cursor: cursors++, curve: compileDeformCurve(keys), count: arrays[0].length, held: Float64Array.from(arrays.flat()) };
+  });
+  return { name, duration: tl.duration, deforms, bones, slots: slotTimelines, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map((key) => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
 }
 const DEG = RUNTIME_DEG;
 const TWO_PI = 2 * RUNTIME_PI;
@@ -9474,6 +9516,8 @@ class RuntimePose {
     this.light = new Float64Array(ns * 4);
     this.shown = new Int32Array(ns);
     this.vertices = new Float64Array(model.vertexCount);
+    this.deform = new Float64Array(model.deformCount);
+    this.deformed = new Uint8Array(model.attachments.length);
     this.cursors = new Int32Array(Math.max(1, model.cursors)).fill(-1);
     this.ikMix = new Float64Array(nc);
     this.ikSoftness = new Float64Array(nc);
@@ -9523,6 +9567,7 @@ class RuntimePose {
     this.constraintValues(null, 0);
     this.solveConstraints();
     this.slotValues(null, 0);
+    this.deformValues(null, 0);
   }
   /** The animation posed at its time `t`, from the setup pose (the header). */
   apply(t) {
@@ -9536,6 +9581,7 @@ class RuntimePose {
     this.constraintValues(anim, t);
     this.solveConstraints();
     this.slotValues(anim, t);
+    this.deformValues(anim, t);
   }
   /** One step of a looping track: the track time moved by `dt`, the animation posed at it wrapped by the duration (`loopedTime` in src/core/raw.ts). */
   step(dt) {
@@ -10245,6 +10291,31 @@ class RuntimePose {
       }
     }
   }
+  /** Reset on every pose, then match source identity after switches; no old frame's offsets survive. */
+  deformValues(anim, t) {
+    this.deformed.fill(0);
+    this.deform.fill(0);
+    if (anim === null || this.model.omitDeform) return;
+    for (let k = 0; k < anim.deforms.length; k++) {
+      const tl = anim.deforms[k];
+      const i = keyAt(tl.curve, this.cursors, tl.cursor, t);
+      if (i < 0) continue;
+      const held = i + 1 === tl.curve.keys || tl.curve.kinds[i] === CURVE_STEPPED;
+      const p = held ? 0 : deformFraction(tl.curve, i, t);
+      const start = i * tl.count;
+      for (let s = 0; s < this.shown.length; s++) {
+        const index = this.shown[s];
+        if (index < 0 || !this.model.slots[s].live) continue;
+        const at = this.model.attachments[index];
+        if (at.timeline !== tl.identity || at.deformCount === 0) continue;
+        this.deformed[index] = 1;
+        for (let q = 0; q < tl.count; q++) {
+          const v = tl.held[start + q];
+          this.deform[at.deformOffset + q] = held ? v : v + (tl.held[start + tl.count + q] - v) * p;
+        }
+      }
+    }
+  }
   /** Every shown attachment's world vertices into `vertices` at its offset (`regionCorners`, `worldVertices`). */
   computeVertices() {
     const m = this.model;
@@ -10266,7 +10337,8 @@ class RuntimePose {
         const d = W[b + W_D];
         const wx = W[b + W_X];
         const wy = W[b + W_Y];
-        const local = at.local;
+        const local = this.deformed[index] && at.draw === DRAW_MESH ? this.deform : at.local;
+        const lo = this.deformed[index] && at.draw === DRAW_MESH ? at.deformOffset : 0;
         if (at.draw === DRAW_REGION) {
           for (let q = 0; q < 8; q += 2) {
             const lx = local[q];
@@ -10276,8 +10348,8 @@ class RuntimePose {
           }
         } else {
           for (let q = 0; q < at.count; q += 2) {
-            const x = local[q];
-            const y = local[q + 1];
+            const x = local[lo + q];
+            const y = local[lo + q + 1];
             out[o++] = x * a + y * bb + wx;
             out[o++] = x * c + y * d + wy;
           }
@@ -10296,9 +10368,15 @@ class RuntimePose {
         const end = n + counts[v];
         for (; n < end; n++) {
           const b = bones[n] * WORLDS;
-          const x = xs[n];
-          const y = ys[n];
           const weight = weights[n];
+          const deformed = this.deformed[index] !== 0;
+          const x = deformed ? xs[n] + this.deform[at.deformOffset + n * 2] : xs[n];
+          const y = deformed ? ys[n] + this.deform[at.deformOffset + n * 2 + 1] : ys[n];
+          if (deformed && m.deformAfterWeights) {
+            wx += (xs[n] * W[b + W_A] + ys[n] * W[b + W_B] + W[b + W_X]) * weight + this.deform[at.deformOffset + n * 2];
+            wy += (xs[n] * W[b + W_C] + ys[n] * W[b + W_D] + W[b + W_Y]) * weight + this.deform[at.deformOffset + n * 2 + 1];
+            continue;
+          }
           wx += (x * W[b + W_A] + y * W[b + W_B] + W[b + W_X]) * weight;
           wy += (x * W[b + W_C] + y * W[b + W_D] + W[b + W_Y]) * weight;
         }