animl 0.0.0-stage → 0.1.0

package/modules/rig/core/origin.js

@@ -0,0 +1,107 @@
+import { apply, invert, mul } from "../../../packages/core/src/geom.js";
+import { flatten } from "../../../packages/core/src/path.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { origin } from "./constraints.js";
+const extremes = (m, rx, ry) => [0, 1].flatMap((i) => {
+  const t = Math.atan2(m[i + 2] * ry, m[i] * rx) * 180 / Math.PI;
+  return [t, t + 180];
+});
+function geometryPoints(ctx, node, m) {
+  const n = ctx.model.nodes[node], r = n.raw, type = String(n.type);
+  if (n.geom) return flatten(n.geom).flatMap((s) => s.pts);
+  const ellipse = (x, y, rx, ry, angles) => angles.flatMap((v) => {
+    const q = v * Math.PI / 180;
+    return [x + rx * Math.cos(q), y + ry * Math.sin(q)];
+  });
+  if (type === "circle") return ellipse(r.center[0], r.center[1], r.r, r.r, extremes(m, r.r, r.r));
+  if (type === "arc") {
+    const [x, y] = r.center, d = r.r, from = r.from, to = r.to, a = extremes(m, d, d).map((t) => from + ((t - from) % 360 + 360) % 360);
+    return ellipse(x, y, d, d, [from, to, ...a.filter((v) => v > from && v < to)]);
+  }
+  const box = (x, y, w, h) => [
+    x,
+    y,
+    x + w,
+    y,
+    x + w,
+    y + h,
+    x,
+    y + h
+  ];
+  if (type === "rect") return box(r.x0, r.y0, r.w, r.h);
+  if (type === "ellipse") return ellipse(r.cx, r.cy, r.rx, r.ry, extremes(m, r.rx, r.ry));
+  if (type === "triangle")
+    return [r.x0 + r.width / 2, r.y0, r.x0 + r.width, r.y0 + r.height, r.x0, r.y0 + r.height];
+  if (type === "polygon" || type === "star") {
+    const star = type === "star", count = r[star ? "points" : "sides"] * (star ? 2 : 1);
+    return Array.from({ length: count }, (_, j) => {
+      const a = (star ? -90 : r.rotation - 90) * Math.PI / 180 + j * Math.PI * 2 / count, d = star && j % 2 ? r.innerRadius : r.radius;
+      return [r.cx + d * Math.cos(a), r.cy + d * Math.sin(a)];
+    }).flat();
+  }
+  if (type === "contour")
+    return r.vertices.flatMap((v) => v.point.slice(0, 2));
+  if (["image", "text", "layout"].includes(type)) {
+    const x = Number(r.x0 ?? 0), y = Number(r.y0 ?? 0), w = Number(r.width ?? 0), h = Number(r.height ?? 0);
+    return box(x, y, w, h);
+  }
+  return [];
+}
+function subtreePoints(ctx, root) {
+  const inv = invert(ctx.rest(root));
+  if (!inv) return [];
+  const out = [];
+  const visit = (node) => {
+    const rel = mul(inv, ctx.rest(node)), p = geometryPoints(ctx, node, rel);
+    for (let k = 0; k < p.length; k += 2) out.push(...apply(rel, p[k], p[k + 1]));
+    for (const child of ctx.model.nodes[node].children) visit(child);
+  };
+  visit(root);
+  return out;
+}
+function point(ctx, node, uv, frame) {
+  const points = subtreePoints(ctx, node);
+  if (!points.length) return apply(frame, 0, 0);
+  const at = (axis) => {
+    const values = points.filter((_, k) => k % 2 === axis), lo = Math.min(...values);
+    return lo + (Math.max(...values) - lo) * Number(uv[axis]);
+  };
+  return apply(frame, at(0), at(1));
+}
+function tupleBindings(bind) {
+  const expression = bind.expression;
+  return {
+    ...bind,
+    expression(source, types, expected, pointer, diag, read) {
+      if (expected !== "point") return expression(source, types, expected, pointer, diag, read);
+      source = source.trim();
+      let depth = 0, comma = -1;
+      for (let k = 1; k < source.length - 1; k++) {
+        if (source[k] === "(") depth++;
+        if (source[k] === ")") depth--;
+        if (source[k] === "," && depth === 0) {
+          comma = k;
+          break;
+        }
+      }
+      if (source[0] !== "[" || !source.endsWith("]") || comma < 0) {
+        diag.err(
+          "bind-type",
+          pointer,
+          V && "origin binding needs [u-expression, v-expression]",
+          V && "use two numeric expressions inside brackets"
+        );
+        return;
+      }
+      const u = expression(source.slice(1, comma), types, "number", pointer, diag, read), v = expression(source.slice(comma + 1, -1), types, "number", pointer, diag, read);
+      if (u && v) return (scope) => [u(scope), v(scope)];
+    }
+  };
+}
+function installOrigin(target = origin, bind) {
+  target.point = point;
+  if (bind) Object.assign(bind, tupleBindings(bind));
+}
+export {
+  installOrigin
+};

