@ikijs/editor 0.32.1 → 0.33.1

package/dist/index.mjs

@@ -2937,6 +2937,7 @@ function mouthAnchor(byRole) {
 }
 
 // src/auto-rig/head.ts
+var EAR_EDGE = 3;
 function outerEdge(runs, axisX, side) {
   if (runs.length === 0) return void 0;
   const x = side > 0 ? runs[runs.length - 1] : runs[0];
@@ -2970,7 +2971,11 @@ function findEars(raw, wMax, firstRow, lastRow, minRows, maxRows) {
     if (raw[t] - raw[t - EAR_ROWS] < step) continue;
     for (let b = t + minRows; b <= Math.min(lastRow, t + maxRows); b++) {
       if (raw[b - EAR_ROWS] - raw[b] >= step) {
-        return { top: t - EAR_ROWS, bottom: b };
+        let end = b;
+        for (let k = b + 1; k <= Math.min(lastRow, b + minRows); k++) {
+          if (raw[k - EAR_ROWS] - raw[k] >= step) end = k;
+        }
+        return { top: t - EAR_ROWS, bottom: end };
       }
     }
     return void 0;
@@ -3048,6 +3053,7 @@ function buildHeadFrame(layers, opts) {
       return rows[i] + (rows[j] - rows[i]) * clamp(r - i, 0, 1);
     };
     const rawRows = raw;
+    let earRows;
     const earless = (chin) => {
       const rowOf = (y) => Math.round(canvasH / 2 - y - faceLayer.bbox.y - 0.5);
       const span3 = Math.max(1, eyeY - chin);
@@ -3070,8 +3076,10 @@ function buildHeadFrame(layers, opts) {
         top: rowY(top) + 0.5,
         bottom: rowY(bottom) - 0.5,
         attachAt: (y) => attach(clamp(canvasH / 2 - y - faceLayer.bbox.y - 0.5, top, bottom)),
-        outer
+        outer,
+        edgeAt: (y) => attach(clamp(canvasH / 2 - y - faceLayer.bbox.y - 0.5, top, bottom)) + EAR_EDGE
       };
+      earRows = { top, bottom };
       return smoothProfile(
         rawRows.map((v, r) => r > top && r < bottom ? attach(r) : v)
       );
@@ -3193,9 +3201,13 @@ function buildHeadFrame(layers, opts) {
       headHalfAt = readRows(head);
       headMax = Math.max(...head);
       if (ears !== void 0) {
+        const band = earRows;
+        const edge = head.map(
+          (w, r) => r >= band.top && r <= band.bottom ? w + EAR_EDGE : w
+        );
         const bottomOf = (d) => {
-          for (let r = head.length - 1; r >= 0; r--) {
-            if (head[r] >= d) return rowY(r) - 0.5;
+          for (let r = edge.length - 1; r >= 0; r--) {
+            if (edge[r] >= d) return rowY(r) - 0.5;
           }
           return face.y1;
         };
@@ -3363,6 +3375,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);
@@ -3382,6 +3407,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;
@@ -3395,7 +3491,7 @@ function earField(m) {
     const attach = ears.attachAt(y);
     const span3 = Math.max(1, ears.outer - attach);
     if (sideOf(m, x, s) === "far") {
-      const rim2 = TURN.earFar * m.face;
+      const rim2 = m.earFar * m.face;
       const root2 = earRoot(m, face, y, s);
       const lead = Math.max(
         0,
@@ -3420,7 +3516,7 @@ function farEarCovered(m) {
   const ears = m.frame.ears;
   if (ears === void 0) return true;
   const face = faceField(m);
-  const rim = TURN.earFar * m.face;
+  const rim = m.earFar * m.face;
   const y0 = ears.bottom - 2;
   const y1 = ears.top + 2;
   const n = Math.max(1, Math.ceil(y1 - y0));
@@ -4261,6 +4357,7 @@ function fitTurn(ctx, targets, plan, build) {
     lead: plan.turn.featureLead,
     follow: plan.hair.follow,
     outline: plan.hair.outlineFollow,
+    earFar: plan.turn.farEar,
     fore: targets.farEyeRatio === void 0 ? plan.turn.eyeForeshorten : 1,
     shell: 1,
     noseLead: targets.noseShift !== void 0 || plan.turn.noseLead === 1 ? void 0 : plan.turn.noseLead
@@ -4497,6 +4594,7 @@ function buildTurn(frame, landmarks, q, turn) {
     hairOuter: q.outline * face,
     hairBack: A * hh * turn.hairBack,
     shellScale: q.shell,
+    earFar: q.earFar,
     earFarScale: 1 + A * (turn.earFarScale - 1),
     ...landmarks
   };
@@ -4584,6 +4682,23 @@ var RIG_PLAN_FIELDS = [
     migratedFrom: null,
     what: "how far the nose leads the face plate on the turn \u2014 turn only, the nod keeps the profile's nose depth"
   },
+  {
+    path: "turn.farEar",
+    group: "turn",
+    key: "farEar",
+    kind: "absolute",
+    unit: "share of the face plate's slide",
+    default: PROFILE.TURN.earFar,
+    range: [0, 1],
+    recommended: [0, 0.5],
+    step: 0.1,
+    poses: TURN_POSES,
+    cue: null,
+    fitBy: null,
+    provisional: false,
+    migratedFrom: null,
+    what: "how far the far ear's outer edge follows the face on the turn (0: it holds and the head slides over it, about half of a default-sized ear going under the face; 1: it rides with the face and stays whole)"
+  },
   {
     path: "hair.follow",
     group: "hair",
@@ -6682,6 +6797,11 @@ function buildFaceMesh(frame, b, head, neckCells) {
       frame.axisX - frame.headMax + 0.5,
       frame.axisX + frame.headMax - 0.5
     ];
+    const ears2 = frame.ears;
+    if (ears2 !== void 0 && neck2 === void 0) {
+      const d = ears2.edgeAt(ears2.bottom);
+      at.push(frame.axisX - d, frame.axisX + d);
+    }
     if (neck2 !== void 0) {
       at.push(
         frame.axisX,
@@ -7302,7 +7422,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
@@ -7610,7 +7730,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;