animl 0.0.0-stage → 0.1.0

package/modules/scroll/core/index.js

@@ -0,0 +1,261 @@
+import { drawFrame } from "../../../packages/core/src/draw.js";
+import { apply, clamp, IDENTITY, invert, mul } from "../../../packages/core/src/geom.js";
+import { flatten, parsePath } from "../../../packages/core/src/path.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { nodePointer } from "../../components/core/node-pointer.js";
+import {
+  compose,
+  decompose,
+  registerConstraint,
+  valueProviders
+} from "../../rig/core/api.js";
+import { after } from "../manifest.js";
+const states = /* @__PURE__ */ new WeakMap();
+const models = /* @__PURE__ */ new WeakMap();
+const queued = /* @__PURE__ */ new WeakMap();
+const drags = /* @__PURE__ */ new WeakMap();
+const decorated = /* @__PURE__ */ new WeakSet();
+const number = { k: "num" };
+const key = (node, k) => node + ":" + k;
+function geometryBox(g) {
+  if (!g) return;
+  if (g.r !== void 0) return [g.cx - g.r, g.cy - g.r, 2 * g.r, 2 * g.r];
+  if (g.width !== void 0) return [g.x ?? 0, g.y ?? 0, g.width, g.height ?? 0];
+  if (g.d !== void 0) {
+    const pts = flatten(parsePath(g.d)).flatMap((p) => p.pts);
+    if (!pts.length) return;
+    const xs = pts.filter((_, i) => !(i & 1)), ys = pts.filter((_, i) => i & 1), x = Math.min(...xs), y = Math.min(...ys);
+    return [x, y, Math.max(...xs) - x, Math.max(...ys) - y];
+  }
+}
+function bounds(p, root) {
+  const n = p.model.nodes[root];
+  if (n.type === "layout") {
+    const b = p.layoutBox?.(n.id);
+    if (b) return [b.x, b.y, b.width, b.height];
+  }
+  const frame = drawFrame(p), points = [];
+  const visit = (i, m) => {
+    const box = geometryBox(frame.nodes[i]?.geometry);
+    if (box) {
+      const [x2, y2, w, h] = box;
+      points.push(apply(m, x2, y2), apply(m, x2 + w, y2), apply(m, x2, y2 + h), apply(m, x2 + w, y2 + h));
+    }
+    for (const child of p.model.nodes[i].children)
+      visit(child, mul(m, frame.nodes[child]?.transform ?? IDENTITY));
+  };
+  visit(root, IDENTITY);
+  if (!points.length) return;
+  const xs = points.map((q) => q[0]), ys = points.map((q) => q[1]), x = Math.min(...xs), y = Math.min(...ys);
+  return [x, y, Math.max(...xs) - x, Math.max(...ys) - y];
+}
+function metrics(ctx, node, raw) {
+  const viewport = ctx.model.ids.get(raw.viewport), content = bounds(ctx.player, node), view = viewport === void 0 ? void 0 : bounds(ctx.player, viewport);
+  return {
+    content,
+    view,
+    max: [
+      Math.max(0, (content?.[2] ?? 0) - (view?.[2] ?? 0)),
+      Math.max(0, (content?.[3] ?? 0) - (view?.[3] ?? 0))
+    ]
+  };
+}
+function driven(p, node, k) {
+  const w = p.writes(), at = p.model.nodes[node].id + `.constraints.${k}.offset`;
+  return [w.includes(at + "X"), w.includes(at + "Y")];
+}
+function current(ctx, node, raw, k) {
+  let map = states.get(ctx.player);
+  if (!map) states.set(ctx.player, map = /* @__PURE__ */ new Map());
+  const id = key(node, k), old = map.get(id), [maxX, maxY] = metrics(ctx, node, raw).max, [drivenX, drivenY] = driven(ctx.player, node, k), axis = raw.axis ?? "both", x = axis === "y" ? 0 : clamp(drivenX || !old ? ctx.num(node, k, "offsetX", raw.offsetX ?? 0) : old.x, 0, maxX), y = axis === "x" ? 0 : clamp(drivenY || !old ? ctx.num(node, k, "offsetY", raw.offsetY ?? 0) : old.y, 0, maxY), next = { x, y, maxX, maxY };
+  map.set(id, next);
+  return next;
+}
+function contains(p, node, x, y) {
+  const n = p.model.nodes[node], box = bounds(p, node);
+  if (!box) return false;
+  const parent = n.parent, matrix = n.type === "layout" ? parent < 0 ? IDENTITY : p.world(parent) : p.world(node), inv = invert(matrix);
+  if (!inv) return false;
+  const point = apply(inv, x, y);
+  return point[0] >= box[0] && point[1] >= box[1] && point[0] <= box[0] + box[2] && point[1] <= box[1] + box[3];
+}
+function measurable(model, node) {
+  const n = model.nodes[node], type = n.type;
+  if (type === "layout") return true;
+  if (!["group", "bone", "posepad", "repeat"].includes(type)) return true;
+  return n.children.some((child) => measurable(model, child));
+}
+function move(p, spec, dx, dy) {
+  if (spec.raw.interactive === false) return false;
+  const state = states.get(p)?.get(key(spec.node, spec.k));
+  if (!state) return false;
+  let q = queued.get(p);
+  if (!q) queued.set(p, q = /* @__PURE__ */ new Map());
+  const old = q.get(key(spec.node, spec.k)) ?? [state.x, state.y], axis = spec.raw.axis ?? "both", [drivenX, drivenY] = driven(p, spec.node, spec.k), x = axis === "y" ? 0 : drivenX ? old[0] : clamp(old[0] + dx, 0, state.maxX), y = axis === "x" ? 0 : drivenY ? old[1] : clamp(old[1] + dy, 0, state.maxY);
+  if (x === old[0] && y === old[1]) return false;
+  q.set(key(spec.node, spec.k), [x, y]);
+  return true;
+}
+function moveThumb(p, thumb, x0, y0, x1, y1) {
+  const spec = thumb.scroll, state = states.get(p)?.get(key(spec.node, spec.k)), axis = thumb.raw.axis === "x" ? 0 : 1, trackBox = bounds(p, thumb.track), thumbBox = bounds(p, thumb.node), viewBox = bounds(p, spec.viewport), contentBox = bounds(p, spec.node);
+  if (!state || !trackBox || !thumbBox || !viewBox || !contentBox) return false;
+  const track = trackBox[axis + 2], authored = thumbBox[axis + 2], viewport = viewBox[axis + 2], content = contentBox[axis + 2], length = thumb.raw.resize ? Math.min(track, Math.max(authored, content ? track * viewport / content : track)) : authored, travel = track - length, max = axis ? state.maxY : state.maxX, inv = invert(p.world(thumb.track));
+  if (!travel || !max || !inv) return false;
+  const a = apply(inv, x0, y0), b = apply(inv, x1, y1), delta = (b[axis] - a[axis]) / travel * max;
+  return move(p, spec, axis ? 0 : delta, axis ? delta : 0);
+}
+function applyQueued(p) {
+  const q = queued.get(p);
+  if (!q?.size) return;
+  const map = states.get(p);
+  for (const [id, [x, y]] of q) {
+    const state = map?.get(id);
+    if (state) {
+      state.x = x;
+      state.y = y;
+    }
+  }
+  q.clear();
+  activeRig?.context(p)?.i();
+}
+function installInput(player, controller) {
+  if (decorated.has(controller)) return controller;
+  decorated.add(controller);
+  const pointer = controller.pointer.bind(controller), scroll2 = controller.scroll.bind(controller);
+  controller.pointer = (kind, x = 0, y = 0, options = {}) => {
+    const id = options.id ?? 0, specs = models.get(player.model), active = drags.get(player) ?? /* @__PURE__ */ new Map(), previous = active.get(id);
+    let moved = false;
+    if (kind === "down" && (options.button ?? 0) === 0 && specs) {
+      const thumb = [...specs.thumbs].reverse().find((s) => contains(player, s.node, x, y)), spec = thumb?.scroll ?? [...specs.scrolls].reverse().find((s) => contains(player, s.viewport, x, y));
+      if (spec && spec.raw.interactive !== false) {
+        active.set(id, { scroll: spec, thumb, x, y });
+        drags.set(player, active);
+      }
+    } else if (kind === "move" && previous) {
+      moved = previous.thumb ? moveThumb(player, previous.thumb, previous.x, previous.y, x, y) : move(player, previous.scroll, x - previous.x, y - previous.y);
+      previous.x = x;
+      previous.y = y;
+    } else if (kind !== "move") active.delete(id);
+    return pointer(kind, x, y, options) || moved;
+  };
+  controller.scroll = (x, y, dx, dy, options = {}) => {
+    const specs = models.get(player.model), spec = specs && [...specs.scrolls].reverse().find((s) => contains(player, s.viewport, x, y)), moved = !!spec && move(player, spec, dx, dy);
+    return scroll2(x, y, dx, dy, options) || moved;
+  };
+  return controller;
+}
+function scrollState(player, node, k) {
+  return states.get(player)?.get(key(node, k));
+}
+let activeRig;
+const scroll = {
+  name: "scroll",
+  after,
+  entries: [],
+  init(registry, shared) {
+    activeRig = registry.get("rig");
+    const proto = shared.Player.prototype, input = proto.input;
+    if (input && !input.scroll)
+      Object.defineProperty(proto, "input", {
+        configurable: true,
+        value: Object.assign(
+          function() {
+            return installInput(this, input.call(this));
+          },
+          { scroll: true }
+        )
+      });
+    registerConstraint({
+      kind: "scroll",
+      shape: {
+        k: "obj",
+        p: {
+          viewport: { k: "str", feature: "scroll" },
+          axis: { k: "str", of: ["x", "y", "both"] },
+          offsetX: number,
+          offsetY: number,
+          interactive: { k: "bool" }
+        },
+        req: ["viewport", "axis"]
+      },
+      targets: (raw, model) => model.ids.has(raw.viewport) ? [raw.viewport] : [],
+      solve(ctx, node, raw, k) {
+        const s = current(ctx, node, raw, k);
+        return mul(ctx.world(node), [1, 0, 0, 1, -s.x, -s.y]);
+      }
+    });
+    registerConstraint({
+      kind: "scrollThumb",
+      shape: {
+        k: "obj",
+        p: {
+          scroll: { k: "str", feature: "scroll" },
+          track: { k: "str", feature: "scroll" },
+          axis: { k: "str", of: ["x", "y"] },
+          resize: { k: "bool" }
+        },
+        req: ["scroll", "track", "axis"]
+      },
+      targets: (raw) => [raw.scroll, raw.track],
+      solve(ctx, node, raw) {
+        const content = ctx.model.ids.get(raw.scroll), track = ctx.model.ids.get(raw.track);
+        if (content === void 0 || track === void 0) return;
+        const constraints = ctx.model.nodes[content].raw.constraints ?? [], k = constraints.findIndex((c) => c.kind === "scroll"), source = constraints[k];
+        if (k < 0 || !source) return;
+        const state = current(ctx, content, source, k), axis = raw.axis === "x" ? 0 : 1, trackBox = bounds(ctx.player, track), thumbBox = bounds(ctx.player, node), measure = metrics(ctx, content, source), trackLen = trackBox?.[axis + 2] ?? 0, authored = thumbBox?.[axis + 2] ?? 0, viewport = measure.view?.[axis + 2] ?? 0, contentLen = measure.content?.[axis + 2] ?? 0;
+        if (!trackBox || !thumbBox || !trackLen || !authored) return;
+        const length = raw.resize ? Math.min(
+          trackLen,
+          Math.max(authored, contentLen ? trackLen * viewport / contentLen : trackLen)
+        ) : authored, percent = axis ? state.maxY ? state.y / state.maxY : 0 : state.maxX ? state.x / state.maxX : 0, start = trackBox[axis] + (trackLen - length) * percent, values = decompose(ctx.world(node)), scale = length / authored;
+        if (raw.resize) values[axis + 3] *= scale;
+        const desired = compose(values), point = apply(desired, thumbBox[0], thumbBox[1]), target = axis ? apply(ctx.world(track), trackBox[0], start) : apply(ctx.world(track), start, trackBox[1]);
+        values[0] += target[0] - point[0];
+        values[1] += target[1] - point[1];
+        return compose(values);
+      }
+    });
+    valueProviders.set("scroll", (player, out) => {
+      for (const [id, s] of states.get(player) ?? []) {
+        const [node, k] = id.split(":").map(Number), prefix = player.model.nodes[node].id + `.constraints.${k}`;
+        out[prefix + ".percentX"] = s.maxX ? s.x / s.maxX : 0;
+        out[prefix + ".percentY"] = s.maxY ? s.y / s.maxY : 0;
+      }
+    });
+    return scroll;
+  },
+  load(model, _raw, d) {
+    if (!model.doc.requires?.includes("scroll")) return;
+    const scrolls = [];
+    for (const [node, n] of model.nodes.entries())
+      for (const [k, raw] of (n.raw.constraints ?? []).entries())
+        if (raw.kind === "scroll") {
+          const viewport = model.ids.get(raw.viewport);
+          if (viewport === void 0 || !measurable(model, viewport))
+            d.err(
+              "scroll-viewport",
+              nodePointer(model, node) + `/constraints/${k}/viewport`,
+              V && "scroll viewport is missing or has no measurable bounds",
+              V && "target a layout container or a node/subtree with rest geometry"
+            );
+          if (viewport !== void 0) scrolls.push({ node, k, raw, viewport });
+        }
+    const thumbs = [];
+    for (const [node, n] of model.nodes.entries())
+      for (const raw of n.raw.constraints ?? [])
+        if (raw.kind === "scrollThumb") {
+          const content = model.ids.get(raw.scroll), track = model.ids.get(raw.track), source = scrolls.find((s) => s.node === content);
+          if (source && track !== void 0) thumbs.push({ node, raw, scroll: source, track });
+        }
+    models.set(model, { scrolls, thumbs });
+    const previous = model.prepareInputs;
+    model.prepareInputs = (player, scope, dt) => {
+      previous?.(player, scope, dt);
+      applyQueued(player);
+    };
+  }
+};
+export {
+  scroll,
+  scrollState
+};

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

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

