@ikijs/editor 0.20.0 → 0.21.0

package/dist/index.js

@@ -1644,7 +1644,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",
@@ -2257,6 +2260,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) {
@@ -2380,10 +2406,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(import_format3.StandardParameter.MouthForm, mesh, box, [-1, 0, 1], ([x], v) => {
     if (v === 0) return [0, 0];
     const u = (x - c) / half;
@@ -2401,8 +2430,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(import_format3.StandardParameter.MouthOpen, mesh, box, [0, 1], ([x], v) => [
     v * (AMPLITUDE.mouthOpenWidth - 1) * (x - c),
     0
@@ -3059,6 +3088,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" },
@@ -3068,8 +3099,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" },
@@ -3127,6 +3164,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"]) {
@@ -3162,13 +3222,14 @@ 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;
 }
 
 // src/auto-rig/generate.ts
-var import_format9 = require("@ikijs/format");
+var import_format10 = require("@ikijs/format");
 
 // src/auto-rig/animations.ts
 var import_format7 = require("@ikijs/format");
@@ -3471,6 +3532,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);
 }
@@ -3590,7 +3659,180 @@ function checkStrandEdges(strand, irises, hair) {
 }
 
 // src/auto-rig/context.ts
+var import_format9 = require("@ikijs/format");
+
+// src/auto-rig/mouth.ts
 var import_format8 = require("@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(import_format8.StandardParameter.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) {
@@ -3670,7 +3912,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);
@@ -4643,7 +4885,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;
@@ -4692,8 +4933,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,
@@ -4705,8 +4945,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()) {
@@ -4722,7 +4962,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 === import_format8.StandardParameter.AngleX);
+    const warp = part?.warps?.find((w) => w.parameter === import_format9.StandardParameter.AngleX);
     if (part === void 0 || part.mesh === void 0 || !g && !warp) {
       return x + field(role)(x, y, ax, 0)[0];
     }
@@ -5519,6 +5759,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 = [];
@@ -5550,7 +5791,8 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       frame,
       byRole,
       style,
-      landmarks.hairFrontGrid
+      landmarks.hairFrontGrid,
+      lips
     );
     if (built.region !== void 0) {
       regionOf = built.region;
@@ -5607,7 +5849,7 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
   }
   const parameters = declareParameters(new Set(byRole.keys()));
   const model = {
-    version: import_format9.IKI_FORMAT_VERSION,
+    version: import_format10.IKI_FORMAT_VERSION,
     name: "auto-rigged",
     canvas: { width: canvas.width, height: canvas.height },
     parameters,
@@ -5617,7 +5859,7 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     expressions: defaultExpressions(new Set(parameters.map((p) => p.id))),
     motions: defaultMotions(new Set(parameters.map((p) => p.id)))
   };