package/modules/rig/core/solve.d.ts

@@ -0,0 +1,9 @@
+import type { Model } from '../../../packages/core/src/load.js';
+import type { Player } from '../../../packages/core/src/player.js';
+import { type Mat } from '../../../packages/core/src/geom.js';
+import { type RigContext } from './api.js';
+export declare const bone: (m: Model, i: number) => boolean;
+export declare const pivot: (m: Model, i: number) => number[];
+export declare const inverse: (m: Mat) => Mat;
+export declare const contexts: WeakMap<Player, RigContext>;
+export declare function install(model: Model, order: number[]): void;

package/modules/rig/core/solve.js

@@ -0,0 +1,111 @@
+import { IDENTITY, invert, localMatrix, mul } from "../../../packages/core/src/geom.js";
+import {
+  blend,
+  constraintKinds,
+  position,
+  solvePasses
+} from "./api.js";
+const bone = (m, i) => m.nodes[i]?.type === "bone";
+const pivot = (m, i) => bone(m, i) ? [0, 0] : m.nodes[i]?.raw.pivot ?? [0, 0];
+const inverse = (m) => invert(m) ?? IDENTITY;
+const contexts = /* @__PURE__ */ new WeakMap();
+function install(model, order) {
+  const rest = [], restDraw = [];
+  const frame = (i, read) => {
+    const n = model.nodes[i], chain = bone(model, i) && bone(model, n.parent) && !n.raw.root, s = read(i, "scale", 1);
+    return localMatrix(
+      chain ? read(n.parent, "length", 0) : read(i, "x", 0),
+      chain ? 0 : read(i, "y", 0),
+      ...pivot(model, i),
+      read(i, "rotate", 0),
+      s * read(i, "scaleX", 1),
+      s * read(i, "scaleY", 1)
+    );
+  };
+  for (const [i, n] of model.nodes.entries()) {
+    const parent = restDraw[n.parent] ?? IDENTITY;
+    rest[i] = mul(
+      bone(model, i) && bone(model, n.parent) && !n.raw.root ? rest[n.parent] : parent,
+      frame(i, (j, key, def) => model.nodes[j].raw[key] ?? def)
+    );
+    restDraw[i] = bone(model, i) ? parent : rest[i];
+  }
+  const previousInit = model.nesting, previousStep = model.afterStep;
+  model.nesting = (p) => {
+    const nested = previousInit?.(p), local = p.local.bind(p), worlds = [], drawn = [], locals = [], overrides = /* @__PURE__ */ new Map();
+    let solving = -1;
+    const ctx = {
+      player: p,
+      model,
+      world: (i) => worlds[i] ?? IDENTITY,
+      rest: (i) => rest[i] ?? IDENTITY,
+      position: (i, matrix = worlds[i] ?? IDENTITY) => position(matrix, pivot(model, i)),
+      setWorld(i, matrix) {
+        if (~solving && i != solving) overrides.set(i, matrix);
+        worlds[i] = matrix;
+        drawn[i] = bone(model, i) ? mul(mul(matrix, inverse(rest[i])), restDraw[i]) : matrix;
+        const m = mul(inverse(drawn[model.nodes[i].parent] ?? IDENTITY), drawn[i]);
+        if (!locals[i]?.every((v, k) => v === m[k])) {
+          locals[i] = m;
+          p.drawVersions.fill(++p.drawRevision);
+        }
+      },
+      num: (i, k, key, def) => p.num(i, `constraints.${k}.${key}`, def),
+      blend: (a, b, t, i) => blend(a, b, t, i === void 0 ? void 0 : pivot(model, i)),
+      // seam(P8-7): external per-player constraint state can invalidate the value-only signature.
+      i() {
+        signature = "";
+      }
+    };
+    contexts.set(p, ctx);
+    p.local = (i) => locals[i] ?? local(i);
+    let signature = "";
+    const solve = () => {
+      const next = JSON.stringify([
+        model.nodes.map((_, i) => local(i)),
+        p.addrs.map((a) => p.value(a))
+      ]);
+      let run = next !== signature;
+      signature = next;
+      const pass = () => {
+        overrides.clear();
+        for (const i of order) {
+          const n = model.nodes[i], parent = drawn[n.parent] ?? IDENTITY;
+          solving = i;
+          ctx.setWorld(
+            i,
+            overrides.get(i) ?? (bone(model, i) ? mul(
+              bone(model, n.parent) && !n.raw.root ? worlds[n.parent] : parent,
+              frame(i, p.num.bind(p))
+            ) : mul(parent, local(i)))
+          );
+          (n.raw.constraints ?? []).forEach((raw, k) => {
+            const t = ctx.num(i, k, "strength", 1);
+            if (!t) return;
+            const desired = constraintKinds.get(raw.kind)?.solve(ctx, i, raw, k);
+            if (desired) ctx.setWorld(i, ctx.blend(worlds[i], desired, t, i));
+          });
+        }
+        solving = -1;
+      };
+      solvePasses(ctx, () => {
+        if (run) pass();
+        run = true;
+      });
+    };
+    ctx.solve = solve;
+    solve();
+    return nested;
+  };
+  model.afterStep = (p) => {
+    previousStep?.(p);
+    contexts.get(p).solve();
+  };
+}
+export {
+  bone,
+  contexts,
+  install,
+  inverse,
+  pivot
+};

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

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

