@ikijs/editor 0.23.0 → 0.24.0

package/dist/index.d.mts

@@ -891,9 +891,12 @@ interface GenerateOptions {
  * wedge carries the painted line, fading out in the antialias column as the
  * painted edge does; the fan inside it is the crop's own pixels.
  *
- * Draw order: hair_back < body < elbow_L, arm_L, forearm_L, elbow_R, arm_R,
- * forearm_R < face … < hair_front. The forearm draws over the upper arm,
- * which draws over the cap.
+ * Draw order: hair_back < body < elbow_L, forearm_L, arm_L, elbow_R,
+ * forearm_R, arm_R < face … < hair_front. The upper arm draws over the
+ * forearm, which draws over the cap. On the inside of a bend the bands
+ * overlap, and the forearm's seam-row cut stays under the upper arm there, so
+ * the overlap shows the upper arm's bottom edge at the elbow row instead of
+ * the cut rotated up the sleeve.
  *
  * Signs: ParamArmX + raises the arm outward on either side, in degrees 1:1.
  * A rotation is CCW-positive, so an arm whose shoulder lies right of the
@@ -1070,17 +1073,23 @@ declare function parseLayerRoles(fileNames: string[]): {
  * then stay inside the line's closed ink at every column, the tapered ends
  * included, and tucked skin never shows above the line.
  *
- * The seam is the line's drawn bottom edge `Tu` plus one smooth closing
- * travel `D`, a cubic in the column index pinned to zero at the opening's two
- * end columns, so the closed line's ends are the drawn line's own ends. It is
- * fitted by least squares to the raw per-column travel `(T - UPPER_SHARE * H)
- * - Tu`, how far the line's bottom is from the share's point in the
- * interior's span. The travel is fitted, not the seam, because `Tu` is an
- * integer-row read: a smooth seam minus that staircase is a sawtooth the mesh
- * would carry into the rendered line, while a smooth travel carries the
- * drawn stroke (whose antialiased edge is smooth) as one piece. The share sets
- * the travel's depth (the sag), the art's two arcs its shape; the cubic keeps
- * an asymmetric mouth's tilt and cannot wobble.
+ * Shut, the line is a smooth parabola across the opening. Its chord joins the
+ * line's smoothed bottom (below) at the two end columns; its depth below the
+ * chord, half way, is the sag at the centre column of the drawn arc plus a
+ * fitted closing travel: a cubic in the column index, pinned to zero at the
+ * end columns and fitted by least squares to the raw per-column travel
+ * `(T - UPPER_SHARE * H) - Tu`, how far the line's bottom is from the share's
+ * point in the interior's span. That sag is capped at `CLOSED_SAG_MAX` of the
+ * opening's width, the drawn arc included, so a deep opening closes into a
+ * gentle smile and a line drawn deeper than the cap closes flatter than
+ * drawn. The seam is `Tu` plus the column's travel: the parabola minus the
+ * line's bottom averaged over 3 columns each side (the smoothed bottom), not
+ * minus `Tu` itself, so the end columns do not travel. `Tu` is an integer-row read, and a curve minus that staircase
+ * is a sawtooth the mesh would carry into the rendered line; against the
+ * smoothed bottom the stroke (whose antialiased edge is smooth) moves as one
+ * piece, and a kink drawn in it (a V at the centre) keeps only its offset
+ * from that average, which the cap counts in. Every closed shape and the
+ * preview are read off the seam.
  *
  * The lower lip's columns outside the opening (the corner hooks) do not fold,
  * the line's are only thinned and shaped (no travel), and the interior's edge
@@ -1093,9 +1102,9 @@ declare function parseLayerRoles(fileNames: string[]): {
  *
  * Knots: the parts share column knots every `MOUTH_KNOT_PX` plus the
  * opening's boundaries `x0`, `x1` and `x1 + 1`, each an integer canvas
- * boundary. The fit's x is the column index, which is the mesh's boundary
+ * boundary. The travel's x is the column index, which is the mesh's boundary
  * position: a knot at boundary `b` samples column `b`, so the mesh renders the
- * fit exactly at its knots and the pinned ends render as pinned (`x1` and
+ * travel exactly at its knots and the pinned ends render as pinned (`x1` and
  * `x1 + 1` both sample the last column; the second sits at its right edge).
  * The preview resamples each column through the lip meshes' own landed rows
  * (`mouthRestShift`). A part's mesh rounds its local x, so one knot
@@ -1129,8 +1138,8 @@ interface OpeningColumn {
     /** How far the skin tucks up under the line shut: inside the thinned,
      *  squashed line's ink. */
     overlap: number;
-    /** Where the lips meet when shut: the line's bottom edge after its smooth
-     *  closing travel. */
+    /** Where the lips meet when shut: the line's bottom edge after its closing
+     *  travel. */
     seam: number;
 }
 interface Opening {
@@ -1507,10 +1516,17 @@ interface AtlasLayout {
  * BOTTOM only. Page left/top edges need no gutter.
  *
  * pageWidth/pageHeight = tight bound (max x+width+padding, max y+height+padding).
+ * When `maxSide` is given and the first layout is taller than it but not wider,
+ * the pack is retried at every width from the widest padded source up to `maxSide`, and the first
+ * layout that fits the height wins (shelf height is not monotonic in width);
+ * when none does the first is returned for the caller to refuse. The attempts
+ * are every width for this shelf order, not a proof that no packing exists.
+ *
  * Empty sources → { pageWidth: 0, pageHeight: 0, placements: [], padding }.
- * Throws a plain Error naming the offending source id on a non-finite or <= 0 dimension.
+ * Throws a plain Error naming the offending source id on a non-finite or <= 0 dimension,
+ * and on a supplied `maxSide` that is non-finite or <= 0.
  */
-declare function packAtlas(sources: AtlasSource[], padding?: number): AtlasLayout;
+declare function packAtlas(sources: AtlasSource[], padding?: number, maxSide?: number): AtlasLayout;
 /**
  * Convert a pixel placement into a UV rect, inset by `insetPx` on all four
  * edges and clamped to [0, 1] so the validator's bounds check always passes.

package/dist/index.d.ts

@@ -891,9 +891,12 @@ interface GenerateOptions {
  * wedge carries the painted line, fading out in the antialias column as the
  * painted edge does; the fan inside it is the crop's own pixels.
  *
- * Draw order: hair_back < body < elbow_L, arm_L, forearm_L, elbow_R, arm_R,
- * forearm_R < face … < hair_front. The forearm draws over the upper arm,
- * which draws over the cap.
+ * Draw order: hair_back < body < elbow_L, forearm_L, arm_L, elbow_R,
+ * forearm_R, arm_R < face … < hair_front. The upper arm draws over the
+ * forearm, which draws over the cap. On the inside of a bend the bands
+ * overlap, and the forearm's seam-row cut stays under the upper arm there, so
+ * the overlap shows the upper arm's bottom edge at the elbow row instead of
+ * the cut rotated up the sleeve.
  *
  * Signs: ParamArmX + raises the arm outward on either side, in degrees 1:1.
  * A rotation is CCW-positive, so an arm whose shoulder lies right of the
@@ -1070,17 +1073,23 @@ declare function parseLayerRoles(fileNames: string[]): {
  * then stay inside the line's closed ink at every column, the tapered ends
  * included, and tucked skin never shows above the line.
  *
- * The seam is the line's drawn bottom edge `Tu` plus one smooth closing
- * travel `D`, a cubic in the column index pinned to zero at the opening's two
- * end columns, so the closed line's ends are the drawn line's own ends. It is
- * fitted by least squares to the raw per-column travel `(T - UPPER_SHARE * H)
- * - Tu`, how far the line's bottom is from the share's point in the
- * interior's span. The travel is fitted, not the seam, because `Tu` is an
- * integer-row read: a smooth seam minus that staircase is a sawtooth the mesh
- * would carry into the rendered line, while a smooth travel carries the
- * drawn stroke (whose antialiased edge is smooth) as one piece. The share sets
- * the travel's depth (the sag), the art's two arcs its shape; the cubic keeps
- * an asymmetric mouth's tilt and cannot wobble.
+ * Shut, the line is a smooth parabola across the opening. Its chord joins the
+ * line's smoothed bottom (below) at the two end columns; its depth below the
+ * chord, half way, is the sag at the centre column of the drawn arc plus a
+ * fitted closing travel: a cubic in the column index, pinned to zero at the
+ * end columns and fitted by least squares to the raw per-column travel
+ * `(T - UPPER_SHARE * H) - Tu`, how far the line's bottom is from the share's
+ * point in the interior's span. That sag is capped at `CLOSED_SAG_MAX` of the
+ * opening's width, the drawn arc included, so a deep opening closes into a
+ * gentle smile and a line drawn deeper than the cap closes flatter than
+ * drawn. The seam is `Tu` plus the column's travel: the parabola minus the
+ * line's bottom averaged over 3 columns each side (the smoothed bottom), not
+ * minus `Tu` itself, so the end columns do not travel. `Tu` is an integer-row read, and a curve minus that staircase
+ * is a sawtooth the mesh would carry into the rendered line; against the
+ * smoothed bottom the stroke (whose antialiased edge is smooth) moves as one
+ * piece, and a kink drawn in it (a V at the centre) keeps only its offset
+ * from that average, which the cap counts in. Every closed shape and the
+ * preview are read off the seam.
  *
  * The lower lip's columns outside the opening (the corner hooks) do not fold,
  * the line's are only thinned and shaped (no travel), and the interior's edge
@@ -1093,9 +1102,9 @@ declare function parseLayerRoles(fileNames: string[]): {
  *
  * Knots: the parts share column knots every `MOUTH_KNOT_PX` plus the
  * opening's boundaries `x0`, `x1` and `x1 + 1`, each an integer canvas
- * boundary. The fit's x is the column index, which is the mesh's boundary
+ * boundary. The travel's x is the column index, which is the mesh's boundary
  * position: a knot at boundary `b` samples column `b`, so the mesh renders the
- * fit exactly at its knots and the pinned ends render as pinned (`x1` and
+ * travel exactly at its knots and the pinned ends render as pinned (`x1` and
  * `x1 + 1` both sample the last column; the second sits at its right edge).
  * The preview resamples each column through the lip meshes' own landed rows
  * (`mouthRestShift`). A part's mesh rounds its local x, so one knot
@@ -1129,8 +1138,8 @@ interface OpeningColumn {
     /** How far the skin tucks up under the line shut: inside the thinned,
      *  squashed line's ink. */
     overlap: number;
-    /** Where the lips meet when shut: the line's bottom edge after its smooth
-     *  closing travel. */
+    /** Where the lips meet when shut: the line's bottom edge after its closing
+     *  travel. */
     seam: number;
 }
 interface Opening {
@@ -1507,10 +1516,17 @@ interface AtlasLayout {
  * BOTTOM only. Page left/top edges need no gutter.
  *
  * pageWidth/pageHeight = tight bound (max x+width+padding, max y+height+padding).
+ * When `maxSide` is given and the first layout is taller than it but not wider,
+ * the pack is retried at every width from the widest padded source up to `maxSide`, and the first
+ * layout that fits the height wins (shelf height is not monotonic in width);
+ * when none does the first is returned for the caller to refuse. The attempts
+ * are every width for this shelf order, not a proof that no packing exists.
+ *
  * Empty sources → { pageWidth: 0, pageHeight: 0, placements: [], padding }.
- * Throws a plain Error naming the offending source id on a non-finite or <= 0 dimension.
+ * Throws a plain Error naming the offending source id on a non-finite or <= 0 dimension,
+ * and on a supplied `maxSide` that is non-finite or <= 0.
  */
-declare function packAtlas(sources: AtlasSource[], padding?: number): AtlasLayout;
+declare function packAtlas(sources: AtlasSource[], padding?: number, maxSide?: number): AtlasLayout;
 /**
  * Convert a pixel placement into a UV rect, inset by `insetPx` on all four
  * edges and clamped to [0, 1] so the validator's bounds check always passes.

package/dist/index.js

@@ -1845,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(
@@ -1866,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;
@@ -3004,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) => ({
@@ -3105,8 +3116,8 @@ 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" },
@@ -3251,6 +3262,7 @@ 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;
@@ -3317,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;
@@ -3338,16 +3355,24 @@ 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 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) => {