-  const valid = (0, import_format9.parseIkiModel)(model);
+  const valid = (0, import_format10.parseIkiModel)(model);
   if (hasNose && options.onTurnSolved) {
     options.onTurnSolved(
       turnReport(
@@ -5632,14 +5874,14 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
 function turnWarps(mesh, b, fieldOf) {
   return [
     localWarp(
-      import_format9.StandardParameter.AngleX,
+      import_format10.StandardParameter.AngleX,
       mesh,
       b,
       X_STOPS,
       ([x, y], v, i) => v === 0 ? [0, 0] : [fieldOf(i)(x, y, v, 0)[0], 0]
     ),
     localWarp(
-      import_format9.StandardParameter.AngleY,
+      import_format10.StandardParameter.AngleY,
       mesh,
       b,
       Y_STOPS,
@@ -5652,7 +5894,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,
@@ -5667,6 +5909,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") {
@@ -5677,6 +5920,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));
@@ -5687,7 +5932,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" ? import_format9.StandardParameter.EyeOpenLeft : import_format9.StandardParameter.EyeOpenRight;
+  const eyeOpen = side === "L" ? import_format10.StandardParameter.EyeOpenLeft : import_format10.StandardParameter.EyeOpenRight;
   const hh = frame.hh;
   switch (spec.role) {
     case "face":
@@ -5702,7 +5947,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
             headOwnRoll(byRole.has("body"))
           ),
           localWarp(
-            import_format9.StandardParameter.Breath,
+            import_format10.StandardParameter.Breath,
             mesh,
             b,
             [0, 1],
@@ -5749,8 +5994,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
       if (byRole.has("mouth_open")) {
         warps.push(mouthWiden(mesh, b));
         bindings.push(
-          { parameter: import_format9.StandardParameter.MouthOpen, channel: "opacity", from: 1, to: 0 },
-          { parameter: import_format9.StandardParameter.MouthOpen, channel: "opacity", from: 1, to: 0 }
+          { parameter: import_format10.StandardParameter.MouthOpen, channel: "opacity", from: 1, to: 0 },
+          { parameter: import_format10.StandardParameter.MouthOpen, channel: "opacity", from: 1, to: 0 }
         );
         extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       } else {
@@ -5760,19 +6005,19 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
         );
         bindings.push(
           {
-            parameter: import_format9.StandardParameter.MouthOpen,
+            parameter: import_format10.StandardParameter.MouthOpen,
             channel: "scaleY",
             from: 0,
             to: roundTo(grow, 0.01)
           },
           {
-            parameter: import_format9.StandardParameter.MouthOpen,
+            parameter: import_format10.StandardParameter.MouthOpen,
             channel: "scaleX",
             from: 0,
             to: roundTo(AMPLITUDE.mouthOpenWidth - 1, 0.01)
           },
           {
-            parameter: import_format9.StandardParameter.MouthOpen,
+            parameter: import_format10.StandardParameter.MouthOpen,
             channel: "translateY",
             from: 0,
             to: -roundTo(grow * bh(b) / 2, 0.01)
@@ -5784,17 +6029,26 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
     case "mouth_open":
       warps.push(mouthForm(mesh, b), mouthOpenGrow(mesh, b));
       bindings.push({
-        parameter: import_format9.StandardParameter.MouthOpen,
+        parameter: import_format10.StandardParameter.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: import_format9.StandardParameter.Cheek,
+        parameter: import_format10.StandardParameter.Cheek,
         channel: "opacity",
         from: AMPLITUDE.blushRest,
         to: 1
@@ -5805,8 +6059,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(import_format9.StandardParameter.HairSwayX, mesh, b, amp),
-          hairSway(import_format9.StandardParameter.HairSwayZ, mesh, b, amp)
+          hairSway(import_format10.StandardParameter.HairSwayX, mesh, b, amp),
+          hairSway(import_format10.StandardParameter.HairSwayZ, mesh, b, amp)
         );
       }
       warps.push(tiltHang(mesh, b, pivot, hairHangWeight(frame.chinY, b.y0)));
@@ -5847,29 +6101,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":
@@ -5895,9 +6126,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: import_format9.StandardParameter.AngleZ, channel: "rotate", from: roll, to: -roll },
+      { parameter: import_format10.StandardParameter.AngleZ, channel: "rotate", from: roll, to: -roll },
       {
-        parameter: import_format9.StandardParameter.Breath,
+        parameter: import_format10.StandardParameter.Breath,
         channel: "translateY",
         from: 0,
         to: roundTo(headOwnBreath(hasBody) * frame.hh, 0.01)
@@ -5915,8 +6146,8 @@ function deformers(frame, grids, bodyWarp, arms, byRole) {
         points: g.lattice.points
       },
       warp2d: {
-        parameter: import_format9.StandardParameter.AngleX,
-        parameterY: import_format9.StandardParameter.AngleY,
+        parameter: import_format10.StandardParameter.AngleX,
+        parameterY: import_format10.StandardParameter.AngleY,
         valuesX: X_STOPS,
         valuesY: Y_STOPS,
         keyforms2d: g.keyforms.map((offsets) => ({ offsets }))
@@ -5929,16 +6160,16 @@ function hairPhysics() {
   return [
     {
       id: "hairSway",
-      input: { parameter: import_format9.StandardParameter.AngleX, weight: 1 },
-      output: { parameter: import_format9.StandardParameter.HairSwayX, scale: 5 },
+      input: { parameter: import_format10.StandardParameter.AngleX, weight: 1 },
+      output: { parameter: import_format10.StandardParameter.HairSwayX, scale: 5 },
       mass: 1,
       stiffness: 30,
       damping: 3
     },
     {
       id: "hairTilt",
-      input: { parameter: import_format9.StandardParameter.AngleZ, weight: 1 },
-      output: { parameter: import_format9.StandardParameter.HairSwayZ, scale: 8 },
+      input: { parameter: import_format10.StandardParameter.AngleZ, weight: 1 },
+      output: { parameter: import_format10.StandardParameter.HairSwayZ, scale: 8 },
       mass: 1,
       stiffness: 25,
       damping: 2.5
@@ -5948,13 +6179,13 @@ function hairPhysics() {
 function declareParameters(roles) {
   const out = [];
   const add = (id, name, min, max, def) => out.push({ id, name, min, max, default: def });
-  add(import_format9.StandardParameter.AngleX, "Head Angle", -30, 30, 0);
-  add(import_format9.StandardParameter.AngleY, "Head Angle Y", -30, 30, 0);
-  add(import_format9.StandardParameter.AngleZ, "Head Angle Z", -30, 30, 0);
+  add(import_format10.StandardParameter.AngleX, "Head Angle", -30, 30, 0);
+  add(import_format10.StandardParameter.AngleY, "Head Angle Y", -30, 30, 0);
+  add(import_format10.StandardParameter.AngleZ, "Head Angle Z", -30, 30, 0);
   if (roles.has("body")) {
-    add(import_format9.StandardParameter.BodyAngleX, "Body Angle X", -10, 10, 0);
-    add(import_format9.StandardParameter.BodyAngleY, "Body Angle Y", -10, 10, 0);
-    add(import_format9.StandardParameter.BodyAngleZ, "Body Angle Z", -10, 10, 0);
+    add(import_format10.StandardParameter.BodyAngleX, "Body Angle X", -10, 10, 0);
+    add(import_format10.StandardParameter.BodyAngleY, "Body Angle Y", -10, 10, 0);
+    add(import_format10.StandardParameter.BodyAngleZ, "Body Angle Z", -10, 10, 0);
   }
   const addPose = (side, pose, angle) => {
     add(pose, `Arm Pose ${side}`, 0, 1, 0);
@@ -5963,40 +6194,40 @@ function declareParameters(roles) {
   const [armMin, armMax] = ARM_RANGE;
   const [elbowMin, elbowMax] = ELBOW_RANGE;
   if (roles.has("arm_L")) {
-    add(import_format9.StandardParameter.ArmLeft, "Arm L", armMin, armMax, 0);
-    add(import_format9.StandardParameter.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
+    add(import_format10.StandardParameter.ArmLeft, "Arm L", armMin, armMax, 0);
+    add(import_format10.StandardParameter.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
     if (roles.has("forearm_pose_L"))
-      addPose("L", import_format9.StandardParameter.ArmPoseLeft, import_format9.StandardParameter.ArmPoseAngleLeft);
+      addPose("L", import_format10.StandardParameter.ArmPoseLeft, import_format10.StandardParameter.ArmPoseAngleLeft);
   }
   if (roles.has("arm_R")) {
-    add(import_format9.StandardParameter.ArmRight, "Arm R", armMin, armMax, 0);
-    add(import_format9.StandardParameter.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
+    add(import_format10.StandardParameter.ArmRight, "Arm R", armMin, armMax, 0);
+    add(import_format10.StandardParameter.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
     if (roles.has("forearm_pose_R"))
-      addPose("R", import_format9.StandardParameter.ArmPoseRight, import_format9.StandardParameter.ArmPoseAngleRight);
+      addPose("R", import_format10.StandardParameter.ArmPoseRight, import_format10.StandardParameter.ArmPoseAngleRight);
   }
-  add(import_format9.StandardParameter.EyeOpenLeft, "Eye L", 0, 1, 1);
-  add(import_format9.StandardParameter.EyeOpenRight, "Eye R", 0, 1, 1);
+  add(import_format10.StandardParameter.EyeOpenLeft, "Eye L", 0, 1, 1);
+  add(import_format10.StandardParameter.EyeOpenRight, "Eye R", 0, 1, 1);
   if ([...roles].some((r) => /^(iris|pupil|highlight)_/.test(r))) {
-    add(import_format9.StandardParameter.EyeballX, "Gaze X", -1, 1, 0);
-    add(import_format9.StandardParameter.EyeballY, "Gaze Y", -1, 1, 0);
+    add(import_format10.StandardParameter.EyeballX, "Gaze X", -1, 1, 0);
+    add(import_format10.StandardParameter.EyeballY, "Gaze Y", -1, 1, 0);
   }
-  add(import_format9.StandardParameter.MouthOpen, "Mouth Open", 0, 1, 0);
-  add(import_format9.StandardParameter.MouthForm, "Mouth Form", -1, 1, 0);
+  add(import_format10.StandardParameter.MouthOpen, "Mouth Open", 0, 1, 0);
+  add(import_format10.StandardParameter.MouthForm, "Mouth Form", -1, 1, 0);
   if (roles.has("brow_L")) {
-    add(import_format9.StandardParameter.BrowLeftY, "Brow L Y", -1, 1, 0);
-    add(import_format9.StandardParameter.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
+    add(import_format10.StandardParameter.BrowLeftY, "Brow L Y", -1, 1, 0);
+    add(import_format10.StandardParameter.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
   }
   if (roles.has("brow_R")) {
-    add(import_format9.StandardParameter.BrowRightY, "Brow R Y", -1, 1, 0);
-    add(import_format9.StandardParameter.BrowRightAngle, "Brow R Angle", -1, 1, 0);
+    add(import_format10.StandardParameter.BrowRightY, "Brow R Y", -1, 1, 0);
+    add(import_format10.StandardParameter.BrowRightAngle, "Brow R Angle", -1, 1, 0);
   }
   if (roles.has("blush_L") || roles.has("blush_R")) {
-    add(import_format9.StandardParameter.Cheek, "Cheek", 0, 1, 0);
+    add(import_format10.StandardParameter.Cheek, "Cheek", 0, 1, 0);
   }
-  add(import_format9.StandardParameter.Breath, "Breath", 0, 1, 0);
+  add(import_format10.StandardParameter.Breath, "Breath", 0, 1, 0);
   if (roles.has("hair_front")) {
-    add(import_format9.StandardParameter.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
-    add(import_format9.StandardParameter.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(import_format10.StandardParameter.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(import_format10.StandardParameter.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
   }
   return out;
 }