package/modules/rig/core/svg.js

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

package/modules/rig/manifest.d.ts

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

package/modules/rig/manifest.js

@@ -0,0 +1,58 @@
+const after = ["layout"];
+var manifest_default = {
+  ...{
+    name: "rig",
+    summary: "Rigging: bones and ordered transform constraints (copy position, rotation, scale, transform; distance).",
+    after: [],
+    core: { entry: "core/all.ts", export: "rig", svg: "core/svg.ts", svgExport: "rigSVG" },
+    web: [
+      { name: "rig", budget: 3072, heavy: true },
+      { name: "rig-origin", budget: 896, heavy: true, over: "rig" },
+      { name: "rig-distance", budget: 512, heavy: true, over: "rig" },
+      { name: "markup-rig", budget: 384, over: "markup", authoring: true }
+    ],
+    adapters: {
+      "packages/core/src/modules/rig/index.ts": "core/index.ts",
+      "packages/core/src/modules/rig/svg.ts": "core/svg.ts",
+      "packages/markup/src/rig.ts": "markup/index.ts",
+      "packages/web/src/rig.ts": "web/index.ts",
+      "packages/web/src/rig-origin.ts": "web/origin.ts",
+      "packages/web/src/rig-distance.ts": "web/distance.ts",
+      "packages/web/src/markup-rig.ts": "web/markup.ts"
+    },
+    exports: {
+      "core:./rig": "packages/core/src/modules/rig/index.ts",
+      "markup:./rig": "packages/markup/src/rig.ts",
+      "web:./rig": "packages/web/src/rig.ts",
+      "web:./rig-origin": "packages/web/src/rig-origin.ts",
+      "web:./rig-distance": "packages/web/src/rig-distance.ts",
+      "web:./markup-rig": "packages/web/src/markup-rig.ts"
+    },
+    tests: [
+      "modules/rig/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts",
+      "packages/markup/test/compile.test.ts",
+      "packages/markup/test/decompile.test.ts"
+    ],
+    conformance: [
+      "rigging-bone-chains",
+      "rigging-root-bones",
+      "rigging-constraint-order",
+      "rigging-constraint-strength",
+      "rigging-translation",
+      "rigging-rotation",
+      "rigging-scale",
+      "rigging-transform",
+      "rigging-distance-closer",
+      "rigging-distance-further",
+      "rigging-distance-exact"
+    ],
+    docs: ["spec/SPEC.md"]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

package/modules/rig/markup/elements.d.ts

@@ -0,0 +1,4 @@
+import type { ConstraintKind } from '../core/api.js';
+import type { ElementForm } from '../../../packages/core/src/registry.js';
+/** Authoring descriptors; no constraint-child machinery is paid for by a JSON scene. */
+export declare function constraintElements(kinds: ReadonlyMap<string, ConstraintKind>): Record<string, ElementForm>;

package/modules/rig/markup/elements.js

@@ -0,0 +1,35 @@
+function constraintElements(kinds) {
+  return Object.fromEntries(
+    [...kinds.values()].map((c) => [
+      c.kind.replace(/[A-Z]/g, (v) => "-" + v.toLowerCase()),
+      {
+        shape: {
+          k: "obj",
+          p: {
+            strength: { k: "num", min: 0, max: 1 },
+            ...Object.fromEntries(
+              Object.entries(c.shape.p).map(([key, value]) => [
+                key,
+                {
+                  ...value,
+                  markup: value.markup ?? key.replace(/[A-Z]/g, (v) => "-" + v.toLowerCase())
+                }
+              ])
+            )
+          },
+          req: c.shape.req
+        },
+        values: { kind: c.kind },
+        target: {
+          attribute: "into",
+          default: "constraints",
+          choices: ["constraints"],
+          array: true
+        }
+      }
+    ])
+  );
+}
+export {
+  constraintElements
+};

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

@@ -0,0 +1,5 @@
+import type { Compiler } from '../../../packages/markup/src/compile.js';
+import type { Element } from '../../../packages/markup/src/xml.js';
+export declare const rigMarkup: {
+    node(c: Compiler, _e: Element, children: Element[], o: Record<string, unknown>, p: string): Element[];
+};

package/modules/rig/markup/index.js

@@ -0,0 +1,13 @@
+const rigMarkup = {
+  node(c, _e, children, o, p) {
+    return children.filter((child) => {
+      if (!c.elements[child.name]?.values?.kind) return true;
+      const list = o.constraints ??= [];
+      list.push(c.build(child, p + "/constraints/" + list.length));
+      return false;
+    });
+  }
+};
+export {
+  rigMarkup
+};

package/modules/rig/web/distance.d.ts

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

package/modules/rig/web/distance.js

@@ -0,0 +1,11 @@
+import "./index.js";
+import { registerDistance } from "../core/distance.js";
+customElements.get("anima-icon").registerModule({
+  name: "rigdistance",
+  after: ["rig"],
+  entries: [],
+  init(registry) {
+    registerDistance(registry.get("rig").registerConstraint);
+    return this;
+  }
+});

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

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

package/modules/rig/web/index.js

@@ -0,0 +1,5 @@
+import { rig } from "../core/index.js";
+import { rigSVG } from "../core/svg.js";
+import "../../../packages/web/src/index.js";
+customElements.get("anima-icon").registerModule(rig);
+customElements.get("anima-icon").registerSVGBackend("rig", rigSVG);

package/modules/rig/web/markup.d.ts

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

package/modules/rig/web/markup.js

@@ -0,0 +1,29 @@
+import { constraintElements } from "../markup/elements.js";
+import { rigMarkup } from "../markup/index.js";
+import "../../../packages/web/src/markup.js";
+const Icon = customElements.get("anima-icon");
+Icon.registerMarkup("paint", {
+  ...Icon.markupHooks.paint,
+  nodes: (c) => Object.keys(c.elements).filter((k) => c.elements[k].target)
+});
+Icon.registerMarkup("text", Icon.markupHooks.text ?? rigMarkup);
+Icon.registerModule({
+  name: "rigmarkup",
+  after: ["rig"],
+  entries: [],
+  init(registry) {
+    const kinds = registry.get("rig")?.kinds ?? /* @__PURE__ */ new Map();
+    return {
+      ...this,
+      entries: [
+        {
+          target: "node",
+          shapes: {},
+          get elements() {
+            return constraintElements(kinds);
+          }
+        }
+      ]
+    };
+  }
+});

package/modules/rig/web/origin.d.ts

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

package/modules/rig/web/origin.js

@@ -0,0 +1,11 @@
+import "./index.js";
+import { installOrigin } from "../core/origin.js";
+customElements.get("anima-icon").registerModule({
+  name: "rigorigin",
+  after: ["rig", "bind"],
+  entries: [],
+  init(registry) {
+    installOrigin(registry.get("rig").origin, registry.get("bind"));
+    return this;
+  }
+});

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

@@ -0,0 +1,11 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { Player } from '../../../packages/core/src/player.js';
+type State = {
+    x: number;
+    y: number;
+    maxX: number;
+    maxY: number;
+};
+export declare function scrollState(player: Player, node: number, k: number): State | undefined;
+export declare const scroll: Module;
+export {};