animl 0.0.0-stage → 0.1.0

package/modules/skin/core/index.js

@@ -0,0 +1,274 @@
+import { apply, IDENTITY, invert, mul } from "../../../packages/core/src/geom.js";
+import {
+  C,
+  L,
+  M,
+  Z,
+  formatSegs,
+  parsePath
+} from "../../../packages/core/src/path.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { drawFrame, drawWorld } from "../../../packages/core/src/draw.js";
+import { after } from "../manifest.js";
+import { entries, skinElement } from "../capabilities/rigging-skin/registry.js";
+const data = /* @__PURE__ */ new WeakMap();
+let rig;
+let contour;
+const extensions = [];
+const rigContext = (p) => rig?.context(p);
+const pathRest = (n) => {
+  const out = [];
+  for (const sp of n.geom ?? [])
+    for (let i = 0; i < sp.segs.length; ) {
+      const op = sp.segs[i++];
+      if (op === C) {
+        out.push([sp.segs[i + 4], sp.segs[i + 5]]);
+        i += 6;
+      } else if (op !== Z) {
+        out.push([sp.segs[i], sp.segs[i + 1]]);
+        i += 2;
+      }
+    }
+  return out;
+};
+const contourRest = (n) => {
+  const o = n.raw.geometryOrigin ?? [0, 0];
+  return n.raw.vertices.map((v) => [v.point[0] - o[0], v.point[1] - o[1]]);
+};
+function normalize(raw, allowed, pointer, d) {
+  const pairs = Object.entries(raw);
+  if (pairs.length > 4)
+    d.err(
+      "rig-weight-count",
+      pointer,
+      V && `weight has ${pairs.length} influences`,
+      V && "use at most four bones including @rest"
+    );
+  let sum = 0;
+  for (const [name, weight] of pairs) {
+    sum += weight;
+    if (name !== "@rest" && !allowed.has(name))
+      d.err(
+        "rig-weight-bone",
+        pointer + "/" + name.replace(/~/g, "~0").replace(/\//g, "~1"),
+        V && `weight references bone ${name} outside skin.bones`,
+        V && "add the bone to skin.bones or remove the influence"
+      );
+  }
+  if (Math.abs(sum - 1) > 1e-6)
+    d.err(
+      "rig-weight-sum",
+      pointer,
+      V && `weights sum to ${sum}`,
+      V && "weights are normalized automatically",
+      "warning"
+    );
+  if (!(sum > 0)) return [[-1, 1]];
+  return pairs.map(([name, w]) => [name === "@rest" ? -1 : allowed.get(name) ?? -2, w / sum]);
+}
+function influence(p, node, k, part, point, s) {
+  const w = s.weights?.[k];
+  return w ? w[part] ?? w.point : extensions[0]?.(p, node, `${node}:${k}:${part}`, point, s, rig) ?? [[-1, 1]];
+}
+function deform(p, node, point, w) {
+  const ctx = rig?.context(p), w0 = ctx?.rest(node) ?? p.world(node), iw0 = invert(w0);
+  if (!iw0) return point;
+  const q = apply(w0, point[0], point[1]);
+  let x = 0, y = 0;
+  for (const [bone, amount] of w) {
+    let v = q;
+    if (bone >= 0 && ctx) {
+      const inv = invert(ctx.rest(bone));
+      if (inv) v = apply(mul(ctx.world(bone), inv), q[0], q[1]);
+    }
+    x += v[0] * amount;
+    y += v[1] * amount;
+  }
+  return apply(iw0, x, y);
+}
+function move(p, node, k, part, point, s) {
+  return deform(p, node, point, influence(p, node, k, part, point, s));
+}
+function skinPath(p, node, s) {
+  let k = 0;
+  const out = (p.model.nodes[node].geom ?? []).map((sp) => {
+    const g = [...sp.segs];
+    let previous = -1;
+    for (let i = 0; i < g.length; ) {
+      const op = g[i++];
+      if (op === Z) continue;
+      if (op === M || op === L) {
+        const current = k++, q = move(p, node, current, "point", [g[i], g[i + 1]], s);
+        [g[i], g[i + 1]] = q;
+        i += 2;
+        previous = current;
+      } else if (op === C) {
+        const current = k++, a = move(p, node, previous, "out", [g[i], g[i + 1]], s), b = move(p, node, current, "in", [g[i + 2], g[i + 3]], s), q = move(p, node, current, "point", [g[i + 4], g[i + 5]], s);
+        g.splice(i, 6, ...a, ...b, ...q);
+        i += 6;
+        previous = current;
+      }
+    }
+    return { ...sp, segs: g };
+  });
+  return formatSegs(out);
+}
+function skinContour(p, node, s) {
+  const raw = p.model.nodes[node].raw, vertices = raw.vertices, source = contour?.pathfollowPath(p, node), sp = source && parsePath(source)[0];
+  if (!sp || !vertices.length) return source ?? "";
+  const g = [...sp.segs];
+  let pos = 0;
+  const transform = (k, part) => {
+    const q = move(p, node, k, part, [g[pos], g[pos + 1]], s);
+    g[pos++] = q[0];
+    g[pos++] = q[1];
+  };
+  pos++;
+  transform(0, "point");
+  const segment = (from, to, rounded = false) => {
+    const op = g[pos++];
+    if (op === C) {
+      transform(rounded ? to : from, rounded ? "point" : "out");
+      transform(to, rounded ? "point" : "in");
+    }
+    transform(to, "point");
+  };
+  for (let i = 0; i < vertices.length; i++) {
+    if (vertices[i].kind === "rounded" && (raw.closed || i > 0 && i + 1 < vertices.length))
+      segment(i, i, true);
+    if (i + 1 < vertices.length) segment(i, i + 1);
+    else if (raw.closed) segment(i, 0);
+  }
+  return formatSegs([{ ...sp, segs: g }]);
+}
+function geometry(p, node) {
+  const n = p.model.nodes[node], s = data.get(n.raw);
+  if (!s) return;
+  const type = n.type;
+  return type === "path" ? skinPath(p, node, s) : type === "contour" ? skinContour(p, node, s) : void 0;
+}
+const skin = {
+  name: "skin",
+  after,
+  entries,
+  init(registry, _shared) {
+    if (V) skin.entries[0].elements = { skin: skinElement };
+    rig = registry.get("rig");
+    contour = registry.get("contour");
+    return { ...this, init: void 0, x: extensions };
+  },
+  prepare(model, d) {
+    const paths = [], counts = /* @__PURE__ */ new Map();
+    for (const [i, n] of model.nodes.entries()) {
+      const index = counts.get(n.parent) ?? 0;
+      counts.set(n.parent, index + 1);
+      const path = paths[i] = (n.parent < 0 ? "/nodes" : paths[n.parent] + "/children") + "/" + index;
+      const raw = n.raw.skin;
+      if (!raw) continue;
+      const at = path + "/skin", type = n.type, host = type === "path" || type === "contour" || type === "image" && !!n.raw.mesh;
+      if (!host)
+        d.err(
+          "rig-skin-host",
+          at,
+          V && "skin requires a path, contour, or meshed image",
+          V && "move skin to supported geometry"
+        );
+      if (!raw.weights && !extensions[0])
+        d.err(
+          "rig-skin-feature",
+          at + "/weights",
+          V && "automatic skin weights need the skin-auto entry",
+          V && "import 'animl/web/skin-auto' before loading this document"
+        );
+      if (type === "image" && n.raw.mesh && !extensions[1])
+        d.err(
+          "rig-skin-feature",
+          at,
+          V && "skinned images need the skin-mesh entry",
+          V && "import 'animl/web/skin-mesh' before loading this document"
+        );
+      const percentageDash = [
+        n.raw.stroke,
+        ...(n.raw.paints ?? []).map((p) => p.stroke)
+      ].some(
+        (stroke) => stroke?.dash?.some((v) => typeof v === "string" && v.endsWith("%"))
+      );
+      if (percentageDash && !extensions[3])
+        d.err(
+          "rig-skin-feature",
+          at,
+          V && "skinned percentage dashes need the skin-dash entry",
+          V && "import 'animl/web/skin-dash' before loading this document"
+        );
+      const allowed = /* @__PURE__ */ new Map();
+      raw.bones.forEach((id, k) => {
+        const bone = model.ids.get(id);
+        if (bone === void 0 || model.nodes[bone].type !== "bone")
+          d.err(
+            "rig-weight-bone",
+            `${at}/bones/${k}`,
+            V && `${id} is not a bone`,
+            V && "use an existing bone id"
+          );
+        else allowed.set(id, bone);
+      });
+      const rest = type === "path" ? pathRest(n) : type === "contour" ? contourRest(n) : extensions[1]?.(n) ?? [];
+      if (raw.weights && raw.weights.length !== rest.length)
+        d.err(
+          "bad-value",
+          at + "/weights",
+          V && `skin has ${raw.weights.length} weights for ${rest.length} points`,
+          V && "provide one weight entry per point"
+        );
+      const weights = raw.weights?.map((w, k) => ({
+        point: normalize(w.point, allowed, `${at}/weights/${k}/point`, d),
+        ...w.in ? { in: normalize(w.in, allowed, `${at}/weights/${k}/in`, d) } : {},
+        ...w.out ? { out: normalize(w.out, allowed, `${at}/weights/${k}/out`, d) } : {}
+      }));
+      data.set(n.raw, { bones: [...allowed.values()], weights, rest, at });
+    }
+  },
+  load(model, _raw, d) {
+    for (const n of model.nodes) {
+      const s = data.get(n.raw);
+      if (s && n.type === "path" && model.addrs.has(n.id + ".d"))
+        d.err(
+          "rig-skin-morph",
+          s.at,
+          V && "a skinned path cannot animate d",
+          V && "animate bones or remove skin"
+        );
+    }
+    const previous = model.nesting;
+    model.nesting = (p) => {
+      const nested = previous?.(p);
+      p.hitFrame ??= () => drawFrame(p);
+      if (extensions[2])
+        p.skinPoints = (node, xy) => {
+          const s = data.get(p.model.nodes[node].raw);
+          if (s) extensions[2](p, node, xy, s, move);
+        };
+      return nested;
+    };
+  },
+  draw: {
+    frame(p, i, node, _entry, frame) {
+      const s = data.get(p.model.nodes[i].raw);
+      if (!s) return;
+      const d = geometry(p, i);
+      if (d !== void 0) {
+        node.geometry = { kind: "path", d };
+      }
+      const rest = rig?.context(p)?.rest(i);
+      if (!rest) return;
+      const parent = p.model.nodes[i].parent, base = parent < 0 ? IDENTITY : drawWorld(p, parent, frame), inverse = invert(base);
+      if (inverse) node.transform = mul(inverse, rest);
+    }
+  }
+};
+export {
+  data,
+  move,
+  rigContext,
+  skin
+};

package/modules/skin/core/mesh.d.ts

@@ -0,0 +1,5 @@
+import type { NodeM } from '../../../packages/core/src/load.js';
+import type { Player } from '../../../packages/core/src/player.js';
+import type { SkinData } from './index.js';
+export declare function meshRest(n: NodeM): [number, number][];
+export declare function skinMeshPoints(p: Player, node: number, xy: number[], s: SkinData, move: (p: Player, node: number, k: number, part: 'point' | 'in' | 'out', point: [number, number], s: SkinData) => [number, number]): void;

package/modules/skin/core/mesh.js

@@ -0,0 +1,21 @@
+function meshRest(n) {
+  const r = n.raw, m = r.mesh;
+  if (!m) return [];
+  if (m.vertices) return m.vertices.map((v) => [v[0], v[1]]);
+  const [cols, rows] = m.grid, out = [];
+  for (let y = 0; y <= rows; y++)
+    for (let x = 0; x <= cols; x++)
+      out.push([r.x0 + r.width * x / cols, r.y0 + r.height * y / rows]);
+  return out;
+}
+function skinMeshPoints(p, node, xy, s, move) {
+  for (let k = 0; k * 2 < xy.length; k++) {
+    const q = move(p, node, k, "point", [xy[k * 2], xy[k * 2 + 1]], s);
+    xy[k * 2] = q[0];
+    xy[k * 2 + 1] = q[1];
+  }
+}
+export {
+  meshRest,
+  skinMeshPoints
+};

package/modules/skin/core/svg.d.ts

@@ -0,0 +1,2 @@
+import type { SVGBackend } from '../../../packages/core/src/svg.js';
+export declare const skinSVG: SVGBackend;

package/modules/skin/core/svg.js

@@ -0,0 +1,4 @@
+const skinSVG = {};
+export {
+  skinSVG
+};

package/modules/skin/core/values.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleRegistry } from '../../../packages/core/src/modules.js';
+export declare function installValues(_shared: ModuleRegistry): void;

