@ikijs/editor 0.33.0 → 0.34.0

package/dist/index.mjs

@@ -1971,7 +1971,7 @@ var PROFILE_VALUES = {
   noseDepth: 2,
   hairFollow: 1,
   fore: 0.2,
-  backShare: 0.1,
+  backShare: 0.3,
   earFar: 0,
   earFore: 0.1,
   nodDown: 0.18,
@@ -2023,7 +2023,8 @@ function deriveProfile(v) {
      *  takes it only down to its root, `hairSideField`) rides the face at this
      *  share of its translation. */
     hairFollow: v.hairFollow,
-    /** The head's outline at the eye row holds: where the front hair draws
+    /** The head's outline at the eye row turns only as the back hair does
+     *  (`hairBack`, which this share never undercuts): where the front hair draws
      *  it, its outer edge follows the face this much on a row where no back
      *  hair paints behind that edge. Where back hair does, the edge rides
      *  further, as far as that back hair stays behind it through the turn and
@@ -2032,8 +2033,8 @@ function deriveProfile(v) {
      *  rows above the eyes) it follows less where the turn would otherwise
      *  carry it further outside its back hair than the nod alone does. */
     outlineFollow: 0,
-    /** The back hair's slight counter-motion. */
-    hairBack: -v.backShare * v.slide,
+    /** The back hair turns with the head, a share of the plate's slide. */
+    hairBack: v.backShare * v.slide,
     /** The ears lag the plate: the far one's outer edge moves this share of
      *  its slide; the near one rides the head. */
     earFar: v.earFar,
@@ -3375,6 +3376,19 @@ function spin(x, y, ox, oy, a) {
   ];
 }
 function faceField(m) {
+  const plate = plateField(m);
+  const floor = foreheadFloor(m);
+  let hold;
+  return (x, y, ax, ay) => {
+    const d = plate(x, y, ax, ay);
+    if (ax === 0 || y <= floor) return d;
+    if (hold === void 0) hold = foreheadHold(m, floor) ?? null;
+    if (hold === null) return d;
+    const s = Math.sign(ax);
+    return [d[0] - s * Math.abs(ax) * hold(x, y, s) / 30, d[1]];
+  };
+}
+function plateField(m) {
   const f = m.frame;
   return (x, y, ax, ay) => {
     const s = Math.sign(ax);
@@ -3394,6 +3408,77 @@ function faceField(m) {
     return [dx, nodDy(v, ay, f.hh)];
   };
 }
+function faceCellPx(frame) {
+  return Math.min(FACE_CELL_PX, 2 * frame.wMax / 14);
+}
+var FACE_CELL_PX = 28;
+var FOREHEAD_FADE = 0.04;
+function foreheadFloor(m) {
+  const f = m.frame;
+  const eyes = [m.boxes.eye_L, m.boxes.eye_R].filter(
+    (e) => e !== void 0
+  );
+  const eyeTop = eyes.length > 0 ? Math.max(...eyes.map((e) => e.y1)) : f.eyeY;
+  return Math.max(eyeTop, f.ears === void 0 ? -Infinity : f.ears.top + 2);
+}
+function foreheadHold(m, floor) {
+  const f = m.frame;
+  const top = f.face.y1;
+  const count = Math.floor(top - floor);
+  if (count <= 0 || f.faceRuns(top - 0.5) === void 0 || f.hairRuns("hair_front", top - 0.5) === void 0) {
+    return void 0;
+  }
+  const plate = plateField(m);
+  const front = hairFrontField(m);
+  const { inner } = hairFrontBends(f, m.boxes);
+  const cell = faceCellPx(f);
+  const fade = FOREHEAD_FADE * f.hh;
+  const sides = [-1, 1];
+  const hold = sides.map(() => new Float64Array(count));
+  const whole = sides.map(() => new Float64Array(count));
+  const span3 = sides.map(() => new Float64Array(count));
+  let any = false;
+  for (let i = 0; i < count; i++) {
+    const y = top - i - 0.5;
+    const faceRuns = f.faceRuns(y);
+    const hairRuns = f.hairRuns("hair_front", y);
+    sides.forEach((side, k) => {
+      const edge = outerEdge(faceRuns, f.axisX, side);
+      const hair = outerEdge(hairRuns, f.axisX, side);
+      if (edge === void 0 || hair === void 0) return;
+      const end = side * (edge - f.axisX) - cell;
+      if (end <= 0) return;
+      const cover = side * (hair - edge);
+      const room = Math.max(0, cover);
+      const goes = side * plate(edge - side * 0.5, y, 30 * side, 0)[0];
+      const held = side * front(hair - side * 0.5, y, 30 * side, 0)[0];
+      const need = clamp(1 + cover / fade, 0, 1) * Math.max(0, goes - held - room + Math.min(1, room));
+      if (need <= 0) return;
+      const over = Math.min(end, Math.max(2 * cell, end - inner, 2 * need));
+      hold[k][i] = Math.min(need, over / 2);
+      whole[k][i] = end;
+      span3[k][i] = over;
+      any = true;
+    });
+  }
+  if (!any) return void 0;
+  const reach = Math.ceil(cell);
+  return (x, y, s) => {
+    const u = s * (x - f.axisX);
+    if (s === 0 || u <= 0 || y <= floor) return 0;
+    const k = s < 0 ? 0 : 1;
+    const i = clamp(Math.floor(top - y), 0, count - 1);
+    let h = 0;
+    const j1 = Math.min(count - 1, i + 3 * reach);
+    for (let j = Math.max(0, i - 3 * reach); j <= j1; j++) {
+      if (hold[k][j] === 0) continue;
+      const near = clamp((3 * reach - Math.abs(i - j)) / (2 * reach), 0, 1);
+      const across = clamp((u - (whole[k][j] - span3[k][j])) / span3[k][j], 0, 1);
+      h = Math.max(h, hold[k][j] * near * across);
+    }
+    return h * clamp((y - floor) / (2 * cell), 0, 1);
+  };
+}
 function earField(m) {
   const f = m.frame;
   const ears = f.ears;
@@ -3596,7 +3681,7 @@ function hairFrontField(m) {
     )
   );
   const followOf = (x, y, s) => followAt(x, y, s) + (ride === void 0 ? 0 : ride.lift(x, y, s));
-  const drift = Math.abs(m.hairBack);
+  const drift = -m.hairBack;
   const boundOf = (x, y, s) => {
     if (ride === void 0) return followOf(x, y, s);
     const b = ride.blend(x, y, s);
@@ -3763,7 +3848,7 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
   if (f.hairRuns("hair_front", top) === void 0 || f.hairRuns("hair_back", top) === void 0) {
     return void 0;
   }
-  const drift = Math.abs(m.hairBack);
+  const drift = -m.hairBack;
   const sides = [-1, 1];
   const n = ys.length;
   const count = Math.round(top - ys[n - 1]);
@@ -3894,6 +3979,7 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
   const cuts = new Float64Array(n * 2 * nc);
   const blend = new Float64Array(n * 2 * nc);
   const motion = new Array(n * 2);
+  const held = new Array(n * 2);
   const outward = sides.map((side) => {
     const cols = xs.map((_, c) => c).filter((c) => side * (xs[c] - f.axisX) >= 0);
     return side < 0 ? cols.reverse() : cols;
@@ -3950,22 +4036,24 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
         }
       }
       motion[r * 2 + j] = after.map((v) => v + drift);
+      held[r * 2 + j] = today.map((v) => v + drift);
       for (let c = 0; c < nc; c++)
         cuts[(r * 2 + j) * nc + c] = after[c] - today[c];
     });
   }
