@ikijs/editor 0.18.0 → 0.19.0

package/README.md

@@ -82,9 +82,9 @@ it), the ears lag the face, the far one narrowing. AngleZ rolls the head 14° ab
 A `body` rides a body warp that breathes, follows the head's turn and tilt a
 little and turns on `ParamBodyAngleX/Y/Z`, its legs planted, and the head
 hangs from it. `arm_L` / `arm_R`, each a whole arm drawn hanging with its
-shoulder at the top, hang from it too: each becomes an upper arm and a
-forearm cut from the one crop, turning about the shoulder and the elbow on
-`ParamArmL/R` and `ParamElbowL/R`. An arm needs a `body`.
+shoulder at the top, hang from it too: each becomes an elbow cap, an upper
+arm and a forearm cut from the one crop, turning about the shoulder and the
+elbow on `ParamArmL/R` and `ParamElbowL/R`. An arm needs a `body`.
 
 On a layer set with a `nose`, `options.turnTargets` — the cues a 30° reference
 measures (how far the eye pair slides, how much the far eye foreshortens,

package/dist/index.d.mts

@@ -857,31 +857,43 @@ interface GenerateOptions {
 
 /**
  * The arms. Each `arm_L` / `arm_R` layer is one drawing of the whole arm,
- * hanging, its shoulder at the top. It becomes two parts on two nested matrix
- * deformers hung from the body warp:
+ * hanging, its shoulder at the top. It becomes three parts on two nested
+ * matrix deformers hung from the body warp:
  * - the upper arm (the role's own id) on `armDeformer_X`, which turns about
  *   the shoulder, the deltoid cap's centre;
  * - the forearm (`forearm_X`) on `forearmDeformer_X`, a child of the arm's,
- *   which turns about the elbow.
+ *   which turns about the elbow;
+ * - the elbow cap (`elbow_X`), also on `forearmDeformer_X`, drawn behind the
+ *   upper arm.
  * The shoulder pivot rides an all-weight-1 cell of the body warp (`body.ts`),
  * so the arm breathes and turns with the chest rigidly, never sheared.
  *
- * Both parts are cut from the one crop: they share its box, transform and
- * texture rect, and their meshes meet on the seam, the elbow pivot's row. The
- * upper arm is the band above the seam. The forearm is the band below it plus
- * a half-disc fan above it, centred on the elbow pivot. Iki has no glue
- * between meshes, and two bands hinged at a seam open a wedge as wide as the
- * arm on a bend; the half-disc turns about its own centre, so it rotates into
- * itself and keeps the joint covered at any bend.
+ * All three parts are cut from the one crop: they share its box, transform
+ * and texture rect. The upper arm is the band above the seam, the elbow
+ * pivot's row; the forearm is the band below it. Iki has no glue between
+ * meshes, and two bands hinged at a seam open a wedge as wide as the arm on a
+ * bend. The cap fills it: a half-disc fan centred on the elbow pivot turns
+ * about its own centre, so it rotates into itself and keeps the joint covered
+ * at any bend.
  *
- * Draw order: hair_back < body < arm_L, forearm_L, arm_R, forearm_R < face …
- * < hair_front. The forearm draws over the upper arm, so its cap hides the
- * seam.
+ * Behind the upper arm, the cap shows only where the forearm's bend uncovers
+ * it, so it must lie inside the paint at rest, or its edge would show past
+ * the arm's. Its boundary is therefore the arm's own contour, not a circle:
+ * `armGeometry` walks each of the fan's 13 rays out from the elbow to the
+ * contour (`capRays`). A ring at the boundary, `CAP_RIM` wide, takes the UVs
+ * of the seam row's edge cross-section swept round the arc, so the exposed
+ * 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.
  *
- * Signs: ParamArmX + raises the arm outward on either side and ParamElbowX +
- * turns the forearm the same way, both in degrees 1:1. A rotation is
- * CCW-positive, so an arm whose shoulder lies right of the body's axis (+x,
- * the character's left) turns CCW for +, and one at −x turns CW.
+ * 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.
+ *
+ * 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
+ * body's axis (+x, the character's left) turns CCW for +, and one at −x turns
+ * CW. ParamElbowX + bends the forearm toward the body, the opposite turn to
+ * the shoulder's +: it turns CW on the +x side, CCW on the −x side.
  */
 
 type Point = {
@@ -895,8 +907,14 @@ interface ArmGeometry {
     shoulderRadius: number;
     /** The elbow pivot, model space. Its y is the seam the two meshes meet on. */
     elbow: Point;
-    /** The forearm's half-disc radius, px. */
+    /** The elbow cap's largest radius, px. */
     capRadius: number;
+    /** The cap's radius on each of its `CAP_SEGMENTS + 1` rays, from the elbow
+     *  at angles 0..π, px: the walk out to the contour, less `capInset`, at
+     *  most `capRadius`. */
+    capRays: number[];
+    /** The seam row's widest run, crop columns [start, end). */
+    seamRun: [number, number];
     /** +1 for a shoulder right of the body's axis (+ turns CCW), −1 left of it
      *  (+ turns CW). */
     side: 1 | -1;
@@ -910,7 +928,12 @@ interface ArmGeometry {
  *   run centre of the row it lands in;
  * - the elbow is the centre of the row `ELBOW_AT` of the way from there to
  *   the last painted row, at its run centre;
- * - the cap radius is half the elbow's run + 1 px, kept inside the crop.
+ * - the cap radius is half the elbow's run + 1 px, kept inside the crop;
+ * - each cap ray walks 1 px at a time from the elbow until it leaves the
+ *   widest run of the crop row it is in (strictly inside: `start < x < end`,
+ *   on canvas columns, the row the floor of the canvas y), then stops
+ *   `capInset(i)` short of that exit (none on the two seam-end rays, 2 px on
+ *   the next, `CAP_INSET` on the rest), and at `capRadius`.
  * Pivots are on the 0.01 grid, as the written model is. `bodyAxisX` is the
  * body's axis, model x: the shoulder's side of it sets the sign. An arm too
  * short for its width to put the elbow under the shoulder would rig
@@ -938,8 +961,8 @@ declare function parseLayerRoles(fileNames: string[]): {
  * (`body.ts`) that breathes, follows the head's turn and tilt a little and
  * turns on BodyAngleX/Y/Z, its legs planted; a head deformer hung from it
  * that rolls about the chin and breathes; each arm hung from it too, as an
- * upper arm and a forearm turning about the shoulder and the elbow
- * (`arms.ts`); one small warp grid per feature
+ * upper arm, a forearm and an elbow cap turning about the shoulder and the
+ * elbow (`arms.ts`); one small warp grid per feature
  * (each eye, each brow, the nose, the mouth), translating and foreshortening
  * it by its own lead over the plate; and the plate, the hair and the blush
  * moved by per-vertex keyforms of their own — the plate as up to four

package/dist/index.d.ts

@@ -857,31 +857,43 @@ interface GenerateOptions {
 
 /**
  * The arms. Each `arm_L` / `arm_R` layer is one drawing of the whole arm,
- * hanging, its shoulder at the top. It becomes two parts on two nested matrix
- * deformers hung from the body warp:
+ * hanging, its shoulder at the top. It becomes three parts on two nested
+ * matrix deformers hung from the body warp:
  * - the upper arm (the role's own id) on `armDeformer_X`, which turns about
  *   the shoulder, the deltoid cap's centre;
  * - the forearm (`forearm_X`) on `forearmDeformer_X`, a child of the arm's,
- *   which turns about the elbow.
+ *   which turns about the elbow;
+ * - the elbow cap (`elbow_X`), also on `forearmDeformer_X`, drawn behind the
+ *   upper arm.
  * The shoulder pivot rides an all-weight-1 cell of the body warp (`body.ts`),
  * so the arm breathes and turns with the chest rigidly, never sheared.
  *
- * Both parts are cut from the one crop: they share its box, transform and
- * texture rect, and their meshes meet on the seam, the elbow pivot's row. The
- * upper arm is the band above the seam. The forearm is the band below it plus
- * a half-disc fan above it, centred on the elbow pivot. Iki has no glue
- * between meshes, and two bands hinged at a seam open a wedge as wide as the
- * arm on a bend; the half-disc turns about its own centre, so it rotates into
- * itself and keeps the joint covered at any bend.
+ * All three parts are cut from the one crop: they share its box, transform
+ * and texture rect. The upper arm is the band above the seam, the elbow
+ * pivot's row; the forearm is the band below it. Iki has no glue between
+ * meshes, and two bands hinged at a seam open a wedge as wide as the arm on a
+ * bend. The cap fills it: a half-disc fan centred on the elbow pivot turns
+ * about its own centre, so it rotates into itself and keeps the joint covered
+ * at any bend.
  *
- * Draw order: hair_back < body < arm_L, forearm_L, arm_R, forearm_R < face …
- * < hair_front. The forearm draws over the upper arm, so its cap hides the
- * seam.
+ * Behind the upper arm, the cap shows only where the forearm's bend uncovers
+ * it, so it must lie inside the paint at rest, or its edge would show past
+ * the arm's. Its boundary is therefore the arm's own contour, not a circle:
+ * `armGeometry` walks each of the fan's 13 rays out from the elbow to the
+ * contour (`capRays`). A ring at the boundary, `CAP_RIM` wide, takes the UVs
+ * of the seam row's edge cross-section swept round the arc, so the exposed
+ * 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.
  *
- * Signs: ParamArmX + raises the arm outward on either side and ParamElbowX +
- * turns the forearm the same way, both in degrees 1:1. A rotation is
- * CCW-positive, so an arm whose shoulder lies right of the body's axis (+x,
- * the character's left) turns CCW for +, and one at −x turns CW.
+ * 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.
+ *
+ * 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
+ * body's axis (+x, the character's left) turns CCW for +, and one at −x turns
+ * CW. ParamElbowX + bends the forearm toward the body, the opposite turn to
+ * the shoulder's +: it turns CW on the +x side, CCW on the −x side.
  */
 
 type Point = {
@@ -895,8 +907,14 @@ interface ArmGeometry {
     shoulderRadius: number;
     /** The elbow pivot, model space. Its y is the seam the two meshes meet on. */
     elbow: Point;
-    /** The forearm's half-disc radius, px. */
+    /** The elbow cap's largest radius, px. */
     capRadius: number;
+    /** The cap's radius on each of its `CAP_SEGMENTS + 1` rays, from the elbow
+     *  at angles 0..π, px: the walk out to the contour, less `capInset`, at
+     *  most `capRadius`. */
+    capRays: number[];
+    /** The seam row's widest run, crop columns [start, end). */
+    seamRun: [number, number];
     /** +1 for a shoulder right of the body's axis (+ turns CCW), −1 left of it
      *  (+ turns CW). */
     side: 1 | -1;
@@ -910,7 +928,12 @@ interface ArmGeometry {
  *   run centre of the row it lands in;
  * - the elbow is the centre of the row `ELBOW_AT` of the way from there to
  *   the last painted row, at its run centre;
- * - the cap radius is half the elbow's run + 1 px, kept inside the crop.
+ * - the cap radius is half the elbow's run + 1 px, kept inside the crop;
+ * - each cap ray walks 1 px at a time from the elbow until it leaves the
+ *   widest run of the crop row it is in (strictly inside: `start < x < end`,
+ *   on canvas columns, the row the floor of the canvas y), then stops
+ *   `capInset(i)` short of that exit (none on the two seam-end rays, 2 px on
+ *   the next, `CAP_INSET` on the rest), and at `capRadius`.
  * Pivots are on the 0.01 grid, as the written model is. `bodyAxisX` is the
  * body's axis, model x: the shoulder's side of it sets the sign. An arm too
  * short for its width to put the elbow under the shoulder would rig
@@ -938,8 +961,8 @@ declare function parseLayerRoles(fileNames: string[]): {
  * (`body.ts`) that breathes, follows the head's turn and tilt a little and
  * turns on BodyAngleX/Y/Z, its legs planted; a head deformer hung from it
  * that rolls about the chin and breathes; each arm hung from it too, as an
- * upper arm and a forearm turning about the shoulder and the elbow
- * (`arms.ts`); one small warp grid per feature
+ * upper arm, a forearm and an elbow cap turning about the shoulder and the
+ * elbow (`arms.ts`); one small warp grid per feature
  * (each eye, each brow, the nose, the mouth), translating and foreshortening
  * it by its own lead over the plate; and the plate, the hair and the blush
  * moved by per-vertex keyforms of their own — the plate as up to four

package/dist/index.js

@@ -2754,7 +2754,11 @@ function headOwnBreath(hasBody) {
 var ELBOW_AT = 0.42;
 var CAP_ROWS = [0.1, 0.3];
 var CAP_SEGMENTS = 12;
-var ARM_RANGE = [-30, 150];
+var CAP_INSET = 3;
+var capInset = (i) => Math.round(CAP_INSET * Math.min(1, Math.min(i, CAP_SEGMENTS - i) / 2));
+var CAP_RIM = 0.25;
+var ARM_RANGE = [-8, 32];
+var ELBOW_RANGE = [-10, 90];
 var ARM_PARAMS = {
   arm_L: { arm: import_format5.StandardParameter.ArmLeft, elbow: import_format5.StandardParameter.ElbowLeft },
   arm_R: { arm: import_format5.StandardParameter.ArmRight, elbow: import_format5.StandardParameter.ElbowRight }
@@ -2762,11 +2766,13 @@ var ARM_PARAMS = {
 var ARM_IDS = {
   arm_L: {
     forearm: "forearm_L",
+    cap: "elbow_L",
     armDeformer: "armDeformer_L",
     forearmDeformer: "forearmDeformer_L"
   },
   arm_R: {
     forearm: "forearm_R",
+    cap: "elbow_R",
     armDeformer: "armDeformer_R",
     forearmDeformer: "forearmDeformer_R"
   }
@@ -2819,11 +2825,30 @@ function armGeometry(layer, bodyAxisX) {
     b.x1 - elbow.x,
     b.y1 - elbow.y
   );
+  const inside = (x, y) => {
+    const k = Math.floor(y) - bbox.y;
+    if (k < 0 || k >= bbox.h) return false;
+    const [rs, re] = span(k);
+    return rs < x && x < re;
+  };
+  const capRays = Array.from({ length: CAP_SEGMENTS + 1 }, (_, i) => {
+    const a = Math.PI * i / CAP_SEGMENTS;
+    let t = 1;
+    while (t <= capRadius + CAP_INSET && inside(
+      elbow.x + canvasW / 2 + t * Math.cos(a),
+      canvasH / 2 - elbow.y - t * Math.sin(a)
+    )) {
+      t++;
+    }
+    return Math.min(capRadius, Math.max(1, t - capInset(i)));
+  });
   return {
     shoulder,
     shoulderRadius: ru,
     elbow,
     capRadius,
+    capRays,
+    seamRun: [s - bbox.x, e - bbox.x],
     side: shoulder.x > bodyAxisX ? 1 : -1
   };
 }
@@ -2838,69 +2863,101 @@ function armParts(role, layer, g, order) {
   const lx = (x) => roundTo((x - cx(b)) / bw(b), 1e-5);
   const ly = (y) => roundTo((y - cy(b)) / bh(b), 1e-5);
   const seam = ly(g.elbow.y);
-  const band = (top, bottom) => [
+  const band = (top2, bottom) => [
     -0.5,
-    top,
+    top2,
     0.5,
-    top,
+    top2,
     -0.5,
     bottom,
     0.5,
     bottom
   ];
   const quad = [2, 3, 0, 0, 3, 1];
-  const cap = [lx(g.elbow.x), seam];
+  const rays = g.capRays.length;
+  const top = (rays - 1) / 2;
+  const at = (i, r) => {
+    const a = Math.PI * i / (rays - 1);
+    return [lx(g.elbow.x + r * Math.cos(a)), ly(g.elbow.y + r * Math.sin(a))];
+  };
+  const width = (i) => Math.min(CAP_RIM * g.capRadius, g.capRays[i] / 2);
+  const ringRays = Array.from({ length: rays }, (_, i) => i);
+  ringRays.splice(top, 0, top);
+  const vertices = [lx(g.elbow.x), seam];
+  for (let i = 0; i < rays; i++) {
+    vertices.push(...at(i, g.capRays[i] - width(i)));
+  }
+  const ringInner = vertices.length / 2;
+  for (const i of ringRays) vertices.push(...at(i, g.capRays[i] - width(i)));
+  const ringOuter = vertices.length / 2;
+  for (const i of ringRays) vertices.push(...at(i, g.capRays[i]));
+  const { uvs } = meshOf(vertices, []);
+  const col = (c) => roundTo(Math.min(Math.max(c + 0.5, 0.5), bw(b) - 0.5) / bw(b), 1e-5);
+  const v = roundTo(0.5 - seam, 1e-5);
+  ringRays.forEach((i, j) => {
+    const right = j <= top;
+    const outer = right ? g.seamRun[1] : g.seamRun[0] - 1;
+    const step = right ? -width(i) : width(i);
+    uvs[(ringInner + j) * 2] = col(outer + step);
+    uvs[(ringInner + j) * 2 + 1] = v;
+    uvs[(ringOuter + j) * 2] = col(outer);
+    uvs[(ringOuter + j) * 2 + 1] = v;
+  });
   const fan = [];
-  for (let i = 0; i <= CAP_SEGMENTS; i++) {
-    const a = Math.PI * i / CAP_SEGMENTS;
-    cap.push(
-      lx(g.elbow.x + g.capRadius * Math.cos(a)),
-      ly(g.elbow.y + g.capRadius * Math.sin(a))
-    );
-    if (i > 0) fan.push(4, 4 + i, 5 + i);
-  }
-  const part = (id, deformer, at, mesh) => ({
+  for (let i = 0; i < rays - 1; i++) fan.push(0, 1 + i, 2 + i);
+  const ring = [];
+  for (let j = 0; j < ringRays.length - 1; j++) {
+    if (j === top) continue;
+    const [p, q] = [ringInner + j, ringOuter + j];
+    ring.push(p, q, q + 1, p, q + 1, p + 1);
+  }
+  const part = (id, deformer, z, mesh) => ({
     id,
     color: [1, 1, 1, 1],
     width: bw(b),
     height: bh(b),
     transform: { x: cx(b), y: cy(b) },
-    order: at,
+    order: z,
     deformer,
     mesh
   });
   const ids = ARM_IDS[role];
   return [
-    part(role, ids.armDeformer, order, meshOf(band(0.5, seam), quad)),
+    part(ids.cap, ids.forearmDeformer, order, {
+      vertices,
+      uvs,
+      indices: [...fan, ...ring]
+    }),
+    part(role, ids.armDeformer, order + 1, meshOf(band(0.5, seam), quad)),
     part(
       ids.forearm,
       ids.forearmDeformer,
-      order + 1,
-      meshOf([...band(seam, -0.5), ...cap], [...quad, ...fan])
+      order + 2,
+      meshOf(band(seam, -0.5), quad)
     )
   ];
 }
 function armDeformers(role, g) {
   const ids = ARM_IDS[role];
   const params = ARM_PARAMS[role];
-  const rotate = (parameter) => ({
+  const rotate = (parameter, range, sign) => ({
     parameter,
     channel: "rotate",
-    from: g.side * ARM_RANGE[0],
-    to: g.side * ARM_RANGE[1]
+    from: sign * range[0],
+    to: sign * range[1]
   });
   return [
     {
       id: ids.armDeformer,
       parent: BODY_WARP_ID,
       pivot: { ...g.shoulder },
-      bindings: [rotate(params.arm)]
+      bindings: [rotate(params.arm, ARM_RANGE, g.side)]
     },
     {
       id: ids.forearmDeformer,
       parent: ids.armDeformer,
       pivot: { ...g.elbow },
-      bindings: [rotate(params.elbow)]
+      bindings: [rotate(params.elbow, ELBOW_RANGE, -g.side)]
     }
   ];
 }
@@ -2909,8 +2966,8 @@ function armDeformers(role, g) {
 var ROLE_TABLE = [
   { role: "hair_back", family: "hair_back" },
   { role: "body", family: "body" },
-  { role: "arm_L", family: "arm", parts: ["arm_L", "forearm_L"] },
-  { role: "arm_R", family: "arm", parts: ["arm_R", "forearm_R"] },
+  { 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: "face", family: "face", required: true },
   { role: "blush_L", family: "face" },
   { role: "blush_R", family: "face" },
@@ -5723,13 +5780,14 @@ function declareParameters(roles) {
     add(import_format8.StandardParameter.BodyAngleZ, "Body Angle Z", -10, 10, 0);
   }
   const [armMin, armMax] = ARM_RANGE;
+  const [elbowMin, elbowMax] = ELBOW_RANGE;
   if (roles.has("arm_L")) {
     add(import_format8.StandardParameter.ArmLeft, "Arm L", armMin, armMax, 0);
-    add(import_format8.StandardParameter.ElbowLeft, "Elbow L", armMin, armMax, 0);
+    add(import_format8.StandardParameter.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
   }
   if (roles.has("arm_R")) {
     add(import_format8.StandardParameter.ArmRight, "Arm R", armMin, armMax, 0);
-    add(import_format8.StandardParameter.ElbowRight, "Elbow R", armMin, armMax, 0);
+    add(import_format8.StandardParameter.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
   }
   add(import_format8.StandardParameter.EyeOpenLeft, "Eye L", 0, 1, 1);
   add(import_format8.StandardParameter.EyeOpenRight, "Eye R", 0, 1, 1);