package/modules/skin/core/values.js

@@ -0,0 +1,23 @@
+import { apply } from "../../../packages/core/src/geom.js";
+import { data, move, rigContext } from "./index.js";
+import { valueProviders } from "../../rig/core/api.js";
+function installValues(_shared) {
+  valueProviders.set("skin", (player, out) => {
+    for (const [i, n] of player.model.nodes.entries()) {
+      const s = data.get(n.raw);
+      if (!s) continue;
+      s.rest.forEach((rest, k) => {
+        const grid = n.raw.mesh?.grid, at = (key) => player.prop(i, key), base = String(n.type) === "image" ? player.prop(i, "mesh.vertex." + k) ?? // A grid vertex follows the resolved (possibly animated) image box, as drawing does.
+        (grid ? [
+          at("x0") + at("width") * (k % (grid[0] + 1)) / grid[0],
+          at("y0") + at("height") * Math.floor(k / (grid[0] + 1)) / grid[1]
+        ] : rest) : rest;
+        const local = move(player, i, k, "point", base, s), worldMatrix = rigContext(player)?.rest(i) ?? player.world(i), world = apply(worldMatrix, local[0], local[1]);
+        out[n.id + ".skin.point." + k] = world;
+      });
+    }
+  });
+}
+export {
+  installValues
+};