+  const at = (r, j, c) => (r * 2 + j) * nc + c;
+  let zero = last + 1;
+  while (zero < n && ys[zero] > eyeTop) zero++;
+  while (zero > last + 1 && zero < n && ys[zero] < irisTop - 0.5) zero--;
+  const endY = zero < n ? ys[zero] : Math.min(Math.max(eyeTop, irisTop - 0.5), ys[n - 1] - 1);
   for (let r = 0; r < n; r++) {
     sides.forEach((s, j) => {
       motion[r * 2 + j] ??= xs.map(
         (x) => followAt(x, ys[r], s) + liftAt(x, ys[r], s) + drift
       );
+      held[r * 2 + j] ??= motion[r * 2 + j];
     });
   }
-  const at = (r, j, c) => (r * 2 + j) * nc + c;
-  let zero = last + 1;
-  while (zero < n && ys[zero] > eyeTop) zero++;
-  while (zero > last + 1 && zero < n && ys[zero] < irisTop - 0.5) zero--;
-  const endY = zero < n ? ys[zero] : Math.min(Math.max(eyeTop, irisTop - 0.5), ys[n - 1] - 1);
   for (let pass = 0; pass < 8; pass++) {
     const was = blend.slice();
     for (let j = 0; j < 2; j++) {
@@ -3983,11 +4071,15 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
         for (let q = 0; q < r && q <= last; q++) {
           if (wr[q] < 1) continue;
           const k = (ys[r] - endY) / (ys[q] - endY);
-          for (let c = 0; c < nc; c++)
-            blend[at(r, j, c)] = Math.max(
-              blend[at(r, j, c)],
-              blend[at(q, j, c)] * k
-            );
+          const [mq, hq] = [motion[q * 2 + j], held[q * 2 + j]];
+          const [mr, hr] = [motion[r * 2 + j], held[r * 2 + j]];
+          for (let c = 0; c < nc; c++) {
+            const bq = blend[at(q, j, c)];
+            const ease = hq[c] > 0 ? clamp(1 - (1 - bq) * mq[c] / hq[c], 0, 1) : bq;
+            const want = ease * k;
+            const br = mr[c] > 0 && hr[c] > 0 ? 1 - (1 - want) * hr[c] / mr[c] : want;
+            blend[at(r, j, c)] = Math.max(blend[at(r, j, c)], br);
+          }
         }
       }
     }
