@ikijs/editor 0.28.0 → 0.29.0

package/dist/index.mjs

@@ -3373,12 +3373,12 @@ function hairFrontBends(frame, boxes) {
 }
 function hairFrontField(m) {
   const f = m.frame;
-  const back = hairField(m, m.hairBack, NOD.hairBack);
   const cap = { up: NOD.hairFrontTop.up, down: capSlide(m) };
   const eyes = [m.boxes.eye_L, m.boxes.eye_R].filter(
     (e) => e !== void 0
   );
   const { inner, left, right } = hairFrontBends(f, m.boxes);
+  const capTop = m.hairFrontGrid?.ys.find((y) => y <= f.face.y1) ?? f.face.y1;
   const eyeY = eyes.length > 0 ? eyes.reduce((t, e) => t + cy(e), 0) / eyes.length : f.eyeY;
   const eyeH = eyes.length > 0 ? eyes.reduce((t, e) => t + (e.y1 - e.y0), 0) / eyes.length : 1;
   const coreAt = (x, y, s) => {
@@ -3411,22 +3411,18 @@ 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 crown = crownRide(m, cap, (x, y, s) => followOf(x, y, s) + drift);
   const boundOf = (x, y, s) => {
     if (ride === void 0) return followOf(x, y, s);
-    const b = ride.blend(y, s);
+    const b = ride.blend(x, y, s);
     return (1 - b) * (followOf(x, y, s) + ride.cut(x, y, s)) - b * drift;
   };
   return (x, y, ax, ay) => {
     const s = Math.sign(ax);
     const a = Math.abs(ax) / 30;
-    const rx = s * a * boundOf(x, y, s) + a * (m.shellScale - 1) * (x - f.axisX);
+    const rx = s * a * boundOf(x, Math.min(y, capTop), 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);
-    const wx = crown === void 0 ? w : w + crown(y, s);
-    return [bx + wx * (rx - bx), by + w * (ry - by)];
+    return [rx, by + crownBlend(m, y) * (ry - by)];
   };
 }
 function crownBlend(m, y) {
@@ -3563,17 +3559,17 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
     sides.forEach((side, k) => {
       const edge = outerEdge(front, f.axisX, side);
       if (edge === void 0) return;
-      let outward = Infinity;
+      let outward2 = Infinity;
       let inward = Infinity;
       for (let j = Math.floor(i - above); j < Math.ceil(i + 1 + below); j++) {
         const c = runReach(backRows[j - j0], edge, side);
-        outward = Math.min(outward, c.outward);
+        outward2 = Math.min(outward2, c.outward);
         inward = Math.min(inward, c.inward);
       }
       offset[k][i] = side * (edge - f.axisX);
-      reachOut[k][i] = outward;
+      reachOut[k][i] = outward2;
       reachIn[k][i] = inward;
-      if (i < capRows && runReach(backRows[i - j0], edge, side).inward > 0)
+      if (i < capRows && y <= f.face.y1 && runReach(backRows[i - j0], edge, side).inward > 0)
         bound[k][i] = 1;
     });
   }
@@ -3583,12 +3579,12 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
     const [i0, i1] = rowWindow(ys, r, count);
     sides.forEach((side, k) => {
       let d = Infinity;
-      let outward = Infinity;
+      let outward2 = Infinity;
       let inward = Infinity;
       for (let i = i0; i < i1; i++) {
         if (Number.isNaN(offset[k][i])) continue;
         d = Math.min(d, offset[k][i]);
-        outward = Math.min(outward, reachOut[k][i]);
+        outward2 = Math.min(outward2, reachOut[k][i]);
         inward = Math.min(inward, reachIn[k][i]);
       }
       end[r * 2 + k] = d;
@@ -3597,7 +3593,7 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
       sides.forEach((s, j) => {
         const allow = Math.min(
           coreAt(x, ys[r], s),
-          m.shellScale * (s === side ? outward : inward) - drift
+          m.shellScale * (s === side ? outward2 : inward) - drift
         );
         lift[(r * 2 + k) * 2 + j] = Math.max(0, allow - followAt(x, ys[r], s));
       });
@@ -3668,73 +3664,117 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
     return quarter.map((q) => scale * q);
   };
   const cuts = new Float64Array(n * 2 * nc);
-  const blend = new Float64Array(n * 2);
+  const blend = new Float64Array(n * 2 * nc);
+  const motion = 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;
+  });
   const wr = ys.map((y) => crownBlend(m, y));
   for (let r = 0; r <= last && capRows > 0; r++) {
-    const w = wr[r];
-    if (w <= 0) continue;
+    if (wr[r] < 1) continue;
     const edges = [];
+    const copied = r > 0 && wr[r - 1] < 1;
     const [i0, i1] = rowWindow(ys, r, capRows);
     for (let i = i0; i < i1; i++) {
+      const y = top - i - 0.5;
       sides.forEach((side, k) => {
         if (bound[k][i] === 0) return;
         const x = f.axisX + side * offset[k][i];
-        const at = readAt(r, x, top - i - 0.5);
-        if (at === void 0) return;
-        edges.push({
-          side,
-          x,
-          at,
-          outward: reachOut[k][i],
-          inward: reachIn[k][i]
-        });
+        for (const at2 of [
+          readAt(r, x, y),
+          copied && y > ys[r] ? readAt(r - 1, x, y) : void 0
+        ]) {
+          if (at2 === void 0) continue;
+          edges.push({
+            side,
+            x,
+            at: at2,
+            outward: reachOut[k][i],
+            inward: reachIn[k][i]
+          });
+        }
       });
     }
     if (edges.length === 0) continue;
     sides.forEach((s, j) => {
       const today = xs.map((x) => followAt(x, ys[r], s) + liftAt(x, ys[r], s));
       const after = today.slice();
-      if (w >= 1) {
-        for (const side of sides) {
-          const mine = edges.filter((e) => e.side === side);
-          if (mine.length === 0) continue;
-          const cut = capCut(r, s, side, today, mine);
-          for (let c = 0; c < nc; c++) after[c] -= cut[c];
-        }
+      for (const side of sides) {
+        const mine = edges.filter((e) => e.side === side);
+        if (mine.length === 0) continue;
+        const cut = capCut(r, s, side, today, mine);
+        for (let c = 0; c < nc; c++) after[c] -= cut[c];
       }
-      let b = 0;
+      const b = blend.subarray((r * 2 + j) * nc, (r * 2 + j + 1) * nc);
       for (const e of edges) {
-        const rel = w * (along(after, e.at) + drift);
         const hi = m.shellScale * ahead(e, s);
         const lo = -m.shellScale * behind(e, s);
-        if (rel > hi) b = Math.max(b, 1 - hi / rel);
-        else if (rel < lo) b = Math.max(b, 1 - lo / rel);
+        const { c, t } = gridCol(xs, e.at);
+        for (const [cc, weight] of [
+          [c, 1 - t],
+          [c + 1, t]
+        ]) {
+          if (weight <= 0) continue;
+          const rel = after[cc] + drift;
+          if (rel > hi) b[cc] = Math.max(b[cc], 1 - hi / rel);
+          else if (rel < lo) b[cc] = Math.max(b[cc], 1 - lo / rel);
+        }
       }
-      blend[r * 2 + j] = b;
+      motion[r * 2 + j] = after.map((v) => v + drift);
       for (let c = 0; c < nc; c++)
         cuts[(r * 2 + j) * nc + c] = after[c] - today[c];
     });
   }
-  for (let j = 0; j < 2; j++) {
-    for (let r = n - 2; r >= 0; r--) {
-      if (r <= last || wr[r] < 1)
-        blend[r * 2 + j] = Math.max(blend[r * 2 + j], blend[(r + 1) * 2 + j]);
-    }
+  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
+      );
+    });
   }
