@ikijs/editor 0.8.0 → 0.9.0

package/dist/index.mjs

@@ -1420,6 +1420,242 @@ function detectAlphaBbox(rgba, width, height) {
   return { x, y, w: x2 - x + 1, h: y2 - y + 1 };
 }
 
+// src/layer-measure.ts
+var HEAD_BAND = 10;
+var ALPHA_OPAQUE = 128;
+function denseCoreOf(rgba, width, height) {
+  let minX = width;
+  let minY = height;
+  let maxX = -1;
+  let maxY = -1;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      if (rgba[(y * width + x) * 4 + 3] >= ALPHA_OPAQUE) {
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+    }
+  }
+  if (maxX < 0) return null;
+  return { x: minX, y: minY, w: maxX - minX + 1, h: maxY - minY + 1 };
+}
+var SPECK_CORE_FRACTION = 0.25;
+function isSpeckCore(core, part) {
+  return core.w < SPECK_CORE_FRACTION * part.w || core.h < SPECK_CORE_FRACTION * part.h;
+}
+function foregroundSpan(mask, width, height, rowLo, rowHi) {
+  let left = width;
+  let right = -1;
+  for (let y = Math.max(0, rowLo); y <= Math.min(height - 1, rowHi); y++) {
+    for (let x = 0; x < width; x++) {
+      if (!mask[y * width + x]) continue;
+      if (x < left) left = x;
+      if (x > right) right = x;
+    }
+  }
+  return { left, right };
+}
+function headHalfOf(span) {
+  return (span.right - span.left + 1) / 2;
+}
+function eyeBandRowOf(layers) {
+  const centreY = (role) => {
+    const layer = layers.find((l) => l.role === role);
+    return layer && layer.bbox.y + layer.bbox.h / 2;
+  };
+  const pairRow = (left, right) => {
+    const a = centreY(left);
+    const b = centreY(right);
+    return a === void 0 || b === void 0 ? void 0 : (a + b) / 2;
+  };
+  const row = pairRow("iris_L", "iris_R") ?? pairRow("eye_L", "eye_R");
+  if (row === void 0) {
+    throw new Error("auto-rig: no eye pair to measure the head width at");
+  }
+  return Math.round(row);
+}
+function foregroundSpanOfRows(rowLeft, rowRight, rowLo, rowHi) {
+  let left = Infinity;
+  let right = -Infinity;
+  for (let y = Math.max(0, rowLo); y <= Math.min(rowLeft.length - 1, rowHi); y++) {
+    if (rowLeft[y] < left) left = rowLeft[y];
+    if (rowRight[y] > right) right = rowRight[y];
+  }
+  return { left, right };
+}
+function facePlateHalfOf(layers) {
+  const face = layers.find((l) => l.role === "face");
+  if (face === void 0) {
+    throw new Error("auto-rig: no face layer to measure the plate against");
+  }
+  return face.cropW / 2;
+}
+var STRAND_MIN_RUN_FRACTION = 0.5;
+function createLayerSetMeasurer(canvas) {
+  for (const field of ["width", "height"]) {
+    const value = canvas[field];
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new Error(
+        `auto-rig: createLayerSetMeasurer: canvas.${field} must be a positive safe integer, got ${value}`
+      );
+    }
+  }
+  const { width: canvasW, height: canvasH } = canvas;
+  const rgbaLength = canvasW * canvasH * 4;
+  if (!Number.isSafeInteger(rgbaLength)) {
+    throw new Error(
+      `auto-rig: createLayerSetMeasurer: canvas ${canvasW}x${canvasH} is too large: width \xD7 height \xD7 4 = ${rgbaLength} is not a safe integer`
+    );
+  }
+  const opaque = new Uint8Array(canvasW * canvasH);
+  const layerInputs = [];
+  const rowSpansByRole = [];
+  let hairFrontMask;
+  function add({ role, fileName, rgba }) {
+    if (rgba.length !== rgbaLength) {
+      throw new Error(
+        `auto-rig: layer "${fileName}": rgba length ${rgba.length} is not ${canvasW}x${canvasH}x4 = ${rgbaLength}`
+      );
+    }
+    const bbox = detectAlphaBbox(rgba, canvasW, canvasH);
+    if (bbox === null) return null;
+    const rowLeft = new Int32Array(canvasH).fill(canvasW);
+    const rowRight = new Int32Array(canvasH).fill(-1);
+    const ownMask = role === "hair_front" ? new Uint8Array(canvasW * canvasH) : void 0;
+    for (let y = 0; y < canvasH; y++) {
+      for (let x = 0; x < canvasW; x++) {
+        const p = y * canvasW + x;
+        if (rgba[p * 4 + 3] < ALPHA_OPAQUE) continue;
+        opaque[p] = 1;
+        if (ownMask !== void 0) ownMask[p] = 1;
+        if (x < rowLeft[y]) rowLeft[y] = x;
+        if (x > rowRight[y]) rowRight[y] = x;
+      }
+    }
+    rowSpansByRole.push({ role, rowLeft, rowRight });
+    if (ownMask !== void 0) hairFrontMask = ownMask;
+    const layer = {
+      role,
+      fileName,
+      canvasW,
+      canvasH,
+      bbox,
+      cropW: bbox.w,
+      cropH: bbox.h
+    };
+    if (role === "face") {
+      const rowHalfWidths = [];
+      for (let y = bbox.y; y < bbox.y + bbox.h; y++) {
+        rowHalfWidths.push(
+          rowRight[y] >= rowLeft[y] ? headHalfOf({ left: rowLeft[y], right: rowRight[y] }) : 0
+        );
+      }
+      layer.rowHalfWidths = rowHalfWidths;
+    } else if (role === "nose") {
+      const core = denseCoreOf(rgba, canvasW, canvasH);
+      if (core !== null && !isSpeckCore(core, bbox)) layer.denseCore = core;
+    }
+    layerInputs.push(layer);
+    return layer;
+  }
+  function finish() {
+    const eyeRow = eyeBandRowOf(layerInputs);
+    const span = foregroundSpan(
+      opaque,
+      canvasW,
+      canvasH,
+      eyeRow - HEAD_BAND,
+      eyeRow + HEAD_BAND
+    );
+    const headHalfWidth = span.right > span.left ? headHalfOf(span) : void 0;
+    const headHalfWidthApplied = headHalfWidth !== void 0 && headHalfWidth > facePlateHalfOf(layerInputs);
+    let headEdges;
+    if (headHalfWidthApplied) {
+      const bandLo = eyeRow - HEAD_BAND;
+      const bandHi = eyeRow + HEAD_BAND;
+      const left = [];
+      const right = [];
+      for (const { role, rowLeft, rowRight } of rowSpansByRole) {
+        const own = foregroundSpanOfRows(rowLeft, rowRight, bandLo, bandHi);
+        if (own.right <= own.left) continue;
+        left.push({ role, x: own.left - canvasW / 2 });
+        right.push({ role, x: own.right - canvasW / 2 });
+      }
+      headEdges = { left, right };
+    }
+    let strandEdges;
+    const irisLayers = layerInputs.filter((l) => l.role === "iris_L" || l.role === "iris_R").sort((a, b) => a.bbox.x + a.bbox.w / 2 - (b.bbox.x + b.bbox.w / 2));
+    if (hairFrontMask !== void 0 && irisLayers.length === 2) {
+      const mask = hairFrontMask;
+      const half = canvasW / 2;
+      const strandOn = (iris, other, side) => {
+        const r = Math.floor(iris.bbox.y + iris.bbox.h / 2);
+        const centre = iris.bbox.x + iris.bbox.w / 2;
+        const otherX = other.bbox.x + other.bbox.w / 2 - half;
+        const c = side < 0 ? Math.ceil(centre) - 1 : Math.floor(centre);
+        const span2 = rowSpansByRole.find((s) => s.role === iris.role);
+        if (span2.rowRight[r] < span2.rowLeft[r]) return void 0;
+        const minRun = STRAND_MIN_RUN_FRACTION * (span2.rowRight[r] + 1 - span2.rowLeft[r]);
+        const strand = new Uint8Array(canvasW);
+        for (let a = 0; a < canvasW; ) {
+          if (mask[r * canvasW + a] !== 1) {
+            a++;
+            continue;
+          }
+          let b = a;
+          while (b < canvasW && mask[r * canvasW + b] === 1) b++;
+          if (b - a >= minRun) strand.fill(1, a, b);
+          a = b;
+        }
+        const strandAt = (x2) => x2 >= 0 && x2 < canvasW && strand[x2] === 1;
+        const outerBoundary = (x2) => (side < 0 ? x2 : x2 + 1) - half;
+        let x = c;
+        let runFace;
+        if (!strandAt(c)) {
+          while (x >= 0 && x < canvasW && !strandAt(x)) x += side;
+          if (x < 0 || x >= canvasW) return void 0;
+          runFace = outerBoundary(x - side);
+        } else {
+          let f = c - side;
+          while (strandAt(f)) f -= side;
+          const face = outerBoundary(f);
+          runFace = side * (face - otherX) > 0 ? face : null;
+        }
+        while (strandAt(x)) x += side;
+        return {
+          y: canvasH / 2 - (r + 0.5),
+          irisOuter: (side < 0 ? span2.rowLeft[r] : span2.rowRight[r] + 1) - half,
+          irisInner: (side < 0 ? span2.rowRight[r] + 1 : span2.rowLeft[r]) - half,
+          runOuter: outerBoundary(x - side),
+          runFace
+        };
+      };
+      const [low, high] = irisLayers;
+      const left = strandOn(low, high, -1);
+      const right = strandOn(high, low, 1);
+      if (left !== void 0 || right !== void 0) {
+        strandEdges = {
+          ...left === void 0 ? {} : { left },
+          ...right === void 0 ? {} : { right }
+        };
+      }
+    }
+    return {
+      layers: layerInputs,
+      ...headHalfWidth === void 0 ? {} : { headHalfWidth },
+      headHalfWidthApplied,
+      turnOptions: {
+        ...headHalfWidthApplied ? { turnTargets: { headHalfWidth } } : {},
+        ...headEdges === void 0 ? {} : { headEdges },
+        ...strandEdges === void 0 ? {} : { strandEdges }
+      }
+    };
+  }
+  return { add, finish };
+}
+
 // src/binding-capture.ts
 function captureBindingEndpoint(channel, restValue, posedValue) {
   if (channel === "opacity") {
@@ -1991,6 +2227,7 @@ function meshCellsFor(w, h) {
 }
 var FACE_PLATE_CELLS = 10;
 var FEATURE_GRID_CELLS = 4;
+var MOUTH_GRID_CELL_PX = 32;
 var TURN_LATTICE_CELL_PX = 16;
 var GRID_MARGIN = 0.12;
 var HEAD_CYLINDER_RADIUS_FACTOR = 0.6 / 0.5;
@@ -2141,31 +2378,33 @@ function turnColumnMap(grid, faceCenterX, radiusX, angleX, travel) {
       x + boundedCylinderBend(x - faceCenterX, radiusX, theta) + slide
     );
   }
-  const cellFor = (v, edges) => {
+  const cellFor = (x) => {
     let lo = 0;
     let hi = grid.cols - 1;
     while (lo < hi) {
       const mid = lo + hi >> 1;
-      if (v < edges[mid + 1]) hi = mid;
+      if (x < restX[mid + 1]) hi = mid;
       else lo = mid + 1;
     }
     return lo;
   };
-  const sample = (edges, values, v) => {
-    const c = cellFor(v, edges);
-    const s = Math.max(
-      0,
-      Math.min(1, (v - edges[c]) / (edges[c + 1] - edges[c]))
-    );
-    if (s === 0) return values[c];
-    if (s === 1) return values[c + 1];
-    return values[c] + (values[c + 1] - values[c]) * s;
-  };
   return {
     restX,
     warpedX,
-    mapX: (x) => sample(restX, warpedX, x),
-    invertX: (X) => sample(warpedX, restX, X)
+    // Piecewise-linear read of `warpedX` over `restX`, the within-cell
+    // fraction clamped to [0,1] as sampleWarpGrid clamps (s, t). A node reads
+    // its own warped x: `warpedX[c] + Δ·1` is `warpedX[c + 1]` only to an
+    // ulp, and the columns a bake reads are nodes.
+    mapX: (x) => {
+      const c = cellFor(x);
+      const s = Math.max(
+        0,
+        Math.min(1, (x - restX[c]) / (restX[c + 1] - restX[c]))
+      );
+      if (s === 0) return warpedX[c];
+      if (s === 1) return warpedX[c + 1];
+      return warpedX[c] + (warpedX[c + 1] - warpedX[c]) * s;
+    }
   };
 }
 function renderedLandingX(part, vertexLanding, px, py) {
@@ -2271,7 +2510,7 @@ function plateLandingOn(plate, mapAt) {
     y
   );
 }
-function plateGuardRowsFor(face, hairFront) {
+function plateGuardRowsFor(face, hairFront, widestY = -Infinity) {
   const rowsOf = (part, y) => {
     const { rows } = meshCellsFor(part.cropW, part.cropH);
     return Array.from(
@@ -2286,7 +2525,7 @@ function plateGuardRowsFor(face, hairFront) {
   return [
     ...faceRows,
     ...rowsOf(hairFront, hairFront.centerY).map(
-      (y) => Math.max(bottom, Math.min(top, y))
+      (y) => Math.max(bottom, Math.min(top, Math.max(y, widestY)))
     )
   ];
 }
@@ -2298,7 +2537,7 @@ function plateGuardsOf(carriers, faceHalfWidth, profile, hairFront) {
   return {
     plate,
     edgeAt: profile === void 0 ? () => faceHalfWidth : profile.at,
-    plateGuardRows: plateGuardRowsFor(plate.part, hairFront)
+    plateGuardRows: plateGuardRowsFor(plate.part, hairFront, profile?.widestY)
   };
 }
 var TurnTargetError = class extends Error {
@@ -2476,14 +2715,15 @@ var TURN_SWEEP_SAMPLES = 32;
 var HOLD_CLEARANCE = 1;
 var TURN_HOLD_SAMPLES = 16;
 var TURN_SETTLE_PASSES = 24;
-function hairFrontHoldTarget(x, y, deg, faceCenterX, plateLandingAt, edgeAt, holdBase, holdEdge) {
+function hairFrontHoldTarget(x, y, deg, faceCenterX, plateLandingAt, edgeAt, holdBase, holdEdge, widestY = -Infinity) {
   const local = x - faceCenterX;
   const dist = Math.abs(local);
   const side = Math.sign(local);
-  const painted = edgeAt(y);
-  if (dist <= painted) return plateLandingAt(deg, x, y);
+  const row = Math.max(y, widestY);
+  const painted = edgeAt(row);
+  if (dist <= painted) return plateLandingAt(deg, x, row);
   if (dist <= holdBase) {
-    const inner = plateLandingAt(deg, faceCenterX + side * painted, y);
+    const inner = plateLandingAt(deg, faceCenterX + side * painted, row);
     const u = (dist - painted) / (holdBase - painted);
     return inner + (faceCenterX + side * holdEdge - inner) * u;
   }
@@ -2588,7 +2828,8 @@ function evaluateTurnCandidate(ctx, radius) {
       plateLandingAt,
       ctx.edgeAt,
       hold.holdBase,
-      hold.holdEdgeAt(deg)
+      hold.holdEdgeAt(deg),
+      ctx.profile?.widestY
     ),
     leadShift
   );
@@ -3563,7 +3804,7 @@ function plateReachAt(plateLandingAt, faceCenterX, edgeAt, plateGuardRows, deg)
     )
   );
 }
-function bakeHairFrontSilhouetteWarp(mesh, partX, partY, faceCenterX, plateLandingAt, edgeAt, holdBase, holdEdgeAt, plateGuardRows) {
+function bakeHairFrontSilhouetteWarp(mesh, partX, partY, faceCenterX, plateLandingAt, edgeAt, holdBase, holdEdgeAt, plateGuardRows, widestY = -Infinity) {
   if (holdEdgeAt(0) !== holdBase) {
     throw new Error(
       `auto-rig: bakeHairFrontSilhouetteWarp: holdEdgeAt(0) is ${holdEdgeAt(0)}, not the hold edge's own rest distance ${holdBase}, so the bangs would move in the rest pose`
@@ -3601,7 +3842,8 @@ function bakeHairFrontSilhouetteWarp(mesh, partX, partY, faceCenterX, plateLandi
           plateLandingAt,
           edgeAt,
           holdBase,
-          holdEdge
+          holdEdge,
+          widestY
         ) - x,
         0
       );
@@ -3780,7 +4022,7 @@ function defaultPoseOf(bindings) {
     return binding.from + (binding.to - binding.from) * t;
   });
 }
-function groupGridFor(members, cells, turnShiftPx, nodShiftPx) {
+function groupGridFor(members, cells, turnShiftPx, nodShiftPx, cellPx) {
   let minX = Infinity;
   let maxX = -Infinity;
   let minY = Infinity;
@@ -3815,24 +4057,50 @@ function groupGridFor(members, cells, turnShiftPx, nodShiftPx) {
       }
     }
   }
+  const extentMinX = minX;
+  const extentMaxX = maxX;
   minX -= turnShiftPx;
   maxX += turnShiftPx;
   minY -= nodShiftPx;
   maxY += nodShiftPx;
   const marginX = (maxX - minX) * GRID_MARGIN + 1;
   const marginY = (maxY - minY) * GRID_MARGIN + 1;
-  return {
-    cols: cells,
-    rows: cells,
-    points: generateGridPoints(
-      cells,
-      cells,
-      minX - marginX,
-      maxX + marginX,
-      minY - marginY,
-      maxY + marginY
-    )
-  };
+  const points = generateGridPoints(
+    cells,
+    cells,
+    minX - marginX,
+    maxX + marginX,
+    minY - marginY,
+    maxY + marginY
+  );
+  if (cellPx === void 0) return { cols: cells, rows: cells, points };
+  const stride = cells + 1;
+  const uniformXs = Array.from({ length: stride }, (_, c) => points[c * 2]);
+  const ys = Array.from(
+    { length: stride },
+    (_, r) => points[r * stride * 2 + 1]
+  );
+  const xs = [uniformXs[0]];
+  for (let c = 0; c < cells; c++) {
+    const left = uniformXs[c];
+    const right = uniformXs[c + 1];
+    const from = Math.max(left, extentMinX);
+    const to = Math.min(right, extentMaxX);
+    if (right - left > cellPx && from < to) {
+      const steps = Math.ceil((to - from) / cellPx);
+      if (from > left) xs.push(from);
+      for (let k = 1; k < steps; k++) {
+        xs.push(from + k * (to - from) / steps);
+      }
+      if (to < right) xs.push(to);
+    }
+    xs.push(right);
+  }
+  const merged = [];
+  for (const y of ys) {
+    for (const x of xs) merged.push(x, y);
+  }
+  return { cols: xs.length - 1, rows: cells, points: merged };
 }
 function eyelidFoldFor(layers, layer, mesh, t) {
   const side = ROLE_TABLE[layer.role].eyeSide;
@@ -3933,7 +4201,8 @@ function turnSetup(layers) {
         own,
         isPlate ? FACE_PLATE_CELLS : FEATURE_GRID_CELLS,
         isPlate ? 0 : turnShift[turnFamily(role)],
-        nodShiftPx
+        nodShiftPx,
+        group === "mouthWarp" ? MOUTH_GRID_CELL_PX : void 0
       )
     );
   }
@@ -4273,7 +4542,8 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
               edgeAt,
               holdBase,
               turn?.holdEdgeAt ?? (() => holdBase),
-              plateGuardRows
+              plateGuardRows,
+              profile?.widestY
             )
           );
           ownWarps.push(
@@ -4362,6 +4632,7 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
 }
 export {
   ALPHA_BBOX_THRESHOLD,
+  ALPHA_OPAQUE,
   ATLAS_PADDING,
   AddDeformer,
   AddPart,
@@ -4372,6 +4643,8 @@ export {
   DeletePart,
   DeletePhysicsRig,
   EditorDocument,
+  HEAD_BAND,
+  SPECK_CORE_FRACTION,
   SetDeformerBindings,
   SetDeformerParent,
   SetDeformerPivot,
@@ -4395,9 +4668,14 @@ export {
   createDefaultPart,
   createDefaultWarpDeformer,
   createGridMesh,
+  createLayerSetMeasurer,
+  denseCoreOf,
   detectAlphaBbox,
+  foregroundSpan,
   generateIkiFromLayerSet,
+  headHalfOf,
   interpolateGridOffsets,
+  isSpeckCore,
   packAtlas,
   parseLayerRoles,
   upsertGridKeyform,