@@ -4004,7 +4096,7 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
     }
     if (blend.every((v, i) => v === was[i])) break;
   }
-  const cutRow = (r, j, x) => r > last ? 0 : along(cuts.subarray((r * 2 + j) * nc, (r * 2 + j + 1) * nc), x);
+  const cutRow = (r, j, x) => r > last ? 0 : along(cuts.subarray(at(r, j, 0), at(r, j, nc)), x);
   return {
     lift: liftAt,
     // Between vertex rows, as the render interpolates; a vertex reads its own
@@ -4488,6 +4580,7 @@ function buildTurn(frame, landmarks, q, turn) {
   const eyeHalf = eyes.reduce((sum, e) => sum + (e.x1 - e.x0) / 2, 0) / Math.max(1, eyes.length);
   const farScale = 1 + q.fore * A * (turn.eyeFarScale - 1);
   const farCorner = lead(turn.eyeFar) - (1 - farScale) * eyeHalf;
+  const shell = A * hh * turn.hairBack;
   return {
     frame,
     face,
@@ -4505,10 +4598,13 @@ function buildTurn(frame, landmarks, q, turn) {
     mouth: q.mouth ?? lead(turn.mouth),
     mouthWidth: 1 + A * (turn.mouthWidth - 1),
     tilt: A,
-    hairFront: q.follow * face,
-    hairFar: Math.max(q.follow * face, farCorner),
-    hairOuter: q.outline * face,
-    hairBack: A * hh * turn.hairBack,
+    // The front hair lies on the head in front of its shell: neither over
+    // the face nor at the outline it draws does it turn less than the back
+    // hair behind it.
+    hairFront: Math.max(q.follow * face, shell),
+    hairFar: Math.max(q.follow * face, shell, farCorner),
+    hairOuter: Math.max(q.outline * face, shell),
+    hairBack: shell,
     shellScale: q.shell,
     earFar: q.earFar,
     earFarScale: 1 + A * (turn.earFarScale - 1),
@@ -4630,7 +4726,7 @@ var RIG_PLAN_FIELDS = [
     fitBy: null,
     provisional: false,
     migratedFrom: "hairFollow",
-    what: "the front hair's share of the face's turn"
+    what: "the front hair's share of the face's turn (never less than the back hair's own turn, 0.3 of the face's: a share under that has no effect)"
   },
   {
     path: "hair.outlineFollow",
@@ -4647,7 +4743,7 @@ var RIG_PLAN_FIELDS = [
     fitBy: null,
     provisional: false,
     migratedFrom: "outlineFollow",
-    what: "the front hair's outer edge's share where it draws the head's outline (0: the outline holds, though where back hair paints behind it, it may ride further, as far as that back hair reaches; at hair.follow the front hair's side strands ride whole)"
+    what: "the front hair's outer edge's share where it draws the head's outline (never less than the back hair's own turn: at 0 the outline turns only as the back hair does, though where back hair paints behind it, it may ride further, as far as that back hair reaches; at hair.follow the front hair's side strands ride whole)"
   },
   {
     path: "hair.sway",
@@ -7338,7 +7434,7 @@ function writeOcclusion(customParts, built, parts) {
 
 // src/auto-rig/generate.ts
 var MESH_CELLS = {
-  face: { px: 28, min: 4, max: 24 },
+  face: { px: FACE_CELL_PX, min: 4, max: 24 },
   // The front hair eases from riding the face to holding the outline.
   hair_front: { px: 32, min: 3, max: 24 },
   // A side lock's rows come from `sideLockGrid`: even ones, plus the root
@@ -7646,7 +7742,7 @@ function buildPart(spec, b, order, frame, byRole, plan, frontGrid, lips) {
   let region;
   let headStart = 0;
   if (spec.role === "face") {
-    const px = Math.min(MESH_CELLS.face.px, 2 * frame.wMax / 14);
+    const px = faceCellPx(frame);
     const fm = buildFaceMesh(frame, b, { ...MESH_CELLS.face, px }, NECK_CELLS);
     mesh = fm.mesh;
     region = fm.region;