@ikijs/editor 0.22.0 → 0.24.0

package/dist/index.js

@@ -33,6 +33,7 @@ __export(index_exports, {
   DeletePhysicsRig: () => DeletePhysicsRig,
   EditorDocument: () => EditorDocument,
   HEAD_BAND: () => HEAD_BAND,
+  LIP_INSIDE_ROLES: () => LIP_INSIDE_ROLES,
   LIP_ROLES: () => LIP_ROLES,
   LayerGeometryError: () => LayerGeometryError,
   SPECK_CORE_FRACTION: () => SPECK_CORE_FRACTION,
@@ -69,6 +70,7 @@ __export(index_exports, {
   generateIkiFromLayerSet: () => generateIkiFromLayerSet,
   headHalfOf: () => headHalfOf,
   interpolateGridOffsets: () => interpolateGridOffsets,
+  isLipInsideRole: () => isLipInsideRole,
   isSpeckCore: () => isSpeckCore,
   mouthFold: () => mouthFold,
   mouthOpening: () => mouthOpening,
@@ -1843,7 +1845,10 @@ function captureBindingEndpoint(channel, restValue, posedValue) {
 // src/atlas.ts
 var ATLAS_PADDING = 2;
 var UV_INSET_PX = 0.5;
-function packAtlas(sources, padding = ATLAS_PADDING) {
+function packAtlas(sources, padding = ATLAS_PADDING, maxSide) {
+  if (maxSide !== void 0 && !(isFinite(maxSide) && maxSide > 0)) {
+    throw new Error(`packAtlas: invalid maxSide ${maxSide}`);
+  }
   for (const src of sources) {
     if (!isFinite(src.width) || src.width <= 0) {
       throw new Error(
@@ -1864,42 +1869,50 @@ function packAtlas(sources, padding = ATLAS_PADDING) {
     (sum, s) => sum + (s.width + padding) * (s.height + padding),
     0
   );
-  const targetWidth = Math.max(
-    Math.ceil(Math.sqrt(totalArea)),
-    // Ensure at least the widest single source fits.
-    Math.max(...sorted.map((s) => s.width + padding))
-  );
-  const placements = [];
-  let shelfX = 0;
-  let shelfY = 0;
-  let shelfHeight = 0;
-  for (const src of sorted) {
-    const paddedW = src.width + padding;
-    const paddedH = src.height + padding;
-    if (shelfX > 0 && shelfX + paddedW > targetWidth) {
-      shelfY += shelfHeight;
-      shelfX = 0;
-      shelfHeight = 0;
-    }
-    placements.push({
-      id: src.id,
-      x: shelfX,
-      y: shelfY,
-      width: src.width,
-      height: src.height
-    });
-    shelfX += paddedW;
-    if (paddedH > shelfHeight) shelfHeight = paddedH;
+  const widest = Math.max(...sorted.map((s) => s.width + padding));
+  const firstWidth = Math.max(Math.ceil(Math.sqrt(totalArea)), widest);
+  const shelve = (targetWidth) => {
+    const placements = [];
+    let shelfX = 0;
+    let shelfY = 0;
+    let shelfHeight = 0;
+    for (const src of sorted) {
+      const paddedW = src.width + padding;
+      const paddedH = src.height + padding;
+      if (shelfX > 0 && shelfX + paddedW > targetWidth) {
+        shelfY += shelfHeight;
+        shelfX = 0;
+        shelfHeight = 0;
+      }
+      placements.push({
+        id: src.id,
+        x: shelfX,
+        y: shelfY,
+        width: src.width,
+        height: src.height
+      });
+      shelfX += paddedW;
+      if (paddedH > shelfHeight) shelfHeight = paddedH;
+    }
+    let pageWidth = 0;
+    let pageHeight = 0;
+    for (const p of placements) {
+      const right = p.x + p.width + padding;
+      const bottom = p.y + p.height + padding;
+      if (right > pageWidth) pageWidth = right;
+      if (bottom > pageHeight) pageHeight = bottom;
+    }
+    return { pageWidth, pageHeight, placements };
+  };
+  const first = shelve(firstWidth);
+  if (maxSide === void 0 || first.pageHeight <= maxSide || first.pageWidth > maxSide) {
+    return { ...first, padding };
   }
-  let pageWidth = 0;
-  let pageHeight = 0;
-  for (const p of placements) {
-    const right = p.x + p.width + padding;
-    const bottom = p.y + p.height + padding;
-    if (right > pageWidth) pageWidth = right;
-    if (bottom > pageHeight) pageHeight = bottom;
+  for (let w = widest; w <= maxSide; w++) {
+    const layout = shelve(w);
+    if (layout.pageHeight <= maxSide) return { ...layout, padding };
   }
-  return { pageWidth, pageHeight, placements, padding };
+  return { ...first, padding };
 }
 function uvRectFor(placement, page, insetPx = UV_INSET_PX) {
   const px = placement.x + insetPx;
@@ -3002,14 +3015,14 @@ function armParts(role, layer, g, order, poseSwitch) {
       },
       true
     ),
-    part(role, ids.armDeformer, order + 1, meshOf(band(0.5, seam), quad)),
     part(
       ids.forearm,
       ids.forearmDeformer,
-      order + 2,
+      order + 1,
       meshOf(band(seam, -0.5), quad),
       true
-    )
+    ),
+    part(role, ids.armDeformer, order + 2, meshOf(band(0.5, seam), quad))
   ];
 }
 var rotateBinding = (parameter, range, sign) => ({
@@ -3098,21 +3111,26 @@ var import_format7 = require("@ikijs/format");
 // 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" },
-  { role: "arm_L", family: "arm", parts: ["elbow_L", "arm_L", "forearm_L"] },
-  { role: "arm_R", family: "arm", parts: ["elbow_R", "arm_R", "forearm_R"] },
+  { role: "arm_L", family: "arm", parts: ["elbow_L", "forearm_L", "arm_L"] },
+  { role: "arm_R", family: "arm", parts: ["elbow_R", "forearm_R", "arm_R"] },
   { role: "face", family: "face", required: true },
   { role: "blush_L", family: "face" },
   { role: "blush_R", family: "face" },
   { 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 },
@@ -3175,6 +3193,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(
@@ -3238,6 +3262,12 @@ function parseLayerRoles(fileNames) {
 
 // src/auto-rig/mouth.ts
 var UPPER_SHARE = 0.4;
+var CLOSED_SAG_MAX = 0.1;
+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) {
@@ -3299,10 +3329,15 @@ function mouthOpening(byRole) {
     for (let d = 0; (r = read(c - d) ?? read(c + d)) === void 0; d++) ;
     reads.push(r);
   }
+  const n = reads.length;
   const m = (x0 + x1) / 2;
-  let p = 0;
-  let q = 0;
-  if (reads.length >= 4) {
+  const centre = Math.round(m);
+  const smooth = reads.map((_, i) => {
+    const near = reads.slice(Math.max(0, i - 3), i + 4);
+    return near.reduce((s, r) => s + r.Tu, 0) / near.length;
+  });
+  let sag = 0;
+  if (n >= 4) {
     let s11 = 0;
     let s12 = 0;
     let s22 = 0;
@@ -3320,16 +3355,32 @@ function mouthOpening(byRole) {
       t2 += b2 * d;
     });
     const det = s11 * s22 - s12 * s12;
-    p = (t1 * s22 - t2 * s12) / det;
-    q = (s11 * t2 - s12 * t1) / det;
+    const p = (t1 * s22 - t2 * s12) / det;
+    const q = (s11 * t2 - s12 * t1) / det;
+    const c = centre - x0;
+    const D = c * (centre - x1) * (p + q * (centre - m));
+    const arc = (reads[0].Tu + reads[n - 1].Tu) / 2 - reads[c].Tu;
+    const t = c / (n - 1);
+    const k = 4 * t * (1 - t);
+    const offset = arc - (smooth[0] + (smooth[n - 1] - smooth[0]) * t - smooth[c]);
+    sag = Math.min(arc - D, CLOSED_SAG_MAX * n - Math.max(0, offset) / k);
   }
   const columns = reads.map((r, i) => {
-    const x = x0 + i;
-    return { ...r, seam: r.Tu + (x - x0) * (x - x1) * (p + q * (x - m)) };
+    if (n < 4) return { ...r, seam: r.Tu };
+    const t = i / (x1 - x0);
+    const parabola = smooth[0] + (smooth[n - 1] - smooth[0]) * t - sag * 4 * t * (1 - t);
+    return { ...r, seam: r.Tu + parabola - smooth[i] };
   });
-  const base = (col) => columns[Math.min(x1, Math.max(x0, col)) - x0];
-  const centre = Math.round((x0 + x1) / 2);
+  const clamp2 = (col) => Math.min(x1, Math.max(x0, col));
+  const base = (col) => columns[clamp2(col) - x0];
   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,
@@ -3338,39 +3389,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(import_format7.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)];
-  });
+  return localWarp(
+    import_format7.StandardParameter.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);
@@ -3383,18 +3475,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) {
@@ -5983,7 +6088,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;
@@ -6100,6 +6205,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(
@@ -6107,6 +6214,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":
@@ -6309,6 +6417,7 @@ function declareParameters(roles) {
   DeletePhysicsRig,
   EditorDocument,
   HEAD_BAND,
+  LIP_INSIDE_ROLES,
   LIP_ROLES,
   LayerGeometryError,
   SPECK_CORE_FRACTION,
@@ -6345,6 +6454,7 @@ function declareParameters(roles) {
   generateIkiFromLayerSet,
   headHalfOf,
   interpolateGridOffsets,
+  isLipInsideRole,
   isSpeckCore,
   mouthFold,
   mouthOpening,