@ikijs/editor 0.20.0 → 0.21.0

package/dist/index.mjs

@@ -1567,7 +1567,10 @@ var ROW_RUN_ROLES = /* @__PURE__ */ new Set([
   "arm_L",
   "arm_R",
   "forearm_pose_L",
-  "forearm_pose_R"
+  "forearm_pose_R",
+  "mouth_inner",
+  "lip_lower",
+  "lip_upper"
 ]);
 var REST_HIDDEN_ROLES = /* @__PURE__ */ new Set([
   "forearm_pose_L",
@@ -2184,6 +2187,29 @@ function gridMesh(cols, rows) {
   }
   return { vertices, uvs, indices };
 }
+function columnMesh(b, grid) {
+  const { xs } = grid;
+  const rows = grid.ys.length - 1;
+  const vertices = [];
+  const uvs = [];
+  for (let r = 0; r <= rows; r++) {
+    for (const x of xs) {
+      const u = (x - b.x0) / bw(b);
+      vertices.push(roundTo(u - 0.5, 1e-5), roundTo(0.5 - r / rows, 1e-5));
+      uvs.push(roundTo(u, 1e-5), roundTo(r / rows, 1e-5));
+    }
+  }
+  const n = xs.length;
+  const indices = [];
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c + 1 < n; c++) {
+      const tl = r * n + c;
+      const bl = tl + n;
+      indices.push(bl, bl + 1, tl, tl, bl + 1, tl + 1);
+    }
+  }
+  return { vertices, uvs, indices };
+}
 function meshPoints(mesh, box) {
   const out = [];
   for (let i = 0; i < mesh.vertices.length; i += 2) {
@@ -2309,10 +2335,13 @@ function browBindings(side, reach) {
   ];
 }
 var BROW_TILT = 15;
-function mouthForm(mesh, box) {
-  const a = 0.3 * bh(box);
-  const c = cx(box);
-  const half = bw(box) / 2;
+var mouthFrameOf = (box) => ({
+  c: cx(box),
+  half: bw(box) / 2,
+  amp: 0.3 * bh(box)
+});
+function mouthForm(mesh, box, frame = mouthFrameOf(box)) {
+  const { c, half, amp: a } = frame;
   return localWarp(P.MouthForm, mesh, box, [-1, 0, 1], ([x], v) => {
     if (v === 0) return [0, 0];
     const u = (x - c) / half;
@@ -2330,8 +2359,8 @@ function mouthOpenGrow(mesh, box) {
     ([x, y], v) => v === 1 ? [(AMPLITUDE.mouthOpenWidth - 1) * (x - c), 0] : [0, box.y1 + (y - box.y1) * 0.2 - y]
   );
 }
-function mouthWiden(mesh, box) {
-  const c = cx(box);
+function mouthWiden(mesh, box, frame = mouthFrameOf(box)) {
+  const c = frame.c;
   return localWarp(P.MouthOpen, mesh, box, [0, 1], ([x], v) => [
     v * (AMPLITUDE.mouthOpenWidth - 1) * (x - c),
     0
@@ -2990,6 +3019,8 @@ function forearmPoseDeformer(role, arm) {
 }
 
 // src/auto-rig/roles.ts
+var LIP_ROLES = ["mouth_inner", "lip_lower", "lip_upper"];
+var isLipRole = (role) => LIP_ROLES.includes(role);
 var ROLE_TABLE = [
   { role: "hair_back", family: "hair_back" },
   { role: "body", family: "body" },
@@ -2999,8 +3030,14 @@ var ROLE_TABLE = [
   { role: "blush_L", family: "face" },
   { role: "blush_R", family: "face" },
   { role: "nose", family: "nose" },
-  { role: "mouth", family: "mouth", required: true },
+  { role: "mouth", family: "mouth" },
   { role: "mouth_open", family: "mouth" },
+  // The lip set, back to front: the interior, the lower lip's skin, the upper
+  // lip and its line over both. It folds open instead of crossfading
+  // (`mouth.ts`), so it stands in for `mouth`, never beside it.
+  { role: "mouth_inner", family: "mouth" },
+  { role: "lip_lower", family: "mouth" },
+  { role: "lip_upper", family: "mouth" },
   { role: "eye_L", family: "eye_L", required: true },
   { role: "eye_R", family: "eye_R", required: true },
   { role: "iris_L", family: "eye_L" },
@@ -3058,6 +3095,29 @@ function checkArmsHaveBody(roles) {
     );
   }
 }
+function checkMouth(roles) {
+  const has = new Set(roles);
+  const present = LIP_ROLES.filter((r) => has.has(r));
+  if (present.length === 0) {
+    if (!has.has("mouth")) {
+      throw new Error(
+        `auto-rig: missing required role mouth (or the lip set ${LIP_ROLES.join(", ")})`
+      );
+    }
+    return;
+  }
+  if (present.length < LIP_ROLES.length) {
+    throw new Error(
+      `auto-rig: the lip set is partial: missing ${LIP_ROLES.filter((r) => !has.has(r)).join(", ")}`
+    );
+  }
+  const mixed = ["mouth", "mouth_open"].filter((r) => has.has(r));
+  if (mixed.length > 0) {
+    throw new Error(
+      `auto-rig: the lip set cannot be mixed with ${mixed.join(", ")} (the lip set replaces the mouth drawings; use one or the other)`
+    );
+  }
+}
 function checkPosesHaveArms(roles) {
   const has = new Set(roles);
   for (const side of ["L", "R"]) {
@@ -3093,6 +3153,7 @@ function parseLayerRoles(fileNames) {
       `auto-rig: missing required role${missing.length > 1 ? "s" : ""} ${missing.join(", ")}`
     );
   }
+  checkMouth(seen.keys());
   checkArmsHaveBody(seen.keys());
   checkPosesHaveArms(seen.keys());
   return out;
@@ -3101,7 +3162,7 @@ function parseLayerRoles(fileNames) {
 // src/auto-rig/generate.ts
 import {
   IKI_FORMAT_VERSION as IKI_FORMAT_VERSION2,
-  StandardParameter as P7,
+  StandardParameter as P8,
   parseIkiModel as parseIkiModel3
 } from "@ikijs/format";
 
@@ -3408,6 +3469,14 @@ function checkLayers(layers, canvas) {
   if (missing.length > 0) {
     throw new Error(`auto-rig: missing required role(s) ${missing.join(", ")}`);
   }
+  checkMouth(seen);
+  for (const l of layers) {
+    if (l.rowRuns === void 0 && isLipRole(l.role)) {
+      throw new Error(
+        `auto-rig: layer "${l.fileName}": the lip set needs rowRuns (the fold reads the opening's rows off them; measure with createLayerSetMeasurer)`
+      );
+    }
+  }
   checkArmsHaveBody(seen);
   checkPosesHaveArms(seen);
 }
@@ -3527,7 +3596,182 @@ function checkStrandEdges(strand, irises, hair) {
 }
 
 // src/auto-rig/context.ts
-import { StandardParameter as P6 } from "@ikijs/format";
+import { StandardParameter as P7 } from "@ikijs/format";
+
+// src/auto-rig/mouth.ts
+import {
+  StandardParameter as P6
+} from "@ikijs/format";
+var UPPER_SHARE = 0.3;
+var MOUTH_KNOT_PX = 4;
+var isLipSet = (byRole) => LIP_ROLES.every((r) => byRole.has(r));
+function columnRuns(layer) {
+  const cols = /* @__PURE__ */ new Map();
+  (layer.rowRuns ?? []).forEach((runs, k) => {
+    for (let i = 0; i < runs.length; i += 2) {
+      for (let c = runs[i]; c < runs[i + 1]; c++) {
+        const list = cols.get(c) ?? [];
+        const last = list[list.length - 1];
+        if (last !== void 0 && last[1] === k) last[1] = k + 1;
+        else list.push([k, k + 1]);
+        cols.set(c, list);
+      }
+    }
+  });
+  return cols;
+}
+var edgesOf = (layer, run) => ({
+  top: layer.canvasH / 2 - (layer.bbox.y + run[0]),
+  bottom: layer.canvasH / 2 - (layer.bbox.y + run[1])
+});
+function mouthOpening(byRole) {
+  const inner = byRole.get("mouth_inner");
+  const upper = byRole.get("lip_upper");
+  const lower = byRole.get("lip_lower");
+  const innerCols = columnRuns(inner);
+  if (innerCols.size === 0) {
+    throw new LayerGeometryError(
+      `auto-rig: layer "${inner.fileName}": mouth_inner has no opaque pixel (alpha \u2265 128) to read the opening off`
+    );
+  }
+  const upperCols = columnRuns(upper);
+  const lowerCols = columnRuns(lower);
+  const cols = [...innerCols.keys()];
+  const x0 = Math.min(...cols);
+  const x1 = Math.max(...cols);
+  const read = (col) => {
+    const runs = innerCols.get(col);
+    if (runs === void 0) return void 0;
+    const T = edgesOf(inner, runs[0]).top;
+    const Bb = edgesOf(inner, runs[runs.length - 1]).bottom;
+    const line = [...upperCols.get(col) ?? []].reverse().map((r) => edgesOf(upper, r)).find((e) => e.top >= T);
+    const Tu = line?.bottom ?? T;
+    const lineTop = line?.top ?? T;
+    const skin = lowerCols.get(col)?.[0];
+    return {
+      T,
+      Bb,
+      Tu,
+      lineTop,
+      lineH: lineTop - Tu,
+      Bl: skin === void 0 ? Bb : edgesOf(lower, skin).top,
+      H: T - Bb,
+      seam: T - UPPER_SHARE * (T - Bb)
+    };
+  };
+  const reads = [];
+  for (let c = x0; c <= x1; c++) {
+    let r;
+    for (let d = 0; (r = read(c - d) ?? read(c + d)) === void 0; d++) ;
+    reads.push(r);
+  }
+  const base = (col) => reads[Math.min(x1, Math.max(x0, col)) - x0];
+  const centre = Math.round((x0 + x1) / 2);
+  const w = base(centre).lineH;
+  return {
+    x0,
+    x1,
+    centre,
+    canvasW: inner.canvasW,
+    w,
+    at(col) {
+      const b = base(col);
+      return { ...b, overlap: Math.max(0, Math.min(w, b.lineH)) };
+    }
+  };
+}
+function mouthFold(role, opening) {
+  return (col, y, v) => {
+    if (v === 1) return 0;
+    if (role !== "mouth_inner" && (col < opening.x0 || col > opening.x1))
+      return 0;
+    const c = opening.at(col);
+    const k = 1 - v;
+    switch (role) {
+      case "lip_upper":
+        return (c.seam - c.Tu) * k;
+      case "lip_lower":
+        return (c.seam + c.overlap - c.Bl) * k;
+      case "mouth_inner":
+        return (c.seam + c.overlap - y) * k;
+    }
+  };
+}
+function columnOfKnot(knot, opening, role) {
+  const boundary = Math.round(knot + opening.canvasW / 2);
+  const col = boundary === opening.x1 + 1 ? opening.x1 : boundary;
+  if (col >= opening.x0 && col <= opening.x1) return col;
+  return role === "mouth_inner" ? Math.min(opening.x1, Math.max(opening.x0, col)) : void 0;
+}
+function mouthFoldWarp(role, mesh, xs, box, opening) {
+  const fold = mouthFold(role, opening);
+  return localWarp(P6.MouthOpen, mesh, box, [0, 1], (p, v, i) => {
+    const col = columnOfKnot(xs[i % xs.length], opening, role);
+    return [0, col === void 0 ? 0 : fold(col, p[1], v)];
+  });
+}
+function mouthKnots(union, opening) {
+  const half = opening.canvasW / 2;
+  const step = MOUTH_KNOT_PX;
+  const xs = [union.x0];
+  while (xs[xs.length - 1] + step < union.x1 - 0.3 * step)
+    xs.push(xs[xs.length - 1] + step);
+  xs.push(union.x1);
+  const fixed = /* @__PURE__ */ new Set([union.x0, union.x1]);
+  for (const x of [opening.x0 - half, opening.x1 + 1 - half]) {
+    fixed.add(x);
+    if (xs.includes(x)) continue;
+    const near = xs.findIndex((v) => Math.abs(v - x) < 0.3 * step);
+    if (near >= 0 && !fixed.has(xs[near])) xs[near] = x;
+    else xs.push(x);
+  }
+  xs.sort((p, q) => p - q);
+  for (const x of xs) {
+    if (!Number.isInteger(x + half)) {
+      throw new Error(
+        `auto-rig: mouth knot ${x} is not an integer canvas boundary`
+      );
+    }
+  }
+  return xs;
+}
+function mouthMesh(box, knots) {
+  const xs = [box.x0, ...knots.filter((k) => k > box.x0 && k < box.x1), box.x1];
+  const rows = cellsFor(bh(box), MOUTH_KNOT_PX, 2, 40);
+  const ys = Array.from(
+    { length: rows + 1 },
+    (_, r) => box.y1 - bh(box) * r / rows
+  );
+  return { mesh: columnMesh(box, { xs, ys }), xs };
+}
+function buildMouthRig(byRole) {
+  const opening = mouthOpening(byRole);
+  const union = unionBoxes(LIP_ROLES.map((r) => boxOfLayer(byRole.get(r))));
+  return {
+    opening,
+    frame: mouthFrameOf(union),
+    knots: mouthKnots(union, opening),
+    union
+  };
+}
+function mouthAnchor(byRole) {
+  const box = (role) => boxOfLayer(byRole.get(role));
+  if (isLipSet(byRole)) {
+    const opening = mouthOpening(byRole);
+    return {
+      at: {
+        x: cx(box("mouth_inner")),
+        y: opening.at(opening.centre).seam
+      },
+      box: unionBoxes(LIP_ROLES.map(box))
+    };
+  }
+  const m = box("mouth");
+  return {
+    at: { x: cx(m), y: cy(m) },
+    box: byRole.has("mouth_open") ? unionBoxes([m, box("mouth_open")]) : m
+  };
+}
 
 // src/auto-rig/head.ts
 function outerEdge(runs, axisX, side) {
@@ -3607,7 +3851,7 @@ function buildHeadFrame(layers, opts) {
     return ya === void 0 || yb === void 0 ? void 0 : (ya + yb) / 2;
   };
   const eyeY = pair("iris_L", "iris_R") ?? pair("eye_L", "eye_R");
-  const mouthY = centreY("mouth");
+  const mouthY = mouthAnchor(byRole).at.y;
   const rowY = (r) => canvasH / 2 - (faceLayer.bbox.y + r + 0.5);
   const raw = filledProfile(faceLayer.rowHalfWidths);
   const profile = raw === null ? null : smoothProfile(raw);
@@ -4580,7 +4824,6 @@ function sideIrises(byRole) {
   return pair === void 0 ? {} : { left: pair.left.box, right: pair.right.box };
 }
 function solveContext(frame, byRole, options, hasNose) {
-  const box = (role) => boxOfLayer(byRole.get(role));
   const row = (s, strand2, sideSign) => {
     if (strand2 !== void 0) {
       const lo = sideSign < 0 ? strand2.irisOuter : strand2.irisInner;
@@ -4629,8 +4872,7 @@ function solveContext(frame, byRole, options, hasNose) {
     noseBox = nose.denseCore ? boxOfPixels(nose.denseCore, nose.canvasW, nose.canvasH) : boxOfLayer(nose);
     noseAt = { x: cx(noseBox), y: cy(noseBox) };
   }
-  const mouthBox = byRole.has("mouth_open") ? unionBoxes([box("mouth"), box("mouth_open")]) : box("mouth");
-  const m = box("mouth");
+  const mouth = mouthAnchor(byRole);
   return {
     frame,
     left,
@@ -4642,8 +4884,8 @@ function solveContext(frame, byRole, options, hasNose) {
     eyeBoxes: { left: eyes.left.box, right: eyes.right.box },
     noseAt,
     noseBox,
-    mouthAt: { x: cx(m), y: cy(m) },
-    mouthBox
+    mouthAt: mouth.at,
+    mouthBox: mouth.box
   };
 }
 function renderedLander(turn, parts, grids, from = /* @__PURE__ */ new Map()) {
@@ -4659,7 +4901,7 @@ function renderedLander(turn, parts, grids, from = /* @__PURE__ */ new Map()) {
     const family = roleSpec(role).family;
     const part = parts.find((p) => p.id === role);
     const g = grids.get(family);
-    const warp = part?.warps?.find((w) => w.parameter === P6.AngleX);
+    const warp = part?.warps?.find((w) => w.parameter === P7.AngleX);
     if (part === void 0 || part.mesh === void 0 || !g && !warp) {
       return x + field(role)(x, y, ax, 0)[0];
     }
@@ -5456,6 +5698,7 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     hh: frame.hh,
     pivots: [...arms.values()].map((g) => g.shoulder)
   }) : void 0;
+  const lips = isLipSet(byRole) ? buildMouthRig(byRole) : void 0;
   const parts = [];
   const reach = /* @__PURE__ */ new Map();
   let regionOf = [];
@@ -5487,7 +5730,8 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       frame,
       byRole,
       style,
-      landmarks.hairFrontGrid
+      landmarks.hairFrontGrid,
+      lips
     );
     if (built.region !== void 0) {
       regionOf = built.region;
@@ -5569,14 +5813,14 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
 function turnWarps(mesh, b, fieldOf) {
   return [
     localWarp(
-      P7.AngleX,
+      P8.AngleX,
       mesh,
       b,
       X_STOPS,
       ([x, y], v, i) => v === 0 ? [0, 0] : [fieldOf(i)(x, y, v, 0)[0], 0]
     ),
     localWarp(
-      P7.AngleY,
+      P8.AngleY,
       mesh,
       b,
       Y_STOPS,
@@ -5589,7 +5833,7 @@ function plateFields(turn, region, head) {
   const neck = neckField(turn);
   return (i) => region[i] === "ear" ? ear : region[i] === "neck" ? neck : head;
 }
-function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
+function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
   const box = (role) => boxOfLayer(byRole.get(role));
   const part = {
     id: spec.role,
@@ -5604,6 +5848,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
   const bindings = [];
   let extra = [0, 0];
   let mesh;
+  let knotXs;
   let region;
   let headStart = 0;
   if (spec.role === "face") {
@@ -5614,6 +5859,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
     headStart = fm.headStart;
   } else if (spec.role === "hair_front") {
     mesh = columnMesh(b, frontGrid);
+  } else if (lips !== void 0 && isLipRole(spec.role)) {
+    ({ mesh, xs: knotXs } = mouthMesh(b, lips.knots));
   } else if (spec.family !== "body") {
     const cells = MESH_CELLS[spec.role] ?? FEATURE_MESH_CELLS;
     const px = Math.min(cells.px, meshScale(spec.role, frame));
@@ -5624,7 +5871,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
   }
   if (mesh !== void 0) part.mesh = mesh;
   const side = spec.role.endsWith("_L") ? "L" : "R";
-  const eyeOpen = side === "L" ? P7.EyeOpenLeft : P7.EyeOpenRight;
+  const eyeOpen = side === "L" ? P8.EyeOpenLeft : P8.EyeOpenRight;
   const hh = frame.hh;
   switch (spec.role) {
     case "face":
@@ -5639,7 +5886,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
             headOwnRoll(byRole.has("body"))
           ),
           localWarp(
-            P7.Breath,
+            P8.Breath,
             mesh,
             b,
             [0, 1],
@@ -5686,8 +5933,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
       if (byRole.has("mouth_open")) {
         warps.push(mouthWiden(mesh, b));
         bindings.push(
-          { parameter: P7.MouthOpen, channel: "opacity", from: 1, to: 0 },
-          { parameter: P7.MouthOpen, channel: "opacity", from: 1, to: 0 }
+          { parameter: P8.MouthOpen, channel: "opacity", from: 1, to: 0 },
+          { parameter: P8.MouthOpen, channel: "opacity", from: 1, to: 0 }
         );
         extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       } else {
@@ -5697,19 +5944,19 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
         );
         bindings.push(
           {
-            parameter: P7.MouthOpen,
+            parameter: P8.MouthOpen,
             channel: "scaleY",
             from: 0,
             to: roundTo(grow, 0.01)
           },
           {
-            parameter: P7.MouthOpen,
+            parameter: P8.MouthOpen,
             channel: "scaleX",
             from: 0,
             to: roundTo(AMPLITUDE.mouthOpenWidth - 1, 0.01)
           },
           {
-            parameter: P7.MouthOpen,
+            parameter: P8.MouthOpen,
             channel: "translateY",
             from: 0,
             to: -roundTo(grow * bh(b) / 2, 0.01)
@@ -5721,17 +5968,26 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
     case "mouth_open":
       warps.push(mouthForm(mesh, b), mouthOpenGrow(mesh, b));
       bindings.push({
-        parameter: P7.MouthOpen,
+        parameter: P8.MouthOpen,
         channel: "opacity",
         from: 0,
         to: 1
       });
       extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       break;
+    case "mouth_inner":
+    case "lip_lower":
+    case "lip_upper":
+      warps.push(
+        mouthFoldWarp(spec.role, mesh, knotXs, b, lips.opening),
+        mouthForm(mesh, b, lips.frame),
+        mouthWiden(mesh, b, lips.frame)
+      );
+      break;
     case "blush_L":
     case "blush_R":
       bindings.push({
-        parameter: P7.Cheek,
+        parameter: P8.Cheek,
         channel: "opacity",
         from: AMPLITUDE.blushRest,
         to: 1
@@ -5742,8 +5998,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
       if (byRole.has("hair_front")) {
         const amp = style.sway * AMPLITUDE.sway * hh;
         warps.push(
-          hairSway(P7.HairSwayX, mesh, b, amp),
-          hairSway(P7.HairSwayZ, mesh, b, amp)
+          hairSway(P8.HairSwayX, mesh, b, amp),
+          hairSway(P8.HairSwayZ, mesh, b, amp)
         );
       }
       warps.push(tiltHang(mesh, b, pivot, hairHangWeight(frame.chinY, b.y0)));
@@ -5784,29 +6040,6 @@ function hairFrontGrid(b, frame, boxes) {
   );
   return { xs, ys };
 }
-function columnMesh(b, grid) {
-  const { xs } = grid;
-  const rows = grid.ys.length - 1;
-  const vertices = [];
-  const uvs = [];
-  for (let r = 0; r <= rows; r++) {
-    for (const x of xs) {
-      const u = (x - b.x0) / bw(b);
-      vertices.push(roundTo(u - 0.5, 1e-5), roundTo(0.5 - r / rows, 1e-5));
-      uvs.push(roundTo(u, 1e-5), roundTo(r / rows, 1e-5));
-    }
-  }
-  const n = xs.length;
-  const indices = [];
-  for (let r = 0; r < rows; r++) {
-    for (let c = 0; c + 1 < n; c++) {
-      const tl = r * n + c;
-      const bl = tl + n;
-      indices.push(bl, bl + 1, tl, tl, bl + 1, tl + 1);
-    }
-  }
-  return { vertices, uvs, indices };
-}
 function meshScale(role, frame) {
   switch (role) {
     case "hair_front":
@@ -5832,9 +6065,9 @@ function deformers(frame, grids, bodyWarp, arms, byRole) {
     pivot: { x: roundTo(frame.axisX, 0.01), y: roundTo(frame.chinY, 0.01) },
     bindings: [
       // AngleZ is clockwise-positive (Live2D's); a rotation is CCW-positive.
-      { parameter: P7.AngleZ, channel: "rotate", from: roll, to: -roll },
+      { parameter: P8.AngleZ, channel: "rotate", from: roll, to: -roll },
       {
-        parameter: P7.Breath,
+        parameter: P8.Breath,
         channel: "translateY",
         from: 0,
         to: roundTo(headOwnBreath(hasBody) * frame.hh, 0.01)
@@ -5852,8 +6085,8 @@ function deformers(frame, grids, bodyWarp, arms, byRole) {
         points: g.lattice.points
       },
       warp2d: {
-        parameter: P7.AngleX,
-        parameterY: P7.AngleY,
+        parameter: P8.AngleX,
+        parameterY: P8.AngleY,
         valuesX: X_STOPS,
         valuesY: Y_STOPS,
         keyforms2d: g.keyforms.map((offsets) => ({ offsets }))
@@ -5866,16 +6099,16 @@ function hairPhysics() {
   return [
     {
       id: "hairSway",
-      input: { parameter: P7.AngleX, weight: 1 },
-      output: { parameter: P7.HairSwayX, scale: 5 },
+      input: { parameter: P8.AngleX, weight: 1 },
+      output: { parameter: P8.HairSwayX, scale: 5 },
       mass: 1,
       stiffness: 30,
       damping: 3
     },
     {
       id: "hairTilt",
-      input: { parameter: P7.AngleZ, weight: 1 },
-      output: { parameter: P7.HairSwayZ, scale: 8 },
+      input: { parameter: P8.AngleZ, weight: 1 },
+      output: { parameter: P8.HairSwayZ, scale: 8 },
       mass: 1,
       stiffness: 25,
       damping: 2.5
@@ -5885,13 +6118,13 @@ function hairPhysics() {
 function declareParameters(roles) {
   const out = [];
   const add = (id, name, min, max, def) => out.push({ id, name, min, max, default: def });
-  add(P7.AngleX, "Head Angle", -30, 30, 0);
-  add(P7.AngleY, "Head Angle Y", -30, 30, 0);
-  add(P7.AngleZ, "Head Angle Z", -30, 30, 0);
+  add(P8.AngleX, "Head Angle", -30, 30, 0);
+  add(P8.AngleY, "Head Angle Y", -30, 30, 0);
+  add(P8.AngleZ, "Head Angle Z", -30, 30, 0);
   if (roles.has("body")) {
-    add(P7.BodyAngleX, "Body Angle X", -10, 10, 0);
-    add(P7.BodyAngleY, "Body Angle Y", -10, 10, 0);
-    add(P7.BodyAngleZ, "Body Angle Z", -10, 10, 0);
+    add(P8.BodyAngleX, "Body Angle X", -10, 10, 0);
+    add(P8.BodyAngleY, "Body Angle Y", -10, 10, 0);
+    add(P8.BodyAngleZ, "Body Angle Z", -10, 10, 0);
   }
   const addPose = (side, pose, angle) => {
     add(pose, `Arm Pose ${side}`, 0, 1, 0);
@@ -5900,40 +6133,40 @@ function declareParameters(roles) {
   const [armMin, armMax] = ARM_RANGE;
   const [elbowMin, elbowMax] = ELBOW_RANGE;
   if (roles.has("arm_L")) {
-    add(P7.ArmLeft, "Arm L", armMin, armMax, 0);
-    add(P7.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
+    add(P8.ArmLeft, "Arm L", armMin, armMax, 0);
+    add(P8.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
     if (roles.has("forearm_pose_L"))
-      addPose("L", P7.ArmPoseLeft, P7.ArmPoseAngleLeft);
+      addPose("L", P8.ArmPoseLeft, P8.ArmPoseAngleLeft);
   }
   if (roles.has("arm_R")) {
-    add(P7.ArmRight, "Arm R", armMin, armMax, 0);
-    add(P7.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
+    add(P8.ArmRight, "Arm R", armMin, armMax, 0);
+    add(P8.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
     if (roles.has("forearm_pose_R"))
-      addPose("R", P7.ArmPoseRight, P7.ArmPoseAngleRight);
+      addPose("R", P8.ArmPoseRight, P8.ArmPoseAngleRight);
   }
-  add(P7.EyeOpenLeft, "Eye L", 0, 1, 1);
-  add(P7.EyeOpenRight, "Eye R", 0, 1, 1);
+  add(P8.EyeOpenLeft, "Eye L", 0, 1, 1);
+  add(P8.EyeOpenRight, "Eye R", 0, 1, 1);
   if ([...roles].some((r) => /^(iris|pupil|highlight)_/.test(r))) {
-    add(P7.EyeballX, "Gaze X", -1, 1, 0);
-    add(P7.EyeballY, "Gaze Y", -1, 1, 0);
+    add(P8.EyeballX, "Gaze X", -1, 1, 0);
+    add(P8.EyeballY, "Gaze Y", -1, 1, 0);
   }
-  add(P7.MouthOpen, "Mouth Open", 0, 1, 0);
-  add(P7.MouthForm, "Mouth Form", -1, 1, 0);
+  add(P8.MouthOpen, "Mouth Open", 0, 1, 0);
+  add(P8.MouthForm, "Mouth Form", -1, 1, 0);
   if (roles.has("brow_L")) {
-    add(P7.BrowLeftY, "Brow L Y", -1, 1, 0);
-    add(P7.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
+    add(P8.BrowLeftY, "Brow L Y", -1, 1, 0);
+    add(P8.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
   }
   if (roles.has("brow_R")) {
-    add(P7.BrowRightY, "Brow R Y", -1, 1, 0);
-    add(P7.BrowRightAngle, "Brow R Angle", -1, 1, 0);
+    add(P8.BrowRightY, "Brow R Y", -1, 1, 0);
+    add(P8.BrowRightAngle, "Brow R Angle", -1, 1, 0);
   }
   if (roles.has("blush_L") || roles.has("blush_R")) {
-    add(P7.Cheek, "Cheek", 0, 1, 0);
+    add(P8.Cheek, "Cheek", 0, 1, 0);
   }
-  add(P7.Breath, "Breath", 0, 1, 0);
+  add(P8.Breath, "Breath", 0, 1, 0);
   if (roles.has("hair_front")) {
-    add(P7.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
-    add(P7.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(P8.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(P8.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
   }
   return out;
 }