@ikijs/editor 0.18.0 → 0.19.0

package/dist/index.mjs

@@ -2684,7 +2684,11 @@ function headOwnBreath(hasBody) {
 var ELBOW_AT = 0.42;
 var CAP_ROWS = [0.1, 0.3];
 var CAP_SEGMENTS = 12;
-var ARM_RANGE = [-30, 150];
+var CAP_INSET = 3;
+var capInset = (i) => Math.round(CAP_INSET * Math.min(1, Math.min(i, CAP_SEGMENTS - i) / 2));
+var CAP_RIM = 0.25;
+var ARM_RANGE = [-8, 32];
+var ELBOW_RANGE = [-10, 90];
 var ARM_PARAMS = {
   arm_L: { arm: P3.ArmLeft, elbow: P3.ElbowLeft },
   arm_R: { arm: P3.ArmRight, elbow: P3.ElbowRight }
@@ -2692,11 +2696,13 @@ var ARM_PARAMS = {
 var ARM_IDS = {
   arm_L: {
     forearm: "forearm_L",
+    cap: "elbow_L",
     armDeformer: "armDeformer_L",
     forearmDeformer: "forearmDeformer_L"
   },
   arm_R: {
     forearm: "forearm_R",
+    cap: "elbow_R",
     armDeformer: "armDeformer_R",
     forearmDeformer: "forearmDeformer_R"
   }
@@ -2749,11 +2755,30 @@ function armGeometry(layer, bodyAxisX) {
     b.x1 - elbow.x,
     b.y1 - elbow.y
   );
+  const inside = (x, y) => {
+    const k = Math.floor(y) - bbox.y;
+    if (k < 0 || k >= bbox.h) return false;
+    const [rs, re] = span(k);
+    return rs < x && x < re;
+  };
+  const capRays = Array.from({ length: CAP_SEGMENTS + 1 }, (_, i) => {
+    const a = Math.PI * i / CAP_SEGMENTS;
+    let t = 1;
+    while (t <= capRadius + CAP_INSET && inside(
+      elbow.x + canvasW / 2 + t * Math.cos(a),
+      canvasH / 2 - elbow.y - t * Math.sin(a)
+    )) {
+      t++;
+    }
+    return Math.min(capRadius, Math.max(1, t - capInset(i)));
+  });
   return {
     shoulder,
     shoulderRadius: ru,
     elbow,
     capRadius,
+    capRays,
+    seamRun: [s - bbox.x, e - bbox.x],
     side: shoulder.x > bodyAxisX ? 1 : -1
   };
 }
@@ -2768,69 +2793,101 @@ function armParts(role, layer, g, order) {
   const lx = (x) => roundTo((x - cx(b)) / bw(b), 1e-5);
   const ly = (y) => roundTo((y - cy(b)) / bh(b), 1e-5);
   const seam = ly(g.elbow.y);
-  const band = (top, bottom) => [
+  const band = (top2, bottom) => [
     -0.5,
-    top,
+    top2,
     0.5,
-    top,
+    top2,
     -0.5,
     bottom,
     0.5,
     bottom
   ];
   const quad = [2, 3, 0, 0, 3, 1];
-  const cap = [lx(g.elbow.x), seam];
+  const rays = g.capRays.length;
+  const top = (rays - 1) / 2;
+  const at = (i, r) => {
+    const a = Math.PI * i / (rays - 1);
+    return [lx(g.elbow.x + r * Math.cos(a)), ly(g.elbow.y + r * Math.sin(a))];
+  };
+  const width = (i) => Math.min(CAP_RIM * g.capRadius, g.capRays[i] / 2);
+  const ringRays = Array.from({ length: rays }, (_, i) => i);
+  ringRays.splice(top, 0, top);
+  const vertices = [lx(g.elbow.x), seam];
+  for (let i = 0; i < rays; i++) {
+    vertices.push(...at(i, g.capRays[i] - width(i)));
+  }
+  const ringInner = vertices.length / 2;
+  for (const i of ringRays) vertices.push(...at(i, g.capRays[i] - width(i)));
+  const ringOuter = vertices.length / 2;
+  for (const i of ringRays) vertices.push(...at(i, g.capRays[i]));
+  const { uvs } = meshOf(vertices, []);
+  const col = (c) => roundTo(Math.min(Math.max(c + 0.5, 0.5), bw(b) - 0.5) / bw(b), 1e-5);
+  const v = roundTo(0.5 - seam, 1e-5);
+  ringRays.forEach((i, j) => {
+    const right = j <= top;
+    const outer = right ? g.seamRun[1] : g.seamRun[0] - 1;
+    const step = right ? -width(i) : width(i);
+    uvs[(ringInner + j) * 2] = col(outer + step);
+    uvs[(ringInner + j) * 2 + 1] = v;
+    uvs[(ringOuter + j) * 2] = col(outer);
+    uvs[(ringOuter + j) * 2 + 1] = v;
+  });
   const fan = [];
-  for (let i = 0; i <= CAP_SEGMENTS; i++) {
-    const a = Math.PI * i / CAP_SEGMENTS;
-    cap.push(
-      lx(g.elbow.x + g.capRadius * Math.cos(a)),
-      ly(g.elbow.y + g.capRadius * Math.sin(a))
-    );
-    if (i > 0) fan.push(4, 4 + i, 5 + i);
-  }
-  const part = (id, deformer, at, mesh) => ({
+  for (let i = 0; i < rays - 1; i++) fan.push(0, 1 + i, 2 + i);
+  const ring = [];
+  for (let j = 0; j < ringRays.length - 1; j++) {
+    if (j === top) continue;
+    const [p, q] = [ringInner + j, ringOuter + j];
+    ring.push(p, q, q + 1, p, q + 1, p + 1);
+  }
+  const part = (id, deformer, z, mesh) => ({
     id,
     color: [1, 1, 1, 1],
     width: bw(b),
     height: bh(b),
     transform: { x: cx(b), y: cy(b) },
-    order: at,
+    order: z,
     deformer,
     mesh
   });
   const ids = ARM_IDS[role];
   return [
-    part(role, ids.armDeformer, order, meshOf(band(0.5, seam), quad)),
+    part(ids.cap, ids.forearmDeformer, order, {
+      vertices,
+      uvs,
+      indices: [...fan, ...ring]
+    }),
+    part(role, ids.armDeformer, order + 1, meshOf(band(0.5, seam), quad)),
     part(
       ids.forearm,
       ids.forearmDeformer,
-      order + 1,
-      meshOf([...band(seam, -0.5), ...cap], [...quad, ...fan])
+      order + 2,
+      meshOf(band(seam, -0.5), quad)
     )
   ];
 }
 function armDeformers(role, g) {
   const ids = ARM_IDS[role];
   const params = ARM_PARAMS[role];
-  const rotate = (parameter) => ({
+  const rotate = (parameter, range, sign) => ({
     parameter,
     channel: "rotate",
-    from: g.side * ARM_RANGE[0],
-    to: g.side * ARM_RANGE[1]
+    from: sign * range[0],
+    to: sign * range[1]
   });
   return [
     {
       id: ids.armDeformer,
       parent: BODY_WARP_ID,
       pivot: { ...g.shoulder },
-      bindings: [rotate(params.arm)]
+      bindings: [rotate(params.arm, ARM_RANGE, g.side)]
     },
     {
       id: ids.forearmDeformer,
       parent: ids.armDeformer,
       pivot: { ...g.elbow },
-      bindings: [rotate(params.elbow)]
+      bindings: [rotate(params.elbow, ELBOW_RANGE, -g.side)]
     }
   ];
 }
@@ -2839,8 +2896,8 @@ function armDeformers(role, g) {
 var ROLE_TABLE = [
   { role: "hair_back", family: "hair_back" },
   { role: "body", family: "body" },
-  { role: "arm_L", family: "arm", parts: ["arm_L", "forearm_L"] },
-  { role: "arm_R", family: "arm", parts: ["arm_R", "forearm_R"] },
+  { role: "arm_L", family: "arm", parts: ["elbow_L", "arm_L", "forearm_L"] },
+  { role: "arm_R", family: "arm", parts: ["elbow_R", "arm_R", "forearm_R"] },
   { role: "face", family: "face", required: true },
   { role: "blush_L", family: "face" },
   { role: "blush_R", family: "face" },
@@ -5659,13 +5716,14 @@ function declareParameters(roles) {
     add(P6.BodyAngleZ, "Body Angle Z", -10, 10, 0);
   }
   const [armMin, armMax] = ARM_RANGE;
+  const [elbowMin, elbowMax] = ELBOW_RANGE;
   if (roles.has("arm_L")) {
     add(P6.ArmLeft, "Arm L", armMin, armMax, 0);
-    add(P6.ElbowLeft, "Elbow L", armMin, armMax, 0);
+    add(P6.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
   }
   if (roles.has("arm_R")) {
     add(P6.ArmRight, "Arm R", armMin, armMax, 0);
-    add(P6.ElbowRight, "Elbow R", armMin, armMax, 0);
+    add(P6.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
   }
   add(P6.EyeOpenLeft, "Eye L", 0, 1, 1);
   add(P6.EyeOpenRight, "Eye R", 0, 1, 1);