package/modules/scroll/core/svg.js

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

package/modules/scroll/manifest.d.ts

@@ -0,0 +1,33 @@
+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: string;
+    }[];
+    adapters: {
+        'packages/core/src/modules/scroll/index.ts': string;
+        'packages/core/src/modules/scroll/svg.ts': string;
+        'packages/markup/src/scroll.ts': string;
+        'packages/web/src/scroll.ts': string;
+    };
+    exports: {
+        'core:./scroll': string;
+        'markup:./scroll': string;
+        'web:./scroll': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/scroll/manifest.js

@@ -0,0 +1,34 @@
+const after = ["rig", "input", "layout"];
+var manifest_default = {
+  ...{
+    name: "scroll",
+    summary: "Scrolling: scroll containers with drag and wheel, clamped offsets and linked scroll thumbs.",
+    after: [],
+    core: { entry: "core/index.ts", export: "scroll", svg: "core/svg.ts", svgExport: "scrollSVG" },
+    web: [{ name: "scroll", budget: 1024, heavy: true, over: "rig" }],
+    adapters: {
+      "packages/core/src/modules/scroll/index.ts": "core/index.ts",
+      "packages/core/src/modules/scroll/svg.ts": "core/svg.ts",
+      "packages/markup/src/scroll.ts": "markup/index.ts",
+      "packages/web/src/scroll.ts": "web/index.ts"
+    },
+    exports: {
+      "core:./scroll": "packages/core/src/modules/scroll/index.ts",
+      "markup:./scroll": "packages/markup/src/scroll.ts",
+      "web:./scroll": "packages/web/src/scroll.ts"
+    },
+    tests: [
+      "modules/scroll/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts",
+      "packages/markup/test/decompile.test.ts"
+    ],
+    conformance: ["rigging-scroll"],
+    docs: ["spec/SPEC.md"]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

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

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

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

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

package/modules/scroll/web/index.js

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

package/modules/skin/capabilities/rigging-skin/registry.d.ts

@@ -0,0 +1,5 @@
+import type { ElementForm, ObjShape } from '../../../../packages/core/src/registry.js';
+import type { ModuleEntry } from '../../../../packages/core/src/modules.js';
+export declare const skinShape: ObjShape;
+export declare const skinElement: ElementForm;
+export declare const entries: ModuleEntry[];

package/modules/skin/capabilities/rigging-skin/registry.js

@@ -0,0 +1,34 @@
+const number = { k: "num", min: 0, max: 1 };
+const influences = { k: "map", of: number };
+const skinShape = {
+  k: "obj",
+  element: "skin",
+  p: {
+    bones: { k: "arr", min: 1, of: { k: "str" } },
+    weights: {
+      k: "arr",
+      min: 1,
+      of: { k: "obj", p: { point: influences, in: influences, out: influences }, req: ["point"] }
+    }
+  },
+  req: ["bones"]
+};
+const authoringShape = {
+  k: "obj",
+  p: {
+    bones: { k: "arr", min: 1, of: { k: "str" } },
+    // The structural compiler parses this attribute as one JSON value; strict validation uses skinShape.
+    weights: { k: "alt", of: [{ k: "arr", of: { k: "any" } }] }
+  },
+  req: ["bones"]
+};
+const skinElement = {
+  shape: authoringShape,
+  target: { attribute: "into", default: "skin", choices: ["skin"] }
+};
+const entries = [{ target: "node", shapes: { skin: skinShape } }];
+export {
+  entries,
+  skinElement,
+  skinShape
+};

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

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

package/modules/skin/core/all.js

@@ -0,0 +1,27 @@
+import { skin as base } from "./index.js";
+import { automatic } from "./auto.js";
+import { skinDash } from "./dash.js";
+import { meshRest, skinMeshPoints } from "./mesh.js";
+import { installValues } from "./values.js";
+const skin = {
+  ...base,
+  init(registry, shared) {
+    const active = base.init?.call(base, registry, shared) ?? base, extensions = active.x;
+    extensions[0] = automatic;
+    extensions[1] = meshRest;
+    extensions[2] = skinMeshPoints;
+    extensions[3] = true;
+    installValues(shared);
+    return { ...active, init: void 0, draw: skin.draw };
+  },
+  draw: {
+    ...base.draw,
+    frame(p, i, node, entry, frame) {
+      base.draw?.frame?.(p, i, node, entry, frame);
+      if (p.model.nodes[i].raw.skin) skinDash(i, node, frame);
+    }
+  }
+};
+export {
+  skin
+};

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

@@ -0,0 +1,4 @@
+import type { Player } from '../../../packages/core/src/player.js';
+import type { RigModule } from '../../rig/core/index.js';
+import type { Influence, SkinData } from './index.js';
+export declare function automatic(p: Player, node: number, key: string, point: [number, number], s: SkinData, rig: RigModule | undefined): Influence;

package/modules/skin/core/auto.js

@@ -0,0 +1,23 @@
+import { apply, IDENTITY } from "../../../packages/core/src/geom.js";
+const cache = /* @__PURE__ */ new WeakMap();
+const distance = (p, a, b) => {
+  const dx = b[0] - a[0], dy = b[1] - a[1], q = dx * dx + dy * dy, t = q ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / q)) : 0;
+  return Math.hypot(p[0] - a[0] - t * dx, p[1] - a[1] - t * dy);
+};
+function automatic(p, node, key, point, s, rig) {
+  let values = cache.get(p);
+  if (!values) cache.set(p, values = /* @__PURE__ */ new Map());
+  const hit = values.get(key);
+  if (hit) return hit;
+  const [, k, part] = key.split(":");
+  if (part === "point") point = s.rest[+k] ?? point;
+  const ctx = rig?.context(p), w0 = ctx?.rest(node) ?? p.world(node), world = apply(w0, point[0], point[1]), nearest = s.bones.map((bone) => {
+    const b = ctx?.rest(bone) ?? IDENTITY, a = apply(b, 0, 0), z = apply(b, p.model.nodes[bone].raw.length ?? 0, 0);
+    return [bone, distance(world, a, z)];
+  }).sort((a, b) => a[1] - b[1]).slice(0, 2), weighted = nearest.map(([bone, d]) => [bone, 1 / (d + 1e-3) ** 2]), sum = weighted.reduce((n, [, w]) => n + w, 0), result = weighted.map(([bone, w]) => [bone, w / sum]);
+  values.set(key, result);
+  return result;
+}
+export {
+  automatic
+};

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

@@ -0,0 +1,2 @@
+import { type DrawFrame, type DrawNode } from '../../../packages/core/src/draw.js';
+export declare function skinDash(node: number, draw: DrawNode, frame: DrawFrame): void;

package/modules/skin/core/dash.js

@@ -0,0 +1,13 @@
+import { geometryLength } from "../../../packages/core/src/draw.js";
+function skinDash(node, draw, frame) {
+  if (!draw.geometry) return;
+  const length = geometryLength(draw.geometry, frame.tree.nodes[node]);
+  for (const paint of draw.paints)
+    if (paint.dashNormalized) {
+      paint.dash = paint.dashNormalized.map((v) => v * length);
+      paint.dashOffset = (paint.dashOffsetNormalized ?? 0) * length;
+    }
+}
+export {
+  skinDash
+};

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

@@ -0,0 +1,28 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { Player } from '../../../packages/core/src/player.js';
+import type { NodeM } from '../../../packages/core/src/load.js';
+import type { RigModule } from '../../rig/core/index.js';
+export type Influence = [number, number][];
+type Weight = {
+    point: Influence;
+    in?: Influence;
+    out?: Influence;
+};
+export type SkinData = {
+    bones: number[];
+    weights?: Weight[];
+    rest: [number, number][];
+    at: string;
+};
+export type Auto = (p: Player, node: number, key: string, point: [number, number], s: SkinData, rig: RigModule | undefined) => Influence;
+export type MeshRest = (node: NodeM) => [number, number][];
+export type MeshDeform = (p: Player, node: number, xy: number[], s: SkinData, movePoint: (p: Player, node: number, k: number, part: 'point' | 'in' | 'out', point: [number, number], s: SkinData) => [number, number]) => void;
+declare const data: WeakMap<object, SkinData>;
+type Extensions = [Auto?, MeshRest?, MeshDeform?, boolean?];
+export { data };
+export declare const rigContext: (p: Player) => import("../../rig/core/api.js").RigContext | undefined;
+export type SkinModule = Module & {
+    x?: Extensions;
+};
+export declare function move(p: Player, node: number, k: number, part: 'point' | 'in' | 'out', point: [number, number], s: SkinData): [number, number];
+export declare const skin: SkinModule;