package/modules/skin/manifest.d.ts

@@ -0,0 +1,46 @@
+export declare const after: string[];
+declare const _default: {
+    name: string;
+    summary: string;
+    after: string[];
+    core: {
+        entry: string;
+        export: string;
+        svg: string;
+        svgExport: string;
+    };
+    web: ({
+        name: string;
+        budget: number;
+        heavy: boolean;
+        over?: undefined;
+    } | {
+        name: string;
+        budget: number;
+        over: string;
+        heavy: boolean;
+    })[];
+    adapters: {
+        'packages/core/src/modules/skin/index.ts': string;
+        'packages/core/src/modules/skin/svg.ts': string;
+        'packages/markup/src/skin.ts': string;
+        'packages/web/src/skin.ts': string;
+        'packages/web/src/skin-auto.ts': string;
+        'packages/web/src/skin-dash.ts': string;
+        'packages/web/src/skin-mesh.ts': string;
+        'packages/web/src/skin-values.ts': string;
+    };
+    exports: {
+        'core:./skin': string;
+        'markup:./skin': string;
+        'web:./skin': string;
+        'web:./skin-auto': string;
+        'web:./skin-dash': string;
+        'web:./skin-mesh': string;
+        'web:./skin-values': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/skin/manifest.js

@@ -0,0 +1,44 @@
+const after = ["contour", "mesh", "paint", "rig"];
+var manifest_default = {
+  name: "skin",
+  summary: "Skinning: deform paths, contours and meshes from bones with explicit or automatic weights.",
+  after,
+  core: { entry: "core/all.ts", export: "skin", svg: "core/svg.ts", svgExport: "skinSVG" },
+  web: [
+    { name: "skin", budget: 1536, heavy: true },
+    { name: "skin-auto", budget: 320, over: "skin", heavy: true },
+    { name: "skin-dash", budget: 192, over: "skin", heavy: true },
+    { name: "skin-mesh", budget: 256, over: "skin", heavy: true },
+    { name: "skin-values", budget: 256, over: "skin", heavy: true }
+  ],
+  adapters: {
+    "packages/core/src/modules/skin/index.ts": "core/all.ts",
+    "packages/core/src/modules/skin/svg.ts": "core/svg.ts",
+    "packages/markup/src/skin.ts": "markup/index.ts",
+    "packages/web/src/skin.ts": "web/index.ts",
+    "packages/web/src/skin-auto.ts": "web/auto.ts",
+    "packages/web/src/skin-dash.ts": "web/dash.ts",
+    "packages/web/src/skin-mesh.ts": "web/mesh.ts",
+    "packages/web/src/skin-values.ts": "web/values.ts"
+  },
+  exports: {
+    "core:./skin": "packages/core/src/modules/skin/index.ts",
+    "markup:./skin": "packages/markup/src/skin.ts",
+    "web:./skin": "packages/web/src/skin.ts",
+    "web:./skin-auto": "packages/web/src/skin-auto.ts",
+    "web:./skin-dash": "packages/web/src/skin-dash.ts",
+    "web:./skin-mesh": "packages/web/src/skin-mesh.ts",
+    "web:./skin-values": "packages/web/src/skin-values.ts"
+  },
+  tests: [
+    "modules/skin/test/**/*.test.ts",
+    "packages/markup/test/corpus.test.ts",
+    "packages/markup/test/names.test.ts"
+  ],
+  conformance: ["rigging-skin", "rigging-weights", "rigging-cubic-weights"],
+  docs: ["spec/SPEC.md"]
+};
+export {
+  after,
+  manifest_default as default
+};

package/modules/skin/markup/index.d.ts

@@ -0,0 +1 @@
+export {};

package/modules/skin/web/auto.d.ts

@@ -0,0 +1 @@
+import './index.js';

package/modules/skin/web/auto.js

@@ -0,0 +1,11 @@
+import "./index.js";
+import { automatic } from "../core/auto.js";
+customElements.get("anima-icon").registerModule({
+  name: "skinauto",
+  after: ["skin"],
+  entries: [],
+  init(registry) {
+    registry.get("skin").x[0] = automatic;
+    return this;
+  }
+});

package/modules/skin/web/dash.d.ts

@@ -0,0 +1 @@
+import './index.js';

package/modules/skin/web/dash.js

@@ -0,0 +1,16 @@
+import "./index.js";
+import { skinDash } from "../core/dash.js";
+customElements.get("anima-icon").registerModule({
+  name: "skindash",
+  after: ["skin"],
+  entries: [],
+  init(registry) {
+    registry.get("skin").x[3] = true;
+    return this;
+  },
+  draw: {
+    frame(p, i, node, _entry, frame) {
+      if (p.model.nodes[i].raw.skin) skinDash(i, node, frame);
+    }
+  }
+});

package/modules/skin/web/index.d.ts

@@ -0,0 +1 @@
+import '../../../packages/web/src/index.js';

package/modules/skin/web/index.js

@@ -0,0 +1,3 @@
+import { skin } from "../core/index.js";
+import "../../../packages/web/src/index.js";
+customElements.get("anima-icon").registerModule(skin);

package/modules/skin/web/mesh.d.ts

@@ -0,0 +1 @@
+import './index.js';

package/modules/skin/web/mesh.js

@@ -0,0 +1,13 @@
+import "./index.js";
+import { meshRest, skinMeshPoints } from "../core/mesh.js";
+customElements.get("anima-icon").registerModule({
+  name: "skinmesh",
+  after: ["skin"],
+  entries: [],
+  init(registry) {
+    const extensions = registry.get("skin").x;
+    extensions[1] = meshRest;
+    extensions[2] = skinMeshPoints;
+    return this;
+  }
+});

package/modules/skin/web/values.d.ts

@@ -0,0 +1 @@
+import './index.js';

package/modules/skin/web/values.js

@@ -0,0 +1,11 @@
+import "./index.js";
+import { installValues } from "../core/values.js";
+customElements.get("anima-icon").registerModule({
+  name: "skinvalues",
+  after: ["skin"],
+  entries: [],
+  init(_registry, shared) {
+    installValues(shared);
+    return this;
+  }
+});

package/modules/surface/core/index.d.ts

@@ -0,0 +1,4 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+export declare const surface: Module;
+/** Outer bands retain size; interior bands share remaining space proportionally. Small targets shrink borders uniformly. */
+export declare function destinations(c: number[], size: number): number[];