@ikijs/editor 0.11.0 → 0.12.1

package/dist/index.mjs

@@ -1569,7 +1569,7 @@ function createLayerSetMeasurer(canvas) {
     if (bbox === null) return null;
     const rowLeft = new Int32Array(canvasH).fill(canvasW);
     const rowRight = new Int32Array(canvasH).fill(-1);
-    const rowRuns = role === "hair_front" || role === "hair_back" ? [] : void 0;
+    const rowRuns = role === "face" || role === "hair_front" || role === "hair_back" ? [] : void 0;
     for (let y = 0; y < canvasH; y++) {
       let runs;
       if (rowRuns !== void 0 && y >= bbox.y && y < bbox.y + bbox.h) {
@@ -2737,12 +2737,14 @@ function buildHeadFrame(layers, opts) {
       shellRight = axisX + headHalf;
     }
   }
-  const hairRuns = (role, y) => {
+  const runsOf = (role, y) => {
     const l = byRole.get(role);
     if (l?.rowRuns === void 0) return void 0;
     const runs = l.rowRuns[Math.floor(canvasH / 2 - y) - l.bbox.y];
     return runs === void 0 ? [] : runs.map((c) => c - canvasW / 2);
   };
+  const hairRuns = (role, y) => runsOf(role, y);
+  const faceRuns = (y) => runsOf("face", y);
   return {
     canvasW,
     canvasH,
@@ -2765,7 +2767,8 @@ function buildHeadFrame(layers, opts) {
     shellRight,
     hairShell,
     holdBase: headHalf ?? plateHalf,
-    hairRuns
+    hairRuns,
+    faceRuns
   };
 }
 
@@ -2967,22 +2970,42 @@ function hairFrontField(m) {
     return core + (m.hairOuter - core) * out;
   };
   const ride = outerRide(m, inner, coreAt, followAt);
+  const followOf = (x, y, s) => followAt(x, y, s) + (ride === void 0 ? 0 : ride(x, y, s));
+  const drift = Math.abs(m.hairBack);
+  const crown = crownRide(m, cap, (x, y, s) => followOf(x, y, s) + drift);
   return (x, y, ax, ay) => {
     const s = Math.sign(ax);
     const a = Math.abs(ax) / 30;
-    const follow = followAt(x, y, s) + (ride === void 0 ? 0 : ride(x, y, s));
-    const rx = s * a * follow + a * (m.shellScale - 1) * (x - f.axisX);
+    const rx = s * a * followOf(x, y, s) + a * (m.shellScale - 1) * (x - f.axisX);
     const ry = nodDy(NOD.hairFront, ay, f.hh);
     const bx = back(x, y, ax, ay)[0];
     const by = nodDy(cap, ay, f.hh);
     const w = crownBlend(m, y);
-    return [bx + w * (rx - bx), by + w * (ry - by)];
+    const wx = crown === void 0 ? w : w + crown(y, s);
+    return [bx + wx * (rx - bx), by + w * (ry - by)];
   };
 }
 function crownBlend(m, y) {
   const top = m.frame.face.y1;
   return 1 - smoothstep(top, Math.max(top + 1, m.hairTop), y);
 }
+function gridRow(ys, y, snap = false) {
+  const n = ys.length;
+  let v = clamp((ys[0] - y) / (ys[0] - ys[n - 1]) * (n - 1), 0, n - 1);
+  if (snap && Math.abs(v - Math.round(v)) < 1e-3) v = Math.round(v);
+  const r = Math.min(n - 2, Math.floor(v));
+  return { r, t: v - r };
+}
+function renderedCrownBlend(m, ys) {
+  const wr = ys.map((y) => crownBlend(m, y));
+  return {
+    wr,
+    blendAt: (y) => {
+      const { r, t } = gridRow(ys, y);
+      return wr[r] + (wr[r + 1] - wr[r]) * t;
+    }
+  };
+}
 var CAP_COVER_LOSS = 0.01;
 function capSlide(m) {
   const f = m.frame;
@@ -2995,12 +3018,7 @@ function capSlide(m) {
   const top = ys[0];
   const n = ys.length;
   const bangs = NOD.hairFront.down;
-  const wr = ys.map((y) => crownBlend(m, y));
-  const blendAt = (y) => {
-    const v = clamp((top - y) / (top - ys[n - 1]) * (n - 1), 0, n - 1);
-    const r = Math.min(n - 2, Math.floor(v));
-    return wr[r] + (wr[r + 1] - wr[r]) * (v - r);
-  };
+  const { wr, blendAt } = renderedCrownBlend(m, ys);
   const flat = ys[wr.findIndex((w) => w >= 1)] ?? ys[n - 1];
   const x0 = xs[0];
   const tops = new Float64Array(Math.round(xs[xs.length - 1] - x0)).fill(NaN);
@@ -3129,13 +3147,157 @@ function outerRide(m, inner, coreAt, followAt) {
     if (s === 0 || d <= inner) return 0;
     const k = x < f.axisX ? 0 : 1;
     const j = s < 0 ? 0 : 1;
-    let v = clamp((top - y) / (top - ys[n - 1]) * (n - 1), 0, n - 1);
-    if (Math.abs(v - Math.round(v)) < 1e-3) v = Math.round(v);
-    const r = Math.min(n - 2, Math.floor(v));
-    const t = v - r;
+    const { r, t } = gridRow(ys, y, true);
     return rowRide(r, k, j, d) * (1 - t) + rowRide(r + 1, k, j, d) * t;
   };
 }
+function crownRide(m, cap, relAt) {
+  const f = m.frame;
+  const grid = m.hairFrontGrid;
+  if (grid === void 0) return void 0;
+  const { xs, ys } = grid;
+  const top = ys[0];
+  if (f.hairRuns("hair_front", top) === void 0 || f.hairRuns("hair_back", top) === void 0) {
+    return void 0;
+  }
+  const n = ys.length;
+  const count = Math.round(top - ys[n - 1]);
+  const hh = f.hh;
+  const face = faceField(m);
+  const { wr, blendAt } = renderedCrownBlend(m, ys);
+  const backRows = /* @__PURE__ */ new Map();
+  const backAt = (j) => {
+    let runs = backRows.get(j);
+    if (runs === void 0) {
+      runs = f.hairRuns("hair_back", top - j - 0.5);
+      backRows.set(j, runs);
+    }
+    return runs;
+  };
+  const faceAt = (j) => {
+    const y = top - j - 0.5;
+    return f.faceRuns(y) ?? (y > f.face.y0 && y < f.face.y1 ? [f.face.x0, f.face.x1] : []);
+  };
+  const passed = (i, dys) => [
+    Math.floor(i - Math.max(0, ...dys)),
+    Math.ceil(i + 1 - Math.min(0, ...dys))
+  ];
+  const rel = new Float64Array(n * xs.length * 2).fill(NaN);
+  const relOf = (r, c, k) => {
+    const at = (r * xs.length + c) * 2 + k;
+    if (Number.isNaN(rel[at])) rel[at] = relAt(xs[c], ys[r], k === 0 ? -1 : 1);
+    return rel[at];
+  };
+  const cellR = (x, y, k) => {
+    let c = 0;
+    while (c < xs.length - 2 && xs[c + 1] < x) c++;
+    const { r } = gridRow(ys, y);
+    return Math.max(
+      relOf(r, c, k),
+      relOf(r, c + 1, k),
+      relOf(r + 1, c, k),
+      relOf(r + 1, c + 1, k)
+    );
+  };
+  const someAngle = (pairs) => {
+    let lo = 0;
+    let hi = 1;
+    for (const [c0, c1] of pairs) {
+      if (c1 === 0) {
+        if (c0 <= 0) return false;
+      } else if (c1 > 0) lo = Math.max(lo, -c0 / c1);
+      else hi = Math.min(hi, -c0 / c1);
+    }
+    return lo < hi;
+  };
+  const slack = [-1, 1].map(() => new Float64Array(count).fill(NaN));
+  const slackAt = (i, k) => {
+    if (!Number.isNaN(slack[k][i])) return slack[k][i];
+    const y = top - i - 0.5;
+    const w = blendAt(y);
+    const nod = {
+      up: w * NOD.hairFront.up + (1 - w) * cap.up,
+      down: w * NOD.hairFront.down + (1 - w) * cap.down
+    };
+    const ays = [-30, 30];
+    const [b0, b1] = passed(
+      i,
+      ays.map((ay) => nodDy(nod, ay, hh) - nodDy(NOD.hairBack, ay, hh))
+    );
+    const band = [];
+    for (let j = b0; j < b1; j++) band.push(backAt(j));
+    const faces = [];
+    const [f0, f1] = passed(
+      i,
+      ays.map((ay) => nodDy(nod, ay, hh) - face(f.axisX, y, 0, ay)[1])
+    );
+    for (let j = f0; j < f1; j++)
+      faces.push({ y: top - j - 0.5, runs: faceAt(j) });
+    const front = f.hairRuns("hair_front", y);
+    [-1, 1].forEach((s, side) => {
+      let least = Infinity;
+      const far = outerEdge(front, f.axisX, s);
+      if (far !== void 0) {
+        const R = cellR(far, y, side);
+        const c = Math.min(...band.map((b) => runReach(b, far, s).outward));
+        if (R > 0) least = Math.min(least, m.shellScale * c / R);
+      }
+      for (let t = s > 0 ? 0 : 1; t < front.length; t += 2) {
+        const x = front[t];
+        const R = cellR(x, y, side);
+        if (R <= 0) continue;
+        let c = Math.min(
+          ...band.map((b) => runReach(b, x, s > 0 ? -1 : 1).inward)
+        );
+        const sh = (m.shellScale - 1) * (x - f.axisX);
+        const d0 = sh + s * m.hairBack;
+        const d1 = d0 + s * R;
+        const lo = Math.min(d0, d1);
+        const hi = Math.max(d0, d1);
+        const bares = faces.some(({ y: fy, runs }) => {
+          for (let r = 0; r < runs.length; r += 2) {
+            const e0 = runs[r];
+            const e1 = runs[r + 1];
+            const de0 = face(e0, fy, 30 * s, 0)[0];
+            const de1 = face(e1, fy, 30 * s, 0)[0];
+            if (someAngle([
+              [e1 - x, de1 - lo],
+              [x - e0, hi - de0]
+            ])) {
+              return true;
+            }
+          }
+          return false;
+        });
+        if (bares) c = 0;
+        least = Math.min(least, m.shellScale * c / R);
+      }
+      slack[side][i] = least - w;
+    });
+    return slack[k][i];
+  };
+  const extra = [0, 1].map((k) => {
+    const out = wr.slice();
+    for (let r = 0; r < n; r++) {
+      if (wr[r] >= 1) continue;
+      const i0 = Math.max(0, Math.floor(top - ys[Math.max(0, r - 1)]));
+      const i1 = Math.min(count, Math.ceil(top - ys[Math.min(n - 1, r + 1)]));
+      let least = Infinity;
+      for (let i = i0; i < i1; i++) least = Math.min(least, slackAt(i, k));
+      out[r] = wr[r] + clamp(least, 0, 1 - wr[r]);
+    }
+    for (let r = n - 2; r >= 0; r--) {
+      if (wr[r] < 1) out[r] = Math.max(wr[r], Math.min(out[r], out[r + 1]));
+    }
+    return out.map((v, r) => v - wr[r]);
+  });
+  return (y, s) => {
+    if (s === 0) return 0;
+    const e = extra[s < 0 ? 0 : 1];
+    const { r, t } = gridRow(ys, y, true);
+    return e[r] * (1 - t) + e[r + 1] * t;
+  };
+}
 function familyField(m, family) {
   switch (family) {
     case "face":