@ikijs/editor 0.22.0 → 0.23.0

package/dist/index.mjs

@@ -3026,6 +3026,8 @@ import {
 // src/auto-rig/roles.ts
 var LIP_ROLES = ["mouth_inner", "lip_lower", "lip_upper"];
 var isLipRole = (role) => LIP_ROLES.includes(role);
+var LIP_INSIDE_ROLES = ["mouth_tongue", "mouth_teeth"];
+var isLipInsideRole = (role) => LIP_INSIDE_ROLES.includes(role);
 var ROLE_TABLE = [
   { role: "hair_back", family: "hair_back" },
   { role: "body", family: "body" },
@@ -3037,10 +3039,13 @@ var ROLE_TABLE = [
   { role: "nose", family: "nose" },
   { 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.
+  // The lip set, back to front: the interior, the tongue and the teeth clipped
+  // to it, 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: "mouth_tongue", family: "mouth" },
+  { role: "mouth_teeth", family: "mouth" },
   { role: "lip_lower", family: "mouth" },
   { role: "lip_upper", family: "mouth" },
   { role: "eye_L", family: "eye_L", required: true },
@@ -3103,6 +3108,12 @@ function checkArmsHaveBody(roles) {
 function checkMouth(roles) {
   const has = new Set(roles);
   const present = LIP_ROLES.filter((r) => has.has(r));
+  const inside = LIP_INSIDE_ROLES.filter((r) => has.has(r));
+  if (inside.length > 0 && present.length === 0) {
+    throw new Error(
+      `auto-rig: ${inside[0]} needs the lip set ${LIP_ROLES.join(", ")} (it is cut from the interior and clipped to it)`
+    );
+  }
   if (present.length === 0) {
     if (!has.has("mouth")) {
       throw new Error(
@@ -3166,6 +3177,11 @@ function parseLayerRoles(fileNames) {
 
 // src/auto-rig/mouth.ts
 var UPPER_SHARE = 0.4;
+var UPPER_THIN = 0.7;
+var END_TAPER = 0.35;
+var END_TAPER_FROM = 0.7;
+var FLICK_PULL = 0.5;
+var FLICK_SQUASH = 0.25;
 var MOUTH_KNOT_PX = 4;
 var isLipSet = (byRole) => LIP_ROLES.every((r) => byRole.has(r));
 function columnRuns(layer) {
@@ -3255,9 +3271,17 @@ function mouthOpening(byRole) {
     const x = x0 + i;
     return { ...r, seam: r.Tu + (x - x0) * (x - x1) * (p + q * (x - m)) };
   });
-  const base = (col) => columns[Math.min(x1, Math.max(x0, col)) - x0];
+  const clamp2 = (col) => Math.min(x1, Math.max(x0, col));
+  const base = (col) => columns[clamp2(col) - x0];
   const centre = Math.round((x0 + x1) / 2);
   const w = base(centre).lineH;
+  const from = END_TAPER_FROM * ((x1 - x0 + 1) / 2);
+  const squash = (col) => {
+    const d = Math.abs(col - centre);
+    const edge = col < centre ? centre - upper.bbox.x : upper.bbox.x + upper.bbox.w - 1 - centre;
+    const t = d <= from ? 0 : d >= edge ? 1 : (d - from) / (edge - from);
+    return 1 - (1 - END_TAPER) * t;
+  };
   return {
     x0,
     x1,
@@ -3266,39 +3290,80 @@ function mouthOpening(byRole) {
     w,
     at(col) {
       const b = base(col);
-      return { ...b, overlap: Math.max(0, Math.min(w, b.lineH)) };
+      const s = squash(clamp2(col));
+      return {
+        ...b,
+        overlap: UPPER_THIN * (b.lineH * (1 - s) / 2 + Math.min(w, b.lineH) * s)
+      };
+    },
+    line(col) {
+      if (col >= x0 && col <= x1) {
+        const b = base(col);
+        return { bottom: b.Tu, top: b.lineTop, squash: squash(col) };
+      }
+      const runs = upperCols.get(col);
+      if (runs === void 0) return void 0;
+      return {
+        bottom: edgesOf(upper, runs[runs.length - 1]).bottom,
+        top: edgesOf(upper, runs[0]).top,
+        squash: FLICK_SQUASH
+      };
     }
   };
 }
 function mouthFold(role, opening) {
+  const { x0, x1 } = opening;
+  const stackThin = (c, y) => y > c.Tu ? c.Tu + UPPER_THIN * (y - c.Tu) : y;
   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;
+    const inside = col >= x0 && col <= x1;
     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;
+      case "lip_lower": {
+        if (!inside) return [0, 0];
+        const c = opening.at(col);
+        return [0, (c.seam + c.overlap - c.Bl) * k];
+      }
+      case "mouth_inner": {
+        const c = opening.at(col);
+        const S = c.seam + c.overlap;
+        return [0, S + v * (stackThin(c, y) - S) - y];
+      }
+      case "mouth_teeth": {
+        const c = opening.at(col);
+        return [0, stackThin(c, y) - y + (c.seam - c.Tu) * k];
+      }
+      case "mouth_tongue": {
+        const c = opening.at(col);
+        return [0, (c.seam + c.overlap - c.Bb) * k];
+      }
+      case "lip_upper": {
+        let c = col;
+        let line = opening.line(c);
+        while (line === void 0)
+          line = opening.line(c += col < x0 ? 1 : -1);
+        const thin = line.bottom + UPPER_THIN * (y - line.bottom);
+        const mid = line.bottom + UPPER_THIN * (line.top - line.bottom) / 2;
+        const travel = inside ? opening.at(col).seam - line.bottom : 0;
+        const shut = mid + line.squash * (thin - mid) + travel;
+        const pull = inside ? 0 : (1 - FLICK_PULL) * ((col < x0 ? x0 : x1 + 1) - col);
+        return [pull * k, thin - y + (shut - thin) * k];
+      }
     }
   };
 }
-function columnOfKnot(knot, opening, role) {
+function columnOfKnot(knot, opening) {
   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;
+  return boundary === opening.x1 + 1 ? opening.x1 : boundary;
 }
 function mouthFoldWarp(role, mesh, xs, box, opening) {
   const fold = mouthFold(role, opening);
-  return localWarp(P5.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)];
-  });
+  return localWarp(
+    P5.MouthOpen,
+    mesh,
+    box,
+    [0, 1],
+    (p, v, i) => fold(columnOfKnot(xs[i % xs.length], opening), p[1], v)
+  );
 }
 function mouthRestShift(byRole) {
   const rig = buildMouthRig(byRole);
@@ -3311,18 +3376,31 @@ function mouthRestShift(byRole) {
     fields.set(role, {
       box,
       xs,
-      dy: xs.map((_, i) => offsets[2 * i + 1] * bh(box))
+      rows: offsets.length / 2 / xs.length - 1,
+      dy: offsets.filter((_, i) => i % 2 === 1).map((o) => o * bh(box))
     });
   }
-  const half = rig.opening.canvasW / 2;
-  return (role, col) => {
-    const { box, xs, dy } = fields.get(role);
-    const x = col + 0.5 - half;
-    if (x < box.x0 || x > box.x1) return 0;
+  const { canvasW, canvasH } = byRole.get("lip_upper");
+  return (role, col, row) => {
+    const { box, xs, rows, dy } = fields.get(role);
+    const x = col + 0.5 - canvasW / 2;
+    const y = canvasH / 2 - (row + 0.5);
+    if (x < box.x0 || x > box.x1 || y < box.y0 || y > box.y1) return void 0;
     let k = 1;
     while (k < xs.length - 1 && xs[k] < x) k++;
-    const t = (x - xs[k - 1]) / (xs[k] - xs[k - 1]);
-    return dy[k - 1] + (dy[k] - dy[k - 1]) * t;
+    const down = (box.y1 - y) / bh(box) * rows;
+    const r = Math.min(rows - 1, Math.floor(down));
+    const fx = (x - xs[k - 1]) / (xs[k] - xs[k - 1]);
+    const fy = down - r;
+    const at = (i, j) => dy[i * xs.length + j];
+    const tl = at(r, k - 1);
+    const br = at(r + 1, k);
+    if (fx <= fy) {
+      const bl = at(r + 1, k - 1);
+      return tl + fy * (bl - tl) + fx * (br - bl);
+    }
+    const tr = at(r, k);
+    return tl + fx * (tr - tl) + fy * (br - tr);
   };
 }
 function mouthKnots(union, opening) {
@@ -5917,7 +5995,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
     headStart = fm.headStart;
   } else if (spec.role === "hair_front") {
     mesh = columnMesh(b, frontGrid);
-  } else if (lips !== void 0 && isLipRole(spec.role)) {
+  } else if (lips !== void 0 && (isLipRole(spec.role) || isLipInsideRole(spec.role))) {
     ({ mesh, xs: knotXs } = mouthMesh(b, lips.knots));
   } else if (spec.family !== "body") {
     const cells = MESH_CELLS[spec.role] ?? FEATURE_MESH_CELLS;
@@ -6034,6 +6112,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
       extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       break;
     case "mouth_inner":
+    case "mouth_tongue":
+    case "mouth_teeth":
     case "lip_lower":
     case "lip_upper":
       warps.push(
@@ -6041,6 +6121,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
         mouthForm(mesh, b, lips.frame),
         mouthWiden(mesh, b, lips.frame)
       );
+      if (isLipInsideRole(spec.role)) part.clip = { masks: ["mouth_inner"] };
       break;
     case "blush_L":
     case "blush_R":
@@ -6242,6 +6323,7 @@ export {
   DeletePhysicsRig,
   EditorDocument,
   HEAD_BAND,
+  LIP_INSIDE_ROLES,
   LIP_ROLES,
   LayerGeometryError,
   SPECK_CORE_FRACTION,
@@ -6278,6 +6360,7 @@ export {
   generateIkiFromLayerSet,
   headHalfOf,
   interpolateGridOffsets,
+  isLipInsideRole,
   isSpeckCore,
   mouthFold,
   mouthOpening,