+  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 j = 0; j < 2 && last < n - 1; j++) {
-    for (let r = 1; r < zero; r++) {
-      for (let q = 0; q < r && q <= last; q++) {
-        if (wr[q] < 1) continue;
-        blend[r * 2 + j] = Math.max(
-          blend[r * 2 + j],
-          blend[q * 2 + j] * (ys[r] - endY) / (ys[q] - endY)
-        );
+  for (let pass = 0; pass < 8; pass++) {
+    const was = blend.slice();
+    for (let j = 0; j < 2; j++) {
+      for (let r = n - 2; r >= 0; r--) {
+        if (r > last && wr[r] >= 1) continue;
+        for (let c = 0; c < nc; c++)
+          blend[at(r, j, c)] = Math.max(
+            blend[at(r, j, c)],
+            blend[at(r + 1, j, c)]
+          );
+      }
+    }
+    for (let j = 0; j < 2 && last < n - 1; j++) {
+      for (let r = 1; r < zero; r++) {
+        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
+            );
+        }
       }
     }
+    for (let r = 0; r < n; r++) {
+      sides.forEach(
+        (s, j) => spreadBlend(
+          blend.subarray(at(r, j, 0), at(r, j, nc)),
+          motion[r * 2 + j],
+          xs,
+          outward,
+          s
+        )
+      );
+    }
+    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);
   return {
@@ -3747,158 +3787,47 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
       const { r, t } = gridRow(ys, y, true);
       return cutRow(r, j, x) * (1 - t) + cutRow(r + 1, j, x) * t;
     },
-    blend: (y, s) => {
+    blend: (x, y, s) => {
       if (s === 0) return 0;
       const j = s < 0 ? 0 : 1;
       const { r, t } = gridRow(ys, y, true);
-      return blend[r * 2 + j] * (1 - t) + blend[(r + 1) * 2 + j] * t;
+      const row = (q) => along(blend.subarray(at(q, j, 0), at(q, j, nc)), x);
+      return row(r) * (1 - t) + row(r + 1) * 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) => {
-    const { c } = gridCol(xs, x);
-    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;
+function spreadBlend(b, a, xs, outward, s) {
+  const fit = (ci, co, g) => {
+    const quarter = Math.abs(xs[co] - xs[ci]) / 4;
+    const today = g * (a[co] - a[ci]);
+    const [lo, hi] = [
+      Math.min(today, 0) - quarter,
+      Math.max(today, 0) + quarter
+    ];
+    const ga = g * a[ci];
+    if (ga === 0) return;
+    const outer = g * (1 - b[co]) * a[co];
+    const [b0, b1] = [1 - (outer - hi) / ga, 1 - (outer - lo) / ga];
+    const least = Math.max(b[ci], Math.min(b0, b1));
+    if (least <= Math.min(1, Math.max(b0, b1))) b[ci] = least;
+    else if (Math.min(b0, b1) > 1) b[ci] = 1;
   };
-  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;
+  for (const cols of outward) {
+    for (let i = 1; i < cols.length; i++)
+      b[cols[i]] = Math.max(b[cols[i]], b[cols[i - 1]]);
+  }
+  const [left, right] = outward.map((cols) => cols[0]);
+  const across = left !== void 0 && right !== void 0 && left !== right;
+  for (let pass = 0; pass < 2; pass++) {
+    outward.forEach((cols, k) => {
+      const g = (k === 0 ? -1 : 1) * s;
+      for (let i = cols.length - 1; i > 0; i--) fit(cols[i - 1], cols[i], g);
     });
-    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, i1] = rowWindow(ys, r, count);
-      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]);
+    if (across) {
+      if (b[left] <= b[right]) fit(left, right, s);
+      else fit(right, left, -s);
     